Introduction et informations
http://nodejs.org/api/events.html
http://www.infoq.com/cn/articles/tyq-nodejs-event
Les événements sont le module le plus important de Node.js. Le module d'événements fournit uniquement un événement d'objet.EenteMitter. Le cœur de EventEmitter est le lancement d'événements et l'écouteur d'événements.
La plupart des modules de Node.js sont hérités du module d'événement.
Contrairement aux événements de l'arbre DOM, il n'y a pas d'activité telle que la capture de bulles, couche par couche.
EventEmitter prend en charge plusieurs auditeurs d'événements. Lorsqu'un événement est lancé, l'écouteur d'événement enregistré sur cet événement est appelé dans la séquence et les paramètres de l'événement sont passés en tant que paramètres de fonction de rappel.
Comment accéder:
La copie de code est la suivante:
exiger («événements»);
emiter.on (événement, auditeur)
La copie de code est la suivante:
/ *
Appelez le module des événements pour obtenir des événements.Eventittemiter Objet
* /
var eventEMmitter = require ('Events'). EventEMmitter;
var ee = new EventEmitter ();
/ *
EventEmitter.on (événement, auditeur) Enregistrez un auditeur pour l'événement
Paramètre 1: chaîne d'événements, nom d'événement
Paramètre 2: fonction de rappel
* /
ee.on ('some_events', fonction (foo, bar) {
console.log ("1er événement d'écoute, paramètre foo =" + foo + ", bar =" + bar);
});
console.log («premier tour»);
ee.emit ('some_events', 'wilson', 'zhong');
console.log («deuxième tour»);
ee.emit ('some_events', 'wilson', 'z');
EventEmitter.on (événement, auditeur) Exemple de code source
emiter.emit (événement, [arg1], [arg2], [...])
La copie de code est la suivante:
var eventEMmitter = require ('Events'). EventEMmitter;
var ee = new EventEmitter ();
ee.on ('some_events', fonction (foo, bar) {
console.log ("1er événement d'écoute, paramètre foo =" + foo + ", bar =" + bar);
});
/ *
EventEmitter.Emit (événement, [Arg1], [Arg2], [...]) déclenche l'événement spécifié
Paramètre 1: chaîne d'événements, nom d'événement
Paramètre 2: paramètres facultatifs, transmettre les paramètres de la fonction de rappel dans l'ordre
Valeur de retour: si cet événement est écouté
* /
var issucess = ee.emit ('some_events', 'wilson', 'zhong');
ee.on ('some_events', fonction (foo, bar) {
Console.log ("2nd Event Event, Paramètre FOO =" + FOO + ", BAR =" + BAR);
});
ee.emit ('some_events', 'zhong', 'wei');
var issuccess2 = ee.emit ('autres_events', 'wilson', 'zhong');
Console.log (émetteur);
Console.log (IssuCcess2);
emetter.emit (événement, [Arg1], [Arg2], [...]) Exemple de code source
L'exemple a effectué trois opérations d'événements de déclenchement, dans lesquelles certains_Events enregistrent l'écoute, et la fonction EMIT renvoie un vrai lorsqu'il est appelé, tandis que d'autres_Events n'enregistrent pas l'écoute, et la fonction EMIT renverra un faux, indiquant que l'événement n'est pas écouté; Bien sûr, vous pouvez ignorer la valeur de retour!
emiter.once (événement, auditeur)
La copie de code est la suivante:
var eventEMmitter = require ('Events'). EventEMmitter;
var ee = new EventEmitter ();
/ *
EventEmitter.once (événement, auditeur) Enregistrez-vous à écoute unique pour les événements, supprimez l'écoute après le déclenchement une fois
Paramètre 1: chaîne d'événements, nom d'événement
Paramètre 2: fonction de rappel
* /
ee.once ('some_events', fonction (foo, bar) {
console.log ("1er événement d'écoute, paramètre foo =" + foo + ", bar =" + bar);
});
console.log («premier tour»);
ee.emit ('some_events', 'wilson', 'zhong');
console.log («deuxième tour»);
var issucess = ee.emit ('some_events', 'wilson', 'zhong');
Console.log (émetteur);
emiter.once (événement, auditeur) Exemple de code source
D'après l'exemple ci-dessus, les résultats de l'exécution de code, nous pouvons voir qu'après avoir enregistré un écouteur pour certains_events avec emiter.once, il se déclenchera en deux tours d'appel Emiter.emit, et le deuxième tour reviendra faux; Cela signifie que l'enregistrement de l'auditeur avec Emiter.on est légèrement différent de l'enregistrement de l'auditeur auprès de Emiter.on mentionné plus tôt.
EMITTER.ONCE L'écoute d'enregistrement est une écoute ponctuelle. Lorsqu'il est déclenché une fois, l'écoute sera supprimée! Bien sûr, c'est plus évident du nom ^ _ ^!
emiter.removeListener (événement, auditeur)
Jetons un coup d'œil à une scène ratée d'abord ~~~
La copie de code est la suivante:
var eventEMmitter = require ('Events'). EventEMmitter;
var ee = new EventEmitter ();
ee.on ('some_events', fonction (foo, bar) {
console.log ("1er événement d'écoute, paramètre foo =" + foo + ", bar =" + bar);
});
/ *
Quand j'ai vu la méthode de suppression de removeListener dans l'API, j'ai pensé que ça devrait être comme ça
Mais le résultat ^ _ ^ !!!
* /
ee.removeListener ('some_events', function () {
console.log («Événement supprimé avec succès certains_events écoutant!»);
});
console.log («premier tour»);
ee.emit ('some_events', 'wilson', 'zhong');
emiter.removeListener (événement, auditeur) Exemple de scénario d'échec Code source
Lorsque j'ai enregistré un auditeur pour certains_events en utilisant emiter.on, j'ai utilisé Emiter.removeListener pour supprimer l'écouteur de certains_events, puis j'ai appelé Emiter.emit pour déclencher. Enfin, j'ai trouvé que ça ne se déroulait pas comme je l'imaginais! Pourquoi?
Je pense naturellement que le deuxième paramètre d'Emiiter.RemoveListener est une fonction de rappel, donc l'API doit être soigneusement lue! ! !
Voyons une autre scène réussie ~~~
La copie de code est la suivante:
var eventEMmitter = require ('Events'). EventEMmitter;
var ee = new EventEmitter ();
Var auditeur = fonction (foo, bar)
{
console.log ("1er événement d'écoute, paramètre foo =" + foo + ", bar =" + bar);
}
var écouteur2 = fonction (foo, bar)
{
Console.log ("2nd Event Event, Paramètre FOO =" + FOO + ", BAR =" + BAR);
}
var écouteur3 = fonction (foo, bar)
{
console.log ("3e événement d'écoute, paramètre foo =" + foo + ", bar =" + bar);
}
ee.on ('some_events', auditeur);
ee.on ('some_events', écouteur2);
ee.on ('some_events', écouteur3);
/ *
EventEmitter.RemoveListener (événement, auditeur) supprime l'auditeur de l'événement spécifié
Remarque: l'auditeur doit être enregistré
PS: Après l'exemple précédent, il échouera. La grande raison est que l'auditeur est ignoré. Il est naturel de penser qu'il est normal de passer le nom de l'événement, donc c'est une tragédie!
* /
ee.RemoveListener ('some_events', auditeur);
ee.RemoveListener ('some_events', écouteur3);
ee.emit ('some_events', 'wilson', 'zhong');
emiter.removeListener (événement, auditeur) Exemple de scénario réussi Code source
J'ai utilisé l'exemple d'écriture de la méthode, ajouté trois auditeurs à certains_events, supprimé les premier et troisième auditeurs, et j'ai finalement déclenché certains_events avec emiter.emit. Le résultat de sortie n'est pas difficile à constater que les premier et troisième auditeurs supprimés avec Emitte.removeListener ne fonctionnaient plus.
Bien sûr, cela est nocif pour les gens. Il s'avère que le deuxième paramètre de Emitte.
emiter.removealLlistenners ([événement])
Emiter.removeListener a été utilisé, mais un événement peut avoir plusieurs auditeurs. Lorsque tous doivent être supprimés, ce n'est évidemment pas une façon agréable de les enlever une par une, et elle ne se conforme pas à la nature d'être paresseux!
Voyons la commodité apportée par Emitte.removealLlistenners!
La copie de code est la suivante:
var eventEMmitter = require ('Events'). EventEMmitter;
var ee = new EventEmitter ();
Var auditeur = fonction (foo, bar)
{
console.log ("1er événement d'écoute, paramètre foo =" + foo + ", bar =" + bar);
}
var écouteur2 = fonction (foo, bar)
{
Console.log ("2nd Event Event, Paramètre FOO =" + FOO + ", BAR =" + BAR);
}
ee.on ('some_events', auditeur);
ee.on ('some_events', écouteur2);
ee.on ('autres_events', fonction (foo, bar)
{
console.log ("autres événements d'écoute, paramètre foo =" + foo + ", bar =" + bar);
});
/ *
EventEmitter.RemovealLlistenners ([événement]) supprime (événement par lots) tous les auditeurs
Paramètre 1: paramètre facultatif, chaîne d'événements, nom d'événement
* /
ee.RemovealLListeners ('some_events');
ee.emit ('some_events', 'wilson', 'zhong');
ee.emit ('autres_events', 'wilson', 'zhong');
EMITTER.REMOVEALLLISTENERS Exemple de code source pour le paramètre de nom d'événement entrant
En regardant les résultats d'exécution ci-dessus, vous constaterez que deux auditeurs ont été inscrits à certains_events; Un auditeur a été inscrit à d'autres_Events; J'ai appelé Emiter.removealLlistenners pour passer le nom de l'événement Some_events;
Enfin, utilisez la fonction Emitte.on pour déclencher deux événements: certains_events et autres_events. Enfin, il est constaté que les deux auditeurs enregistrés par certains_Events n'existent pas, tandis que les auditeurs enregistrés par d'autres_Events existent toujours;
Cela signifie que lorsque Emiter.removealLlistenners passe avec le nom de l'événement en tant que paramètre, tous les auditeurs qui passe dans le nom de l'événement seront supprimés sans affecter d'autres auditeurs d'événements!
emiter.removealLlistenners peut être utilisé sans passer par des paramètres de nom d'événement; exécuter directement
La copie de code est la suivante:
var eventEMmitter = require ('Events'). EventEMmitter;
var ee = new EventEmitter ();
Var auditeur = fonction (foo, bar)
{
console.log ("1er événement d'écoute, paramètre foo =" + foo + ", bar =" + bar);
}
var écouteur2 = fonction (foo, bar)
{
Console.log ("2nd Event Event, Paramètre FOO =" + FOO + ", BAR =" + BAR);
}
ee.on ('some_events', auditeur);
ee.on ('some_events', écouteur2);
ee.on ('autres_events', fonction (foo, bar)
{
console.log ("autres événements d'écoute, paramètre foo =" + foo + ", bar =" + bar);
});
/ *
EventEmitter.RemovealLlistenners ([événement]) supprime (événement par lots) tous les auditeurs
Paramètre 1: paramètre facultatif, chaîne d'événements, nom d'événement
* /
ee.removealLlistenners ();
ee.emit ('some_events', 'wilson', 'zhong');
ee.emit ('autres_events', 'wilson', 'zhong');
emiter.removealLlistenners Exemple de code source sans paramètres de passage
L'exemple de code est presque le même que lors du passage des paramètres, sauf que lorsque vous appelez Emiter.removealLlistenners, aucun nom d'événement spécifié n'est passé;
L'exécution des résultats constatera que certains_EVENTS et autres auditeurs n'existent plus, et il supprimera tous les auditeurs! (Des méthodes plus violentes devraient être utilisées avec prudence ~~)
Emiter.Listeners (événement)
La copie de code est la suivante:
var eventEMmitter = require ('Events'). EventEMmitter;
var ee = new EventEmitter ();
Var auditeur = fonction (foo, bar)
{
console.log ("1er événement d'écoute, paramètre foo =" + foo + ", bar =" + bar);
}
var écouteur2 = fonction (foo, bar)
{
Console.log ("2nd Event Event, Paramètre FOO =" + FOO + ", BAR =" + BAR);
}
ee.on ('some_events', auditeur);
ee.on ('some_events', écouteur2);
ee.on ('autres_events', fonction (foo, bar)
{
console.log ("autres événements d'écoute, paramètre foo =" + foo + ", bar =" + bar);
});
/ *
EventEmitter.Listeners (événement) // renvoie le tableau d'écoute pour l'événement spécifié
Paramètre 1: chaîne d'événements, nom d'événement
* /
var overevereventsarr = ee.Listers ('some_events');
Console.log (LivereReventsAr.Length)
for (var i = evereeventsarr.length - 1; i> = 0; i--) {
Console.log (LivereReventsarr [i]);
};
EMITTER.Listeners (événement) Exemple de code source
Enregistrez deux auditeurs pour certains_events, appelez la fonction Emitte.Listeners, passez le nom de l'événement de certains_events et recevez la valeur de retour de la fonction;
D'après les résultats, nous pouvons voir que la valeur de retour reçoit une collection de toutes les écoutes enregistrées pour certains_events!
emiter.setMaxListeners (n)
Il est vrai qu'un événement peut ajouter plusieurs auditeurs, mais quelle est la valeur maximale par défaut de NodeJS?
La copie de code est la suivante:
var eventEMmitter = require ('Events'). EventEMmitter;
var ee = new EventEmitter ();
/ *
Ajouter 11 auditeurs à EventEmitter
* /
pour (var i = 10; i> = 0; i--) {
ee.on ('some_events', function ()
{
console.log ('th' + (i +1) + 'écouteur');
});
};
Ajouter n à l'écoute d'échantillons de codes source
Dans l'exemple ci-dessus, j'ai utilisé une boucle pour ajouter 11 écoute à certains_events, exécuté le code et constaté que les informations d'avertissement sont apparues, et l'invite était plus détaillée, j'ai donc besoin d'utiliser Emiter.SetMaxListeners () pour augmenter la limite.
La copie de code est la suivante:
var eventEMmitter = require ('Events'). EventEMmitter;
var ee = new EventEmitter ();
/ *
EventEmitter.setMaxListeners (n) définir une écoute maximale pour eventEmitter
Paramètre 1: n type de nombre, nombre maximum d'auditeurs
Lorsqu'il y a plus de 10 auditeurs, le nombre maximum d'auditeurs pour EventEmitter sera invité:
(Node) Avertissement: fuite de mémoire éventuelle possible détectée. 11 auditeurs ajoutés.
Utilisez Emitte.SetMaxListeners () pour augmenter la limite.
Le concepteur pense que trop d'auditeurs peuvent conduire à des fuites de mémoire, donc il y a un tel avertissement
* /
ee.setMaxListeners (15);
/ *
Ajouter 11 auditeurs à EventEmitter
* /
pour (var i = 10; i> = 0; i--) {
ee.on ('some_events', function ()
{
console.log ('th' + (i +1) + 'écouteur');
});
};
EMITTER.SetMaxListeners Exemple de code source
Lorsque j'appelle Emiter.setMaxListeners pour passer dans 15, le code est exécuté et les informations d'avertissement n'apparaissent plus;
La fonction de Emitte.SetMaxListeners est de définir le nombre maximum d'écouteurs pour eventEmitter. Il semble que vous n'ayez pas besoin de définir cette valeur. Il devrait y avoir moins de cas où 10 ne suffit pas!
Le designer pensait que trop d'auditeurs provoqueraient des fuites de mémoire, alors il a donné un avertissement!
autre...
Je n'entrerai pas dans les détails si j'utilise moins
EventEmitter.defaultMaxListeners
EventEmitter.DefaultMaxListeners La fonction est similaire à SetMaxListeners.
Définir une écoute maximale pour tous les éléments Eventemitters
SetMaxListeners La priorité est supérieure à celle de DefaultMaxListeners
EventEmitter.ListenerCount (émetteur, événement)
Renvoie le nombre d'auditeurs pour l'événement spécifié
Erreur d'événement spécial
Citation de Node.js Guide de développement: EventEmitter définit une erreur d'événement spéciale, qui contient la sémantique de "l'erreur". Nous émettons généralement un événement d'erreur lors de la rencontre des exceptions. Lorsqu'une erreur est émise, EventEMmitter spécifie que s'il n'y a pas d'écouteur de réponse, Node.js le traitera comme une exception, quittez le programme et imprimera la pile d'appels. Nous devons généralement configurer des auditeurs pour des objets qui émettront des événements d'erreur pour éviter que l'ensemble du programme ne s'écrase après les erreurs de rencontre.
Héritage des événements
Parlons-en plus tard dans Util. Si vous êtes intéressé, vous pouvez le vérifier par vous-même http://nodejs.org/api/util.html#util_util_inherits_constructor_superconstructor