Gestion des événements dans Node.js

Dans Node.js de nombreux objets présents dans l'environnement émettent des événements, par exemple un serveur TCP émet un événement de type relier chaque fois qu'un nouveau client se connecte ou qu'un flux de fichiers émet des informations chaque fois qu'une information est lue.

En ce Node.js est ce qu'on appelle des émetteurs d'événements, qui permettent aux développeurs la possibilité de souscrire à des événements, où il souscrit une fonction rappeler qui sera invoqué à chaque fois qu'un événement dans l'émetteur d'événement se produit. Nous pouvons même créer nos propres émetteurs d'événements grâce à la pseudo-classe Émetteur d'événement.

Cependant, pour entrer avec les émetteurs d'événements, nous devons d'abord être clairs sur certains concepts, tels que certains modèles de ces fonctions, les types d'événements et même les auditeurs.

ExigencesPour réaliser les exercices proposés dans ce tutoriel nous devons disposer d'une installation fonctionnelle de Node.js dans notre système, nous pouvons jeter un œil à ce tutoriel avant de continuer à l'approfondir. Il est également important de pouvoir avoir accès à un éditeur de texte riche pour coder les exemples, nous pouvons utiliser ce avec quoi nous nous sentons à l'aise, cependant, pour sa facilité d'utilisation, nous recommandons Texte sublime o NotePad++ qui a aussi des plugins pour la syntaxe JavaScript Oui HTML.

Modèle pour les rappels

La programmation asynchrone n'utilise pas le retour de valeurs dans les fonctions pour indiquer que cette fonction vient de se terminer, mais elle invoque le fameux rappel une fois l'opération terminée pour que notre programme puisse continuer, où JavaScript Je mène à ce type de programmation, voyons un exemple dans Ne donnent pas qui lit un fichier et charge son contenu en mémoire :

 var fs = exiger ('fs'); fs.readFile ('file.txt', function (err, fileContent) {if (err) {throw err;} console.log ('File content:', fileContent.toString ());});

Ce que nous faisons ici, c'est que nous envoyons une fonction anonyme comme deuxième argument de la fonction fs.readFile, et comment pouvons-nous voir que le premier argument de la fonction de rappel est un objet d'erreur, qui aura une instance de la classe Error si une erreur se produit.

Modèle pour l'émetteur d'événement

Le style précédent fonctionne parfaitement lorsque nous voulons notifier qu'une fonction que nous exécutons termine son travail, mais dans le cas où plusieurs événements se produisent au cours de cette exécution ou plusieurs fois, ce style ne fonctionnera pas comme nous le souhaitons. Par exemple, si l'on veut être notifié à chaque fois que l'information est disponible dans la socket, une fonction de type rappeler standard ne nous aidera pas beaucoup, mais c'est là que l'émetteur d'événements peut nous aider.

L'émetteur d'événement n'est rien de plus qu'un objet qui, comme son nom l'indique, émet un événement, où un auditeur il fait partie du code qui se lie à cet émetteur et écoute certains types d'événements, tels que :

 var req = http.request (options, function (response) {response.on ("data", function (data) {console.log ("Certaines données de réponse", data);}); response.on (" end " , function () {console.log (" réponse terminée ");});}); req.end ();

Il s'agit d'un code purement explicatif, où l'on peut voir certaines des étapes pour faire une demande HTTP à un serveur distant mais cela nous permet de voir comment l'objet réponse est un émetteur d'événement, qui peut émettre non seulement Les données Oui finir mais aussi d'autres types d'événements.

Types d'événements

D'après l'exemple précédent on a pu voir que les événements émis ont toujours un type, qui est représenté par une chaîne, en l'occurrence "Les données" O "finir”, qui seront des chaînes arbitraires désignées par l'émetteur de l'événement.

L'émetteur d'événement est une interface générique qui dessert tout type d'événement, mais il existe un cas particulier dans la mise en œuvre de Ne donnent pas et c'est l'événement Erreur, où chaque événement de l'environnement émettra un événement de ce type à chaque fois qu'une erreur se produit et si le développeur choisit de ne pas écouter ce type d'événement et qu'une erreur se produit, l'émetteur d'événement le remarquera et déclenchera une exception dans ce cas . Voyons dans le code suivant comment nous pouvons simuler ce comportement :

 var em = new (require ('événements'). EventEmitter) (); em.emit ('événement1'); em.emit ('erreur', nouvelle erreur ('Mon erreur'));

Si nous l'exécutons via la console, nous pouvons voir comment Ne donnent pas nous dit que nous ne traitons pas l'erreur, générant ainsi une exception non interceptée :

Puisque nous avons vu comment les événements se comportent de manière générale, voyons comment nous utilisons l'API de l'émetteur d'événements.

Utilisation de l'API de l'émetteur d'événements

Tout objet qui implémente le modèle d'émetteur d'événements implémente une série d'événements comme nous pouvons le voir ci-dessous :

.addListener - .onCette méthode nous permet d'ajouter un écouteur à un type d'événement.
.onzeAvec cette méthode, nous pouvons lier un écouteur à un type d'événement étant donné qu'il sera appelé au moins une fois.
.removeEventListenerCette méthode nous permettra de supprimer un écouteur d'un événement donné.
.removeAllEventListenersEnfin, cette méthode nous aide à supprimer tous les écouteurs pour un type d'événement donné.
Ayant déjà vu quelle est la fonction de chacun d'eux, voyons comment nous les utilisons dans nos programmes.

Utilisation de .addListener () ou .on () dans les rappels

En spécifiant un type d'événement et une fonction rappeler, nous pouvons enregistrer l'action à entreprendre lorsqu'un événement spécifique se produit. Par exemple, si nous voulons être informés qu'une portion de données est disponible et émettre un événement de type data, nous pouvons procéder comme suit :

 fonction receiveData (données) {console.log ("Les données ont été obtenues : % j", données); } readFlow.addListener ("données", receiveData);

On peut aussi utiliser la méthode .sur () qui n'est qu'un raccourci, voyons l'équivalent du code précédent :

 fonction receiveData (données) {console.log ("Les données ont été obtenues : % j", données); } readFlow.on ("données", receiveData);

Nous pouvons même ajouter plusieurs écouteurs pour nos événements afin d'écouter le même type d'événement sur le même émetteur, par exemple :

Dans cet exemple, ce qui est fait est de lier deux fonctions à l'événement de type de données, et où une fois l'événement de données émis, les deux chaînes seront imprimées. Il est important de noter que l'émetteur de l'événement est responsable d'appeler tous les les auditeurs enregistrés pour un type d'événement, et il les appellera dans l'ordre dans lequel ils ont été enregistrés, ce qui signifie ce qui suit :

• Un écouteur ne peut pas être appelé immédiatement après l'émission de l'événement, il est possible que d'autres écouteurs soient appelés avant.

• Ne pas intercepter d'exceptions est un comportement malsain pour notre code, donc si l'un de ces écouteurs génère une erreur et n'est pas intercepté, il est possible que certains écouteurs ne soient pas appelés, ce que nous pouvons illustrer dans l'exemple suivant :

Où dans cet exemple, le deuxième écouteur ne sera pas invoqué puisque le premier a généré une erreur.

Utilisation de .removeListener ()

Si, à tout moment, nous ne voulons plus être informés des modifications apportées à un événement ou à un objet spécifique, nous pouvons arrêter de l'enregistrer en spécifiant le type d'événement et la fonction de rappel comme suit :

Utiliser .une fois ()

Dans le cas où notre application est à l'écoute d'un événement qui se produira au moins une fois ou si nous ne souhaitons qu'il ne se produise qu'une seule fois, nous pouvons utiliser .onze(), qui ajoute l'écouteur et le supprime une fois que le premier événement se produit :

Utilisation de .removeAllListeners ()

Enfin, nous pouvons supprimer tous les écouteurs pour un type d'événement particulier d'un émetteur d'événement comme suit :

 issuer.removeAllListeners (type);

Création de l'émetteur d'événement

L'émetteur d'événements nous fournit un moyen générique de créer des interfaces, puisque nous lions des événements au lieu de fonctions, ce qui rend notre programme plus flexible, même si nous voulons utiliser le modèle de Node.js Tout au long de notre application, nous pouvons créer une pseudo-classe et hériter de Émetteur d'événement comme suit:

 util = exiger ('util'); var EventEmitter = require ('événements'). var MaClasse = function () {} util.inherits (MaClasse, EventEmitter);

De cette façon, les méthodes de Émetteur d'événement Ils seront disponibles pour notre instance et nous pourrons les utiliser sans problème et de cette manière Ma classe peut émettre des événements :

 MyClass.prototype.someMethod = function () {this.emit ("événement personnalisé", "argument 1", "argument 2"); };

Ici quand une certaine méthode est appelé dans le cas de Ma classe, l'exemple émet un événement appelé événement personnalisé, où à son tour il émet deux données différentes, l'argument 1 et l'argument 2, qui seront envoyées aux écouteurs d'événement. Enfin dans les cas de Ma classe côté client, vous pouvez écouter le événement personnalisé comme suit:

 var MaClasse = new MaClasse (); MyClass.on ('événement personnalisé', fonction (str1, str2) {console.log ('événement personnalisé écouté avec les arguments str1% s et str2% s!', Str1, str2);});

Comme nous pouvons le voir, l'utilisation d'événements avec l'émetteur d'événements nous aide à communiquer avec notre application et c'est ainsi que nous avons terminé ce tutoriel, où nous avons pu aller au-delà de la programmation asynchrone et appliquer des pratiques qui nous aident à maintenir un standard et optimal modèle pour nos applications.