Node.js EventEmitter

Node.js toutes les opérations d'E / S asynchrone à la fin envoie un événement à la file d'attente d'événements.

Node.js que de nombreux objets sont distribués événement: un objet distribué net.Server un événement à chaque fois une nouvelle connexion, un des objets de fs.readStream seront émis dans le cas où un fichier est ouvert quand. Tous ces objets sont générés des événements events.EventEmitter exemple.

classe EventEmitter

Module d'événements fournit un seul objet: events.EventEmitter. Noyau EventEmitter est forfait fonction événementielle et écouteur d'événement.

Vous pouvez ( «événements») par besoin; pour accéder au module.

// 引入 events 模块
var events = require('events');
// 创建 eventEmitter 对象
var eventEmitter = new events.EventEmitter();

EventEmitter Si une erreur se produit lorsqu'un objet est instancié, il va déclencher la «erreur» événement. Lors de l'ajout d'un nouvel auditeur, événement 'newListener' est déclenché lorsque l'écouteur est supprimé, l'événement 'removeListener' est déclenchée.

Ici, nous utilisons un exemple simple montre l'utilisation EventEmitter:

//event.js 文件
var EventEmitter = require('events').EventEmitter; 
var event = new EventEmitter(); 
event.on('some_event', function() { 
	console.log('some_event 事件触发'); 
}); 
setTimeout(function() { 
	event.emit('some_event'); 
}, 1000); 

des résultats d'exécution sont les suivantes:

Exécutez ce code, une seconde après la sortie de la console'some_event événement déclencheur ».Le principe est que l'objet est enregistré événement événement some_event d'un auditeur, et ensuite nous envoyer des événements some_event par setTimeout 1000 millisecondes après l'événement dans l'objet, puis appelle auditeur some_event.

$ node event.js 
some_event 事件触发

Chaque EventEmitter d'événement par un nom d'événement et un certain nombre de paramètres, le nom de l'événement est une chaîne, généralement exprimées certaines sémantiques. Pour chaque événement, EventEmitter supporte plusieurs écouteur d'événement.

Lorsque l'événement se produit, l'événement pour enregistrer des écouteurs d'événements sont appelés séquentiellement comme argument de paramètre d'événement de rappel.

Prenons l'exemple suivant illustre ce processus:

//event.js 文件
var events = require('events'); 
var emitter = new events.EventEmitter(); 
emitter.on('someEvent', function(arg1, arg2) { 
	console.log('listener1', arg1, arg2); 
}); 
emitter.on('someEvent', function(arg1, arg2) { 
	console.log('listener2', arg1, arg2); 
}); 
emitter.emit('someEvent', 'arg1 参数', 'arg2 参数'); 

Exécutez le code ci-dessus, exécutez comme suit:

$ node event.js 
listener1 arg1 参数 arg2 参数
listener2 arg1 参数 arg2 参数

L'exemple ci-dessus, unEvenement émetteur pour l'événement, deux écouteurs d'événements, puis a déclenché l'événement unEvenement.

Les résultats d'exploitation peuvent être vus dans la fonction d'écoute de rappel de deux événements a été appelé. Ceci est EventEmitter utilisation plus facile.

EventEmitter fournit un certain nombre d'attributs, commesur et émettent.sur la fonction est utilisée pour lier lafonction d'événement,émettre attribut est utilisé pour déclencher un événement. Nous examinerons ensuite les propriétés EventEmitter spécifiques décrites.

manière

server.on('connection', function (stream) {
  console.log('someone connected!');
});

server.once('connection', function (stream) {
  console.log('Ah, we have our first user!');
});

var callback = function(stream) {
  console.log('someone connected!');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);

Les méthodes de classe

événement

Exemples

Les exemples suivants via une connexion (connexion) événement démontre des applications de classe EventEmitter.

Créer un fichier main.js, comme suit:

var events = require('events');
var eventEmitter = new events.EventEmitter();

// 监听器 #1
var listener1 = function listener1() {
   console.log('监听器 listener1 执行。');
}

// 监听器 #2
var listener2 = function listener2() {
  console.log('监听器 listener2 执行。');
}

// 绑定 connection 事件，处理函数为 listener1 
eventEmitter.addListener('connection', listener1);

// 绑定 connection 事件，处理函数为 listener2
eventEmitter.on('connection', listener2);

var eventListeners = require('events').EventEmitter.listenerCount(eventEmitter,'connection');
console.log(eventListeners + " 个监听器监听连接事件。");

// 处理 connection 事件 
eventEmitter.emit('connection');

// 移除监绑定的 listener1 函数
eventEmitter.removeListener('connection', listener1);
console.log("listener1 不再受监听。");

// 触发连接事件
eventEmitter.emit('connection');

eventListeners = require('events').EventEmitter.listenerCount(eventEmitter,'connection');
console.log(eventListeners + " 个监听器监听连接事件。");

console.log("程序执行完毕。");

Le code ci-dessus, des résultats d'exécution sont les suivantes:

$ node main.js
2 个监听器监听连接事件。
监听器 listener1 执行。
监听器 listener2 执行。
listener1 不再受监听。
监听器 listener2 执行。
1 个监听器监听连接事件。
程序执行完毕。

l'événement d'erreur

EventEmitter définit une erreur d'événement spécial, il contient une erreur sémantique, nous aurions normalement déclencher un événement d'erreur face à des exceptions.

Lorsque l'erreur est déclenchée, EventEmitter stipulent que si aucune réponse à un auditeur, Node.js utilisera comme une exception, quitter le programme avec un message d'erreur.

Pour cibler, nous allons généralement déclencher des paramètres d'écoute d'événement d'erreur, éviter l'erreur est rencontrée dans tout le programme se bloque. Par exemple:

var events = require('events'); 
var emitter = new events.EventEmitter(); 
emitter.emit('error'); 

Exécutez l'erreur suivante apparaît:

node.js:201 
throw e; // process.nextTick error, or 'error' event on first tick 
^ 
Error: Uncaught, unspecified 'error' event. 
at EventEmitter.emit (events.js:50:15) 
at Object.<anonymous> (/home/byvoid/error.js:5:9) 
at Module._compile (module.js:441:26) 
at Object..js (module.js:459:10) 
at Module.load (module.js:348:31) 
at Function._load (module.js:308:12) 
at Array.0 (module.js:479:10) 
at EventEmitter._tickCallback (node.js:192:40) 

EventEmitter Héritage

La plupart du temps, nous n'utilisent pas directement EventEmitter, mais a hérité dans l'objet. Y compris fs, net, http, y compris, tant que les modules de base de soutien de réponse aux incidents sont sous-classes de EventEmitter.

Pourquoi? Il y a deux raisons:

Tout d'abord, l'objet a la fonctionnalité d'une réalisation physique d'événements qui répondent à l'écran d'émission et de la sémantique, l'événement devrait être un objet.

Deuxièmement, le mécanisme d'objet JavaScript est un héritage de support multi-partie basé sur des prototypes, objets EventEmitter pas perturber l'héritage originel.