这就是我使用工厂/服务和简单依赖注入(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
]

由于defineProperty存在浏览器兼容性问题，我认为我们可以考虑使用服务。

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;
    }]);
});

并像这样在控制器中使用它:

控制器1 函数($scope, msgBus) { 美元的范围。Sendmsg = function() { msgBus.emitMsg(“somemsg”) ｝ ｝ 控制器2 函数($scope, msgBus) { msgBus。onMsg('somemsg'， $scope, function() { //你的逻辑 })； ｝

我喜欢$rootscope。使用Emit实现相互通信。我建议清洁和性能有效的解决方案，不污染全球空间。

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');

使用rootScope美元。$broadcast和$scope。$on PubSub通信。

另外，请参阅这篇文章:AngularJS -控制器之间的通信

你可以使用AngularJS内置服务$rootScope并将该服务注入到你的两个控制器中。 然后，您可以监听在$rootScope对象上触发的事件。

$rootScope提供了两个事件分派器$emit和$broadcast，它们负责分派事件(可能是自定义事件)，并使用$rootScope。$on函数添加事件监听器。

编辑:在这个回答中解决的问题已经在angular.js 1.2.7版本中解决了。$broadcast现在避免在未注册的作用域冒泡，并且运行速度与$emit一样快。

所以，现在你可以:

使用$rootScope中的$broadcast 从需要了解事件的本地$作用域使用$on进行监听

原始答案如下

我强烈建议不要使用$rootScope。$broadcast + $scope。$on而不是$rootScope。发出+ rootScope。美元美元。前者会导致严重的性能问题，正如@numan所提出的那样。这是因为事件会通过所有范围扩散。

然而，后者(使用$rootScope。$emit + $rootScope.$on)不会受此影响，因此可以用作快速通信通道!

来自$emit的angular文档:

通过作用域层次结构向上分发事件名称，并通知已注册对象

因为$rootScope上面没有作用域，所以不会发生冒泡。使用$rootScope.$emit()/ $rootScope.$on()作为EventBus是完全安全的。

然而，当从控制器内部使用它时，有一个问题。如果你直接从控制器中绑定到$rootScope.$on()，当你的本地$scope被破坏时，你必须自己清理绑定。这是因为控制器(与服务相反)可以在应用程序的生命周期中被实例化多次，这将导致绑定，最终在所有地方创建内存泄漏:)

要取消注册，只需监听$scope的$destroy事件，然后调用由$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);
        }
    ]);

我想说，这并不是angular特有的事情，因为它也适用于其他EventBus实现，你必须清理资源。

但是，对于这些情况，您可以让您的生活变得更轻松。例如，你可以给$rootScope打补丁，并给它一个$onRootScope，订阅在$rootScope上发出的事件，但也可以在本地$scope被破坏时直接清理处理程序。

猴子修补$rootScope以提供这样的$onRootScope方法的最干净的方法是通过装饰器(一个运行块可能也会做得很好，但pssst，不要告诉任何人)

为了确保$onRootScope属性在枚举$scope时不会出现意外情况，我们使用Object.defineProperty()并将enumerable设置为false。请记住，你可能需要一个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;
        }]);
    }]);

有了这个方法，上面的控制器代码可以简化为:

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

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

因此，作为这一切的最终结果，我强烈建议您使用$rootScope。$emit + $scope.$onRootScope。

顺便说一句，我正试图说服angular团队在angular core内部解决这个问题。这里有一个讨论:https://github.com/angular/angular.js/issues/4574

下面是一个jsperf，它展示了$broadcast在一个只有100个$scope的合适场景中所带来的性能影响。

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