Que sont les émetteurs d'événements en Node.js

Comment fonctionne les émetteurs d'évènement et quel est leur utilité ? Une traduction de l'article What are Event Emitters?

Classé dans Pour commencer > Structure de contrôle

Traduction

En Node.js, un événement peut être décrit simplement comme une chaîne de caractères avec une fonction de rappel (callback function) correspondante. Un événement peut être “émis” (ou en d'autres termes, la fonction de rappel correspondant peut être appelée) plusieurs fois et vous pouvez choisir de n'écouter que la première fois qu'il est émis ou toutes les fois. Voici un exemple simple exécuté avec Node.js REPL :

Code :

var example_emitter = new (require('events').EventEmitter);
example_emitter.on("test", function () { console.log("test"); });
example_emitter.on("print", function (message) { console.log(message); });
example_emitter.emit("test");
example_emitter.emit("print", "message");
example_emitter.emit("unhandled");

Résultat :

> var example_emitter = new (require('events').EventEmitter);
{}
> example_emitter.on("test", function () { console.log("test"); });
{ _events: { test: [Function] } }
> example_emitter.on("print", function (message) { console.log(message); });
{ _events: { test: [Function], print: [Function] } }
> example_emitter.emit("test");
test // affiché par `console.log`
true // retour de valeur
> example_emitter.emit("print", "message");
message  // affiché par `console.log`
true  // retour de valeur
> example_emitter.emit("unhandled");
false // retour de valeur

Ceci démontre toutes les fonctionnalités de base d'un émetteur d'événements (event emmiters). La méthode on ou addListener (la méthode d'abonnement) vous permet de choisir l'événement à surveiller et la fonction de rappel à appeler. La méthode emit (méthode de déclenchement), quant à elle, vous permet d'“émettre” un événement, ce qui entraîne l'appel de toutes les fonctions de rappel enregistrées pour cet événement.

Ainsi, dans l'exemple, nous nous abonnons d'abord aux événements test et print. Ensuite, nous émettons les événements test, print et unhandled. Puisque unhandled n'a pas de fonction de rappel, il renvoie simplement false ; les deux autres exécutent tous les fonctions de rappel attachés et renvoient true.

Avec l'événement print, notez que nous passons un paramètre supplémentaire : tous les paramètres supplémentaires passés à emit sont passés à la fonction de rappel comme arguments.

Si vous utilisez la méthode once au lieu de on, une fois que la fonction de rappel est activée, elle est supprimée de la liste des fonctions de rappel. Une petite fonction pratique si vous voulez détecter uniquement la première fois qu'un événement a été émis.

Si vous voulez supprimer une fonction de rappel spécifique, vous pouvez utiliser removeListener. Si vous voulez supprimer tous les fonctions de rappel d'un événement spécifique, vous pouvez utiliser removeAllListeners.

Code :

var EventEmitter = require('events').EventEmitter,
    ee = new EventEmitter();

function callback() {
  console.log("La fonction de rappel a été effectué !");
}

ee.once("event", callback);
ee.emit("event");
ee.emit("event");

ee.on("event", callback);
ee.emit("event");
ee.emit("event");
ee.removeListener("event", callback);
ee.emit("event");

ee.on("event", callback);
ee.emit("event");
ee.removeAllListeners("event");
ee.emit("event");

Résultat :

> var ee = new (require('events').EventEmitter);
> var callback = function () { console.log("Appelée !"); }
> ee.once("event", callback);
{ _events: { event: { [Function: g] listener: [Function] } } }
> ee.emit("event");
Callbacked! // affiché par `console.log`
true
> ee.emit("event");
false

> ee.on("event", callback);
{ _events: { event: [Function] } }
> ee.emit("event");
Callbacked! // affiché par `console.log`
true
> ee.emit("event");
Callbacked! // affiché par `console.log`
true
> ee.removeListener("event", callback);
{ _events: {} }
> ee.emit("event");
false

> ee.on("event", callback);
{ _events: { event: [Function] } }
> ee.emit("event");
Appelée ! // affiché par `console.log`
true
> ee.removeAllListeners("event");
{ _events: { event: null } }
> ee.emit("event");
false

Note : si vous voulez créer plus de 10 écouteurs pour un seul événement, vous devrez appeler ee.setMaxListeners(n) où n est le nombre maximum d'auditeurs (zéro étant un nombre illimité d'auditeurs). Ceci est utilisé pour s'assurer que vous ne perdez pas accidentellement des écouteurs d'événements.