Pasando el alcance actual a un servicio AngularJS

¿Es correcto pasar la "corriente" $scopea un servicio AngularJS?

Estoy en la situación en la que tengo un $ service sabiendo que solo lo consume un controlador, y me gustaría tener una referencia al alcance del controlador en los métodos $ service.

¿Es esto filosóficamente correcto?

¿O sería mejor transmitir eventos al $ rootScope y luego hacer que mi controlador los escuche?

Para que el controlador sepa cuándo ocurre algo asíncrono, use las promesas angulares .

Para provocar el $apply, no necesita el alcance, puede llamar $rootScope.$apply, ya que no hay diferencia llamarlo en un alcance específico o en la raíz.

En cuanto a la lectura de la variable, sería mejor si recibiera los parámetros. Pero también podría leerlo desde un alcance como un parámetro de objeto, pero yo iría con el parámetro, eso haría que su interfaz de servicio sea mucho más clara.

Yo diría que si su funcionalidad es específica de un solo controlador, no necesita un servicio.

Las tareas de los controladores son manipular el modelo específico, mientras que un servicio debe ocuparse de tareas globales. Prefiero ceñirme a este paradigma en lugar de mezclar las cosas.

Esto es lo que dicen los doctores

Servicio

Los servicios angulares son singletons que realizan tareas específicas comunes a las aplicaciones web.

Controlador

En Angular, un controlador es una función de JavaScript (tipo / clase) que se usa para aumentar las instancias de angular Scope, excluyendo el alcance raíz.

PD: Aparte de eso, si necesita digerir, también puede inyectar $ rootScope dentro de su servicio.

Si. Puede pasar $ scope al servicio cuando lo inicializa. En el constructor de servicios, puede asignar el alcance a algo como this._scope y luego hacer referencia al alcance dentro del servicio.

angular.module('blah').controller('BlahCtrl', function($scope, BlahService) {

    $scope.someVar = 4;

    $scope.blahService = new blahService($scope);

});

angular.module('blah').factory('blahService', function() {

    //constructor
    function blahService(scope) {
        this._scope = scope;

        this._someFunction()
    }

    //wherever you'd reference the scope
    blahService.prototype._someFunction = function() {

        this._scope['someVar'] = 5;

    }

    return blahService;

});

Personalmente, creo que pasar $scopea un servicio es una mala idea , porque crea una referencia circular: el controlador depende del servicio y el servicio depende del alcance del controlador.

Además de ser confuso en términos de relaciones, cosas como esta terminan interponiéndose en el camino del recolector de basura.

Mi enfoque preferido es poner un objeto de dominio en el alcance del controlador y pasarlo al servicio. De esta manera, el servicio funciona independientemente de si se usa dentro de un controlador o tal vez dentro de otro servicio en el futuro.

Por ejemplo, si se supone que el servicio empuja y saca elementos de una matriz errors, mi código será:

var errors = [];
$scope.errors = errors;
$scope.myService = new MyService(errors);

El servicio interactúa luego con el controlador operando errors. Por supuesto, debo tener cuidado de no borrar nunca toda la referencia de la matriz, pero al final del día, eso es una preocupación general de JS.

Nunca querría usar la transmisión $applyy / o cosas similares, porque en mi humilde opinión, las buenas prácticas de OO siempre triunfarán sobre cualquier magia angular.