Change the way $rootScope.$broadcast works internally

[mcasimir]

Hi, $rootScope.$broadcast/$scope.$on is almost perfect. It make us able to use $scope.$on for global events, this is perfect since we can handle local and global events the same way and it takes care of deleting listener (freeing memory) for us when $scope is destroyed.

Compared to it $rootScope.$emit/$rootScope.$on is faster but requires us to manually clear the callback to avoid leaking memory in listener.

$rootScope.$broadcast on the contrary is a little slow, cause it traverses all active scopes to find listeners to be triggered. Is it really necessary?

Why can't we solve the same problem in a different way?

Let's try to use a map in $rootScope:

Something like:

$rootScope.
evtScopesMap = {
   evt: {scope1ref: true, scope2ref: true}
}

Listening:

function $on(evt, cb) {
// ...
$rootScope.
evtScopesMap[evt] = thisScope;
}

Broadcasting:

function broadcast(evt) {
  Object.keys(this.evtScopesMap[evt]).forEach(function(scope){
    // Iterate scope.$$listeners and $emit;
  })
}

Cleaning up

scope.destroy = function(){
   // Iterate scope.$$listeners
   // forEach event this scope is bound to:

   delete $rootScope.evtScopesMap[evt][thisScope];
}

This should make $broadcast time constant in finding scopes at a small cost of a having an hashmap with scope references in $rootScope (cost in memory is linear to active scopes count).

I apologize if I misunderstood something here.

Thank you anyway

[petebacondarwin]

We recently improved the performance of $rootScope.$broadcast considerable. See #5507
Have you looked at those?

It would be worth looking at the cost of these broadcasts with some real numbers before spending too much time trying to improve the performance. Do you have a concrete use case where $broadcast is too slow for you?

[lgalfaso]

looks like #8461 (comment) is spot on. If there is anything else remaining, please feel free to reopen the issue

[michaelhunziker]

@petebacondarwin Hi Pete, just to be clear. Could you verify the following statements?

• Fire a global event in a controller or service: $rootScope.$broadcast('MY_EVENT');
• Listen to a global event in a controller: $scope.$on('MY_EVENT', myEventHandler);
  • Question: Should we use $scope.$on or $rootScope.$on here?
• 3 Listen to a global event in a service: $rootScope.$on('MY_EVENT', myEventHandler);
  • Since we do not have a $scope in a service we need to do $rootScope.on(...)

As far as I understand I don't have to worry about any memory leak handling (deleting listeners when $scope is destroyed) with the above code, right?

[lgalfaso]

A good rule of thumb is that you should attach to the scope that follows
the same lifecycle. This is, a controller to $scope (using $on or
$onRootScope) and services to $rootScope, but avoid attaching in the later
case if possible.

[michaelhunziker]

@lgalfaso Thanks for your reply. What exactly do you mean with $onRootScope? As far as I understand this method does not really exist? (#5507 -> statement by Igor Minar: "In the light of all the performance improvements we've done since this issue was created, does it still make sense to add an api like $onRootScope?")

[lgalfaso]

What exactly do you mean with $onRootScope?

Sorry, my mistake, just remove onRootScope from the previous message.
Anyhow, the general rule applies too, even without this.