Jaki jest prawidłowy sposób komunikacji między kontrolerami w AngularJS?

Jaki jest właściwy sposób komunikacji między kontrolerami?

Obecnie używam okropnej krówki obejmującej window:

function StockSubgroupCtrl($scope, $http) {
    $scope.subgroups = [];
    $scope.handleSubgroupsLoaded = function(data, status) {
        $scope.subgroups = data;
    }
    $scope.fetch = function(prod_grp) {
        $http.get('/api/stock/groups/' + prod_grp + '/subgroups/').success($scope.handleSubgroupsLoaded);
    }
    window.fetchStockSubgroups = $scope.fetch;
}

function StockGroupCtrl($scope, $http) {
    ...
    $scope.select = function(prod_grp) {
        $scope.selectedGroup = prod_grp;
        window.fetchStockSubgroups(prod_grp);
    }
}

Edycja : Problem rozwiązany w tej odpowiedzi został rozwiązany w wersji angular.js w wersji 1.2.7 . $broadcastteraz unika bulgotania się nad niezarejestrowanymi zakresami i działa tak szybko, jak $ emit.

Teraz możesz:

• użyj $broadcastz$rootScope
• słuchaj za pomocą $on lokalnego,$scope który musi wiedzieć o wydarzeniu

Oryginalna odpowiedź poniżej

Radzę nie używać $rootScope.$broadcast+, $scope.$onale raczej $rootScope.$emit+ $rootScope.$on. To pierwsze może powodować poważne problemy z wydajnością, o czym wspomniał @numan. Dzieje się tak, ponieważ wydarzenie rozbije się na wszystkie zakresy.

Jednak to ostatnie (użycie $rootScope.$emit+ $rootScope.$on) nie cierpi z tego powodu i dlatego może być używane jako szybki kanał komunikacji!

Z dokumentacji kątowej $emit:

Wysyła nazwę zdarzenia w górę poprzez hierarchię zasięgu, powiadamiając zarejestrowanego

Ponieważ nie ma powyższego zakresu $rootScope, nie ma miejsca na bulgotanie. Używanie $rootScope.$emit()/ $rootScope.$on()jako EventBus jest całkowicie bezpieczne .

Jest jednak jedna gotcha, gdy używasz go z poziomu kontrolerów. Jeśli łączysz się bezpośrednio $rootScope.$on()z kontrolerem, musisz samodzielnie usunąć powiązanie, gdy lokalny $scopezostanie zniszczony. Wynika to z faktu, że kontrolery (w przeciwieństwie do usług) mogą być wielokrotnie tworzone przez cały czas istnienia aplikacji, co powoduje zsumowanie powiązań, co ostatecznie spowoduje przeciek pamięci w całym miejscu :)

Aby wyrejestrować, tylko słuchać na swojej $scope„s $destroyzdarzenia, a następnie wywołać funkcję, który został zwrócony przez $rootScope.$on.

angular
    .module('MyApp')
    .controller('MyController', ['$scope', '$rootScope', function MyController($scope, $rootScope) {

            var unbind = $rootScope.$on('someComponent.someCrazyEvent', function(){
                console.log('foo');
            });

            $scope.$on('$destroy', unbind);
        }
    ]);

Powiedziałbym, że tak naprawdę nie jest to kwestia specyficzna pod kątem, ponieważ dotyczy to również innych implementacji EventBus, że musisz oczyścić zasoby.

W takich przypadkach możesz jednak ułatwić sobie życie. Na przykład, możesz małpować łatkę $rootScopei dać jej $onRootScopesubskrypcję zdarzeń emitowanych na, $rootScopeale także bezpośrednio czyści program obsługi, gdy lokalny $scopezostanie zniszczony.

Najczystszym sposobem na załatanie małpy w $rootScopecelu zapewnienia takiej $onRootScopemetody byłoby zastosowanie dekoratora (blok uruchamiania prawdopodobnie zrobi to dobrze, ale pssst, nie mów nikomu)

Aby upewnić się, że $onRootScopewłaściwość nie pojawi się nieoczekiwanie podczas wyliczania ponad $scope, używamy Object.defineProperty()i ustawiamy enumerablena false. Pamiętaj, że możesz potrzebować podkładki ES5.

angular
    .module('MyApp')
    .config(['$provide', function($provide){
        $provide.decorator('$rootScope', ['$delegate', function($delegate){

            Object.defineProperty($delegate.constructor.prototype, '$onRootScope', {
                value: function(name, listener){
                    var unsubscribe = $delegate.$on(name, listener);
                    this.$on('$destroy', unsubscribe);

                    return unsubscribe;
                },
                enumerable: false
            });


            return $delegate;
        }]);
    }]);

Dzięki tej metodzie kod kontrolera z góry można uprościć w celu:

angular
    .module('MyApp')
    .controller('MyController', ['$scope', function MyController($scope) {

            $scope.$onRootScope('someComponent.someCrazyEvent', function(){
                console.log('foo');
            });
        }
    ]);

Dlatego jako ostateczny wynik tego wszystkiego radzę użyć $rootScope.$emit+ $scope.$onRootScope.

Przy okazji, staram się przekonać zespół kątowy do rozwiązania problemu w rdzeniu kątowym. Trwa dyskusja tutaj: https://github.com/angular/angular.js/issues/4574

Oto jsperf, który pokazuje, jak duży wpływ $broadcastna stół przynosi porządny scenariusz w zaledwie 100 $scope.

http://jsperf.com/rootscope-emit-vs-rootscope-broadcast

Najważniejszą odpowiedzią było obejście problemu Angular, który już nie istnieje (przynajmniej w wersjach> 1.2.16 i „prawdopodobnie wcześniej”), jak wspomniał @zumalifeguard. Ale nadal czytam wszystkie te odpowiedzi bez faktycznego rozwiązania.

Wydaje mi się, że odpowiedź powinna być teraz

• użyj $broadcastz$rootScope
• słuchaj za pomocą $on lokalnego,$scope który musi wiedzieć o wydarzeniu

Więc opublikować

// EXAMPLE PUBLISHER
angular.module('test').controller('CtrlPublish', ['$rootScope', '$scope',
function ($rootScope, $scope) {

  $rootScope.$broadcast('topic', 'message');

}]);

I subskrybuj

// EXAMPLE SUBSCRIBER
angular.module('test').controller('ctrlSubscribe', ['$scope',
function ($scope) {

  $scope.$on('topic', function (event, arg) { 
    $scope.receiver = 'got your ' + arg;
  });

}]);

Plunkers

• Zwykła składnia $ scope (jak widać powyżej)
• Nowy Controller As składnia

Jeśli zarejestrujesz słuchacza na poziomie lokalnym $scope, to zostanie zniszczony automatycznie przez $destroysiebie , gdy wiąże się kontroler zostanie usunięty.

Użycie $ rootScope. $ Broadcast i $ scope. $ On do komunikacji PubSub.

Zobacz także ten post: AngularJS - Komunikacja między kontrolerami

Ponieważ definProperty ma problem ze zgodnością przeglądarki, myślę, że możemy pomyśleć o korzystaniu z usługi.

angular.module('myservice', [], function($provide) {
    $provide.factory('msgBus', ['$rootScope', function($rootScope) {
        var msgBus = {};
        msgBus.emitMsg = function(msg) {
        $rootScope.$emit(msg);
        };
        msgBus.onMsg = function(msg, scope, func) {
            var unbind = $rootScope.$on(msg, func);
            scope.$on('$destroy', unbind);
        };
        return msgBus;
    }]);
});

i użyj go w kontrolerze w następujący sposób:

• kontroler 1

  function($scope, msgBus) {
      $scope.sendmsg = function() {
          msgBus.emitMsg('somemsg')
      }
  }

• kontroler 2

  function($scope, msgBus) {
      msgBus.onMsg('somemsg', $scope, function() {
          // your logic
      });
  }

GridLinked opublikował rozwiązanie PubSub , które wydaje się być całkiem dobrze zaprojektowane. Serwis można znaleźć tutaj .

Również schemat ich obsługi:

W rzeczywistości użycie emisji i emisji jest nieefektywne, ponieważ zdarzenie przesuwa się w górę iw dół hierarchii zasięgu, co może łatwo zmienić się w butelkę wydajności dla złożonej aplikacji.

Sugerowałbym skorzystać z usługi. Oto jak niedawno wdrożyłem go w jednym z moich projektów - https://gist.github.com/3384419 .

Podstawowy pomysł - zarejestruj autobus pubowy / eventowy jako usługę. Następnie wstrzyknij ten eventbus tam, gdzie trzeba subskrybować lub publikować wydarzenia / tematy.

Korzystając z metod get i set w ramach usługi, można bardzo łatwo przekazywać wiadomości między kontrolerami.

var myApp = angular.module("myApp",[]);

myApp.factory('myFactoryService',function(){


    var data="";

    return{
        setData:function(str){
            data = str;
        },

        getData:function(){
            return data;
        }
    }


})


myApp.controller('FirstController',function($scope,myFactoryService){
    myFactoryService.setData("Im am set in first controller");
});



myApp.controller('SecondController',function($scope,myFactoryService){
    $scope.rslt = myFactoryService.getData();
});

w HTML HTML możesz to sprawdzić w ten sposób

<div ng-controller='FirstController'>  
</div>

<div ng-controller='SecondController'>
    {{rslt}}
</div>

Jeśli chodzi o oryginalny kod - wygląda na to, że chcesz udostępnić dane między zakresami. Aby udostępnić Dane lub Stan pomiędzy $ scope, dokumenty sugerują skorzystanie z usługi:

• Aby uruchomić kod bezstanowy lub stanowy współużytkowany przez kontrolery - Zamiast tego użyj usług kątowych.
• Aby utworzyć instancję lub zarządzać cyklem życia innych komponentów (na przykład, aby utworzyć instancje usługi).

Ref: Angular Docs link tutaj

Właściwie zacząłem używać Postal.js jako magistrali komunikatów między kontrolerami.

Ma wiele zalet, takich jak szyna komunikatów, takich jak powiązania w stylu AMQP, sposób, w jaki poczta może zintegrować w / iFrame i gniazda sieciowe, i wiele innych rzeczy.

Użyłem dekoratora, żeby skonfigurować pocztę na $scope.$bus...

angular.module('MyApp')  
.config(function ($provide) {
    $provide.decorator('$rootScope', ['$delegate', function ($delegate) {
        Object.defineProperty($delegate.constructor.prototype, '$bus', {
            get: function() {
                var self = this;

                return {
                    subscribe: function() {
                        var sub = postal.subscribe.apply(postal, arguments);

                        self.$on('$destroy',
                        function() {
                            sub.unsubscribe();
                        });
                    },
                    channel: postal.channel,
                    publish: postal.publish
                };
            },
            enumerable: false
        });

        return $delegate;
    }]);
});

Oto link do postu na blogu na ten temat ...
http://jonathancreamer.com/an-angular-event-bus-with-postal-js/

Tak to robię z Fabryką / Usługami i prostym wstrzykiwaniem zależności (DI) .

myApp = angular.module('myApp', [])

# PeopleService holds the "data".
angular.module('myApp').factory 'PeopleService', ()->
  [
    {name: "Jack"}
  ]

# Controller where PeopleService is injected
angular.module('myApp').controller 'PersonFormCtrl', ['$scope','PeopleService', ($scope, PeopleService)->
  $scope.people = PeopleService
  $scope.person = {} 

  $scope.add = (person)->
    # Simply push some data to service
    PeopleService.push angular.copy(person)
]

# ... and again consume it in another controller somewhere...
angular.module('myApp').controller 'PeopleListCtrl', ['$scope','PeopleService', ($scope, PeopleService)->
  $scope.people = PeopleService
]

Podobał mi się sposób $rootscope.emitwykorzystania komunikacji wewnętrznej. Sugeruję czyste i wydajne rozwiązanie bez zanieczyszczania globalnej przestrzeni.

module.factory("eventBus",function (){
    var obj = {};
    obj.handlers = {};
    obj.registerEvent = function (eventName,handler){
        if(typeof this.handlers[eventName] == 'undefined'){
        this.handlers[eventName] = [];  
    }       
    this.handlers[eventName].push(handler);
    }
    obj.fireEvent = function (eventName,objData){
       if(this.handlers[eventName]){
           for(var i=0;i<this.handlers[eventName].length;i++){
                this.handlers[eventName][i](objData);
           }

       }
    }
    return obj;
})

//Usage:

//In controller 1 write:
eventBus.registerEvent('fakeEvent',handler)
function handler(data){
      alert(data);
}

//In controller 2 write:
eventBus.fireEvent('fakeEvent','fakeData');

Oto szybki i brudny sposób.

// Add $injector as a parameter for your controller

function myAngularController($scope,$injector){

    $scope.sendorders = function(){

       // now you can use $injector to get the 
       // handle of $rootScope and broadcast to all

       $injector.get('$rootScope').$broadcast('sinkallships');

    };

}

Oto przykładowa funkcja do dodania w dowolnym kontrolerze rodzeństwa:

$scope.$on('sinkallships', function() {

    alert('Sink that ship!');                       

});

i oczywiście jest twój HTML:

<button ngclick="sendorders()">Sink Enemy Ships</button>

Począwszy od Angular 1.5 i skupia się na rozwoju opartym na komponentach. Zalecany sposób interakcji między komponentami polega na użyciu właściwości „need” i powiązaniach właściwości (wejścia / wyjścia).

Komponent wymagałby innego komponentu (na przykład komponentu głównego) i uzyskałby odwołanie do kontrolera:

angular.module('app').component('book', {
    bindings: {},
    require: {api: '^app'},
    template: 'Product page of the book: ES6 - The Essentials',
    controller: controller
});

Następnie możesz użyć metod komponentu głównego w komponencie potomnym:

$ctrl.api.addWatchedBook('ES6 - The Essentials');

To jest funkcja kontrolera głównego komponentu:

function addWatchedBook(bookName){

  booksWatched.push(bookName);

}

Oto pełny przegląd architektury: Komunikacja komponentowa

Możesz uzyskać dostęp do tej funkcji hello w dowolnym miejscu modułu

Kontroler jeden

 $scope.save = function() {
    $scope.hello();
  }

drugi kontroler

  $rootScope.hello = function() {
    console.log('hello');
  }

Więcej informacji tutaj

Stworzę usługę i użyję powiadomienia.

1. Utwórz metodę w usłudze powiadomień
2. Utwórz ogólną metodę rozgłaszania powiadomień w usłudze powiadomień.
3. Z kontrolera źródła wywołaj powiadomienie ServiceService.Method. Podaję również odpowiedni obiekt, aby zachować w razie potrzeby.
4. W ramach tej metody utrwalam dane w usłudze powiadomień i wywołuję rodzajową metodę powiadamiania.
5. W kontrolerze docelowym słucham ($ scope.on) zdarzenia rozgłoszeniowego i uzyskuję dostęp do danych z usługi powiadomień.

Ponieważ w dowolnym momencie usługa powiadomień jest pojedyncza, powinna być w stanie zapewnić utrwalone dane w całym systemie.

Mam nadzieję że to pomoże

Możesz skorzystać z wbudowanej usługi AngularJS $rootScopei wstrzyknąć tę usługę do obu kontrolerów. Następnie można nasłuchiwać zdarzeń uruchamianych na obiekcie $ rootScope.

$ rootScope udostępnia dwa wywoływacze zdarzeń, $emit and $broadcastktóre są odpowiedzialne za wywoływanie zdarzeń (mogą być zdarzeniami niestandardowymi) i używają $rootScope.$onfunkcji do dodawania detektora zdarzeń.

Powinieneś korzystać z Usługi, ponieważ $rootscopejest to dostęp z całej aplikacji, a to zwiększa obciążenie lub używasz rootparamów, jeśli twoich danych już nie ma.

function mySrvc() {
  var callback = function() {

  }
  return {
    onSaveClick: function(fn) {
      callback = fn;
    },
    fireSaveClick: function(data) {
      callback(data);
    }
  }
}

function controllerA($scope, mySrvc) {
  mySrvc.onSaveClick(function(data) {
    console.log(data)
  })
}

function controllerB($scope, mySrvc) {
  mySrvc.fireSaveClick(data);
}

Możesz to zrobić, używając zdarzeń kątowych, które to $ emit i $ broadcast. Zgodnie z naszą wiedzą jest to najlepszy, wydajny i skuteczny sposób.

Najpierw wywołujemy funkcję z jednego kontrolera.

var myApp = angular.module('sample', []);
myApp.controller('firstCtrl', function($scope) {
    $scope.sum = function() {
        $scope.$emit('sumTwoNumber', [1, 2]);
    };
});
myApp.controller('secondCtrl', function($scope) {
    $scope.$on('sumTwoNumber', function(e, data) {
        var sum = 0;
        for (var a = 0; a < data.length; a++) {
            sum = sum + data[a];
        }
        console.log('event working', sum);

    });
});

Możesz także użyć $ rootScope zamiast $ scope. Użyj odpowiednio kontrolera.