Comment utiliser les émetteurs d'événements dans Node.js

Les émetteurs d'événements sont des objets dans NodeJS qui déclenchent des événements en envoyant un message pour signaler qu'une action s'est produite.

Node.js fournit un module d'événements intégré. Il contient une classe d'émetteur d'événements qui vous permet de créer et de gérer des événements personnalisés via des fonctions de rappel.

Ici, vous apprendrez à émettre des événements, à écouter et à gérer les données d'événement et à gérer les erreurs d'événement dans NodeJS.

Émission d'événements

Le module d'événements est une partie essentielle de l'environnement côté serveur Node.js. Ainsi, vous n'avez pas besoin de l'installer, mais avant d'utiliser le Emetteur d'événement classe, vous devez importer depuis le module d'événements et l'instancier.

Ainsi:

constante EventEmitter = exiger("événements");
// Instanciation de l'EventEmitter
constante monEmetteur = nouveau EventEmitter();

Vous pouvez émettre des événements en utilisant le Emetteur d'événements émettre méthode. Le émettre la méthode prend un Nom de l'événement et un nombre arbitraire d'arguments comme paramètres.

Une fois que vous appelez le émettre méthode, il émet le passé Nom de l'événement. Ensuite, il appelle de manière synchrone chacun des écouteurs de l'événement dans l'ordre dans lequel vous les avez enregistrés, en transmettant les arguments fournis à chacun. Enfin, il revient vrai si l'événement avait des auditeurs et FAUX s'il n'y avait pas d'auditeurs.

Par exemple:

monEmetteur.emit("TestEvent", "fou", "bar", 1, 2);

Dans le bloc de code ci-dessus, vous avez passé TestEvent comme le Nom de l'événement, et "foo,” "bar,” 1, et 2 comme arguments. Lorsque le bloc de code ci-dessus s'exécute, il avertit tous les auditeurs qui écoutent le TestEvent événement. Il appellera ces auditeurs avec les arguments donnés.

À l'écoute des événements

Vous pouvez écouter les événements émis à l'aide de la Emetteur d'événements sur méthode. Le sur la méthode prend un Nom de l'événement et une fonction de rappel comme paramètres. Lorsque l'événement avec le Nom de l'événement passé dans le sur méthode est émise, elle invoque sa fonction de rappel. Cette méthode renvoie une référence au Emetteur d'événement, vous permettant d'enchaîner plusieurs appels.

Par exemple:

// Premier auditeur
monEmetteur.on("TestEvent", () => {
 console.log("TestEvent émis !!!");
}); // TestEvent Emis !!!
// Deuxième auditeur
monEmetteur.on("TestEvent", (...arguments) => {
 args = args.join(", ");
console.enregistrer(`Evénement émis avec les arguments suivants: ${args}`);
}); // Evénement émis avec les arguments suivants: foo, bar, 1, 2
monEmetteur.emit("TestEvent", "fou", "bar", 1, 2);

Dans le bloc de code ci-dessus, lorsque le TestEvent événement émet, les écouteurs de l'événement invoqueront leurs fonctions de rappel. Les auditeurs réagiront dans l'ordre dans lequel vous les avez enregistrés, ce qui signifie que le rappel du "premier auditeur" s'exécutera avant le second, et ainsi de suite.

Vous pouvez modifier ce comportement à l'aide de la Emetteur d'événements prependListener méthode. Cette méthode prend les mêmes paramètres que la sur méthode. La différence est que cette méthode réagit d'abord à l'événement, quelle que soit l'heure à laquelle vous l'enregistrez.

Par exemple:

monEmetteur.on("TestEvent", () => {
 console.log("TestEvent émis !!!");
});
monEmetteur.prependListener("TestEvent", () => {
 console.log("Exécute en premier")
})
// console.log (myEmitter.listeners("TestEvent"));
monEmetteur.emit("TestEvent", "fou", "bar", 1, 2);

Lorsque le bloc de code ci-dessus s'exécute, "Executes first" sera d'abord enregistré dans la console, suivi de "TestEvent Emitted !!!" quel que soit l'ordre dans lequel vous les avez enregistrés en raison de la prependListener méthode.

Si vous enregistrez plusieurs auditeurs avec le prependListener méthode, ils s'exécuteront dans l'ordre du dernier au premier.

Notez la disposition de l'émetteur et des auditeurs. Les auditeurs viennent toujours avant l'émetteur. Cette disposition est due au fait que les auditeurs doivent déjà écouter l'événement avant que l'émetteur ne l'émette.

Pour le contexte, considérez le bloc de code ci-dessous :

monEmetteur.emit("TestEvent", "fou", "bar", 1, 2);
monEmetteur.on("TestEvent", () => {
 console.log("TestEvent émis !!!");
}); 

Si vous exécutez le bloc de code ci-dessus, rien ne se passe car, au moment où l'émetteur a émis l'événement, aucun écouteur n'écoutait l'événement.

Écouter les événements une fois

Selon vos besoins, vous devrez peut-être gérer certains événements une seule fois dans le cycle de vie de votre application. Vous pouvez y parvenir en utilisant le Emetteur d'événements une fois méthode.

Cette méthode prend les mêmes arguments que sur méthode et fonctionne de manière similaire. La seule différence est que les auditeurs inscrits auprès du une fois La méthode n'écoute l'événement qu'une seule fois.

Par exemple:

monEmetteur.une fois("Seul événement", () => {
 console.log("Événement géré une fois");
});
monEmetteur.emit("Seul événement"); // Evénement géré une seule fois
monEmetteur.emit("Seul événement"); // Ignoré
monEmetteur.emit("Seul événement"); // Ignoré

L'exécution du bloc de code n'enregistrera qu'une seule fois « Événement géré une fois » dans la console, quelle que soit la fréquence à laquelle l'émetteur émet l'événement.

Les auditeurs inscrits au une fois réagissent à l'événement dans l'ordre dans lequel vous les enregistrez. Vous pouvez modifier ce comportement à l'aide de la prependOnceListener méthode, qui fonctionne comme prependListener. La seule différence est que les auditeurs inscrits auprès du une fois La méthode n'écoute l'événement qu'une seule fois.

Gestion des erreurs avec les émetteurs d'événements

Vous devriez prendre soin de gérer les erreurs JavaScript de manière appropriée et les écouteurs d'événements ne font pas exception. Les erreurs non gérées de leur part entraîneront la fermeture du processus Node.js et le blocage de votre application.

Pour gérer un événement d'erreur, au moins un des écouteurs de l'événement doit avoir son Nom de l'événement mis à erreur.

Par exemple:

monEmetteur.on("erreur", (erreur) => {
console.erreur(`Erreur: ${erreur}`);
});

Le fait qu'un écouteur gère une erreur potentielle, comme dans le bloc de code ci-dessus, empêchera l'application de planter lorsqu'une erreur se produit.

Par exemple:

monEmetteur.emit("erreur", nouvelle erreur("C'est une erreur"));

L'exécution du bloc de code ci-dessus enregistrera "Ceci est une erreur" dans la console car un écouteur gère les événements d'erreur.

Gestion des écouteurs d'événements

Le Emetteur d'événement La classe a plusieurs méthodes qui vous permettent de manipuler et de gérer les écouteurs d'événements. Vous pouvez obtenir les écouteurs d'un événement, les supprimer et définir le nombre maximum d'écouteurs pour un événement.

Voici un tableau contenant Emetteur d'événement méthodes avec lesquelles vous pouvez manipuler les écouteurs d'événement :

Vous ne pouvez appeler ces méthodes que sur un Emetteur d'événement exemple.

Par exemple:

monEmetteur.removeListener("TestEvent");

Le bloc de code ci-dessus supprime un seul écouteur pour le TestEvent événement.

L'importance des émetteurs d'événements

Node.js adopte le paradigme de la programmation pilotée par les événements avec sa prise en charge des émetteurs et des auditeurs d'événements. La programmation pilotée par les événements est l'une des raisons pour lesquelles les programmes Node.js sont plus rapides et plus simples que certaines alternatives. Vous pouvez facilement synchroniser plusieurs événements, ce qui améliore l'efficacité.