Jak zrezygnować z transmisji wydarzenia w angularJS. Jak usunąć funkcję zarejestrowaną przez $ on

Zarejestrowałem mojego słuchacza na zdarzenie emisji $ za pomocą funkcji $ on

$scope.$on("onViewUpdated", this.callMe);

i chcę wyrejestrować tego odbiornika na podstawie określonej reguły biznesowej. Ale moim problemem jest to, że po zarejestrowaniu nie mogę go wyrejestrować.

Czy w AngularJS jest jakaś metoda wyrejestrowania konkretnego odbiornika? Metodą taką jak $ przy tym wyrejestrowaniu tego zdarzenia może być $ off. Opierając się na logice biznesowej, mogę powiedzieć

 $scope.$off("onViewUpdated", this.callMe);

i ta funkcja przestaje być wywoływana, gdy ktoś transmituje zdarzenie „onViewUpdated”.

Dzięki

EDYCJA : Chcę wyrejestrować słuchacza z innej funkcji. Nie jest to funkcja, w której ją rejestruję.

Musisz zapisać zwróconą funkcję i wywołać ją, aby anulować subskrypcję zdarzenia.

var deregisterListener = $scope.$on("onViewUpdated", callMe);
deregisterListener (); // this will deregister that listener

Można to znaleźć w kodzie źródłowym :) przynajmniej w wersji 1.0.4. Po prostu opublikuję pełny kod, ponieważ jest krótki

/**
  * @param {string} name Event name to listen on.
  * @param {function(event)} listener Function to call when the event is emitted.
  * @returns {function()} Returns a deregistration function for this listener.
  */
$on: function(name, listener) {
    var namedListeners = this.$$listeners[name];
    if (!namedListeners) {
      this.$$listeners[name] = namedListeners = [];
    }
    namedListeners.push(listener);

    return function() {
      namedListeners[indexOf(namedListeners, listener)] = null;
    };
},

Zobacz także dokumenty .

Patrząc na większość odpowiedzi, wydają się one zbyt skomplikowane. Angular ma wbudowane mechanizmy do wyrejestrowania.

Użyj funkcji wyrejestrowania zwróconej przez$on :

// Register and get a handle to the listener
var listener = $scope.$on('someMessage', function () {
    $log.log("Message received");
});

// Unregister
$scope.$on('$destroy', function () {
    $log.log("Unregistering listener");
    listener();
});

Ten kod działa dla mnie:

$rootScope.$$listeners.nameOfYourEvent=[];

EDYCJA: Prawidłowym sposobem na to jest odpowiedź @ LiviuT!

Zawsze możesz rozszerzyć zakres Angulara, aby umożliwić Ci usunięcie takich detektorów:

//A little hack to add an $off() method to $scopes.
(function () {
  var injector = angular.injector(['ng']),
      rootScope = injector.get('$rootScope');
      rootScope.constructor.prototype.$off = function(eventName, fn) {
        if(this.$$listeners) {
          var eventArr = this.$$listeners[eventName];
          if(eventArr) {
            for(var i = 0; i < eventArr.length; i++) {
              if(eventArr[i] === fn) {
                eventArr.splice(i, 1);
              }
            }
          }
        }
      }
}());

A oto jak to by działało:

  function myEvent() {
    alert('test');
  }
  $scope.$on('test', myEvent);
  $scope.$broadcast('test');
  $scope.$off('test', myEvent);
  $scope.$broadcast('test');

A oto kawałek tego w akcji

Po debugowaniu kodu stworzyłem własną funkcję, podobnie jak odpowiedź „blesh”. Tak właśnie zrobiłem

MyModule = angular.module('FIT', [])
.run(function ($rootScope) {
        // Custom $off function to un-register the listener.
        $rootScope.$off = function (name, listener) {
            var namedListeners = this.$$listeners[name];
            if (namedListeners) {
                // Loop through the array of named listeners and remove them from the array.
                for (var i = 0; i < namedListeners.length; i++) {
                    if (namedListeners[i] === listener) {
                        return namedListeners.splice(i, 1);
                    }
                }
            }
        }
});

więc dołączając moją funkcję do $ rootscope, jest ona teraz dostępna dla wszystkich moich kontrolerów.

i robię w moim kodzie

$scope.$off("onViewUpdated", callMe);

Dzięki

EDYCJA: Sposób AngularJS na to jest w odpowiedzi @ LiviuT! Ale jeśli chcesz wyrejestrować nasłuchiwanie w innym zakresie i jednocześnie nie chcesz tworzyć lokalnych zmiennych, aby zachować odwołania do funkcji wyrejestrowania. To możliwe rozwiązanie.

Odpowiedź @ LiviuT jest niesamowita, ale wydaje się, że wielu ludzi zastanawia się, jak ponownie uzyskać dostęp do funkcji usuwania funkcji obsługi z innego zakresu lub funkcji $, jeśli chcesz ją zniszczyć z miejsca innego niż to, w którym została utworzona. @ Рустем Мусабеков odpowiedź działa po prostu świetnie, ale nie jest bardzo idiomatyczna. (I opiera się na czymś, co powinno być prywatnym szczegółem implementacji, który może się zmienić w dowolnym momencie.) Od tego momentu staje się to bardziej skomplikowane ...

Myślę, że najłatwiejszą odpowiedzią jest po prostu przeniesienie odwołania do funkcji usuwania ( offCallMeFnw jego przykładzie) w samym module obsługi, a następnie wywołanie jej na podstawie pewnych warunków; być może argument, który dołączasz do wydarzenia, które emitujesz lub emitujesz. W ten sposób handlowcy mogą się zburzyć, kiedy tylko chcesz, gdziekolwiek chcesz, niosąc nasiona własnego zniszczenia. Tak jak:

// Creation of our handler:
var tearDownFunc = $rootScope.$on('demo-event', function(event, booleanParam) {
    var selfDestruct = tearDownFunc;
    if (booleanParam === false) {
        console.log('This is the routine handler here. I can do your normal handling-type stuff.')
    }
    if (booleanParam === true) {
        console.log("5... 4... 3... 2... 1...")
        selfDestruct();
    }
});

// These two functions are purely for demonstration
window.trigger = function(booleanArg) {
    $scope.$emit('demo-event', booleanArg);
}
window.check = function() {
    // shows us where Angular is stashing our handlers, while they exist
    console.log($rootScope.$$listeners['demo-event'])
};

// Interactive Demo:

>> trigger(false);
// "This is the routine handler here. I can do your normal handling-type stuff."

>> check();
// [function] (So, there's a handler registered at this point.)  

>> trigger(true);
// "5... 4... 3... 2... 1..."

>> check();
// [null] (No more handler.)

>> trigger(false);
// undefined (He's dead, Jim.)

Dwie myśli:

1. To świetna formuła dla programu uruchamiającego po uruchomieniu. Porzuć warunkowe i biegnij, selfDestructjak tylko zakończy się samobójcza misja.
2. Zastanawiam się, czy źródłowy zakres kiedykolwiek zostanie odpowiednio zniszczony i wyrzucony w pamięci, biorąc pod uwagę, że masz odniesienia do zmiennych zamkniętych. Trzeba by użyć miliona z nich, aby nawet mieć problem z pamięcią, ale jestem ciekawy. Jeśli ktoś ma jakikolwiek wgląd, prosimy o udostępnienie.

Zarejestruj hak, aby wypisać się ze słuchaczy, gdy składnik zostanie usunięty:

$scope.$on('$destroy', function () {
   delete $rootScope.$$listeners["youreventname"];
});  

W przypadku konieczności wielokrotnego włączania i wyłączania nasłuchiwania można utworzyć funkcję z booleanparametrem

function switchListen(_switch) {
    if (_switch) {
      $scope.$on("onViewUpdated", this.callMe);
    } else {
      $rootScope.$$listeners.onViewUpdated = [];
    }
}

Sam $ $ zwraca funkcję do wyrejestrowania

 var unregister=  $rootScope.$on('$stateChangeStart',
            function(event, toState, toParams, fromState, fromParams, options) { 
                alert('state changing'); 
            });

możesz wywołać funkcję unregister (), aby wyrejestrować tego odbiornika

Jednym ze sposobów jest po prostu zniszczenie słuchacza, gdy skończysz.

var removeListener = $scope.$on('navBarRight-ready', function () {
        $rootScope.$broadcast('workerProfile-display', $scope.worker)
        removeListener(); //destroy the listener
    })