Passer la portée actuelle à un service AngularJS

Est-il correct de transmettre le "courant" $scopeà un service AngularJS?

Je suis dans la situation où j'ai un service $ sachant qu'il est consommé par un seul contrôleur, et j'aimerais avoir une référence à la portée du contrôleur dans les méthodes $ service elles-mêmes.

Est-ce philosophiquement correct?

Ou je ferais mieux de diffuser des événements sur $ rootScope et de faire en sorte que mon contrôleur les écoute?

Pour informer le contrôleur lorsqu'un événement asynchrone se produit, utilisez les promesses angulaires .

Pour provoquer le $apply, vous n'avez pas besoin de la portée, vous pouvez appeler $rootScope.$apply, car il n'y a aucune différence en l'appelant dans une portée spécifique ou à la racine.

En ce qui concerne la lecture des variables, il serait préférable que vous receviez des paramètres. Mais vous pouvez également le lire à partir d'une portée en tant que paramètre d'objet, mais j'irais avec un paramètre, ce qui rendrait votre interface de service beaucoup plus claire.

Je dirais que si votre fonctionnalité est spécifique à un seul contrôleur, vous n'avez pas besoin d'un service.

Les tâches des contrôleurs sont de manipuler le modèle spécifique alors qu'un service doit traiter des tâches globales. Je préfère m'en tenir à ce paradigme au lieu de mélanger les choses.

C'est ce que disent les documents

Un service

Les services angulaires sont des singletons qui effectuent des tâches spécifiques communes aux applications Web

Manette

Dans Angular, un contrôleur est une fonction JavaScript (type / classe) utilisée pour augmenter les instances de Angular Scope, à l'exclusion de la portée racine.

PS: En dehors de cela, si vous avez besoin de digérer, vous pouvez également injecter le $ rootScope dans votre service.

Oui. Vous pouvez transmettre la portée $ au service lorsque vous l'initialisez. Dans le constructeur de service, vous pouvez attribuer la portée à quelque chose comme ceci._scope puis référencer la portée dans le service!

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;

});

Personnellement, je pense que passer $scopeà un service est une mauvaise idée , car cela crée une sorte de référence circulaire: le contrôleur dépend du service et le service dépend de l'étendue du contrôleur.

En plus d'être déroutants en termes de relations, des choses comme celle-ci finissent par gêner le ramasse-miettes.

Mon approche préférée consiste à placer un objet de domaine dans la portée du contrôleur et à le transmettre au service. De cette façon, le service fonctionne indépendamment du fait qu'il soit utilisé dans un contrôleur ou peut-être dans un autre service à l'avenir.

Par exemple, si le service est censé pousser et extraire des éléments d'un tableau errors, mon code sera:

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

Le service interagit alors avec le contrôleur en fonctionnant sur errors. Bien sûr, je dois faire attention à ne jamais effacer toute la référence du tableau, mais en fin de compte, c'est une préoccupation générale de JS.

Je ne voudrais jamais utiliser la diffusion $applyet / ou des choses similaires, car à mon avis, les bonnes pratiques OO l'emporteront toujours sur la magie angulaire.