Node.js EventEmitter

Node.js tutte le operazioni di I / O asincrono al completamento invierà un evento alla coda degli eventi.

Node.js che molti oggetti sono distribuiti evento: un oggetto distribuito net.Server un evento ogni volta che una nuova connessione, un oggetto fs.readStream saranno emesse nel caso in cui un file viene aperto quando. Tutti questi oggetti sono generati eventi events.EventEmitter esempio.

classe EventEmitter

Modulo di eventi fornisce un solo oggetto: events.EventEmitter. Nucleo EventEmitter è pacchetto di funzioni su evento e listener di eventi.

È possibile ( "eventi") da richiedere, per accedere al modulo.

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

EventEmitter Se un errore si verifica quando un oggetto viene creata un'istanza, si attiverà l'evento 'errore'. Quando si aggiunge un nuovo listener, evento 'newListener' viene attivato quando il listener viene rimosso, evento 'removeListener' viene attivato.

Qui usiamo un semplice esempio mostra l'utilizzo 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); 

risultati di esecuzione sono i seguenti:

Eseguire questo codice, un secondo dopo l'uscita della console'evento some_event trigger'.Il principio è che l'oggetto viene registrato evento evento some_event di un ascoltatore, e poi inviare gli eventi some_event da setTimeout 1000 millisecondi dopo l'evento in oggetto, poi chiama ascoltatore some_event.

$ node event.js 
some_event 事件触发

Ogni EventEmitter evento da un nome di evento e una serie di parametri, nome dell'evento è una stringa, di solito espresse alcune semantica. Per ogni evento, EventEmitter supporta diversi listener di eventi.

Quando si verifica l'evento, l'evento per registrare listener di eventi sono in sequenza chiamati come argomento parametro evento di callback.

Prendiamo l'esempio che segue illustra questo processo:

//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 参数'); 

Eseguire il codice precedente, eseguito come segue:

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

L'esempio precedente, emettitore someEvent registrato per l'evento, due listener di eventi, quindi innescato eventi someEvent.

I risultati di gestione possono essere visti in funzione listener di callback due eventi è stato chiamato. Questo è EventEmitter utilizzo più semplice.

EventEmitter fornisce una serie di attributi, ad esempiosu ed emettere.sulla funzione viene utilizzato per legarefunzione di evento,emettono attributo viene utilizzato per attivare un evento. Successivo guardiamo proprietà EventEmitter specifiche descritte.

modo

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);

I metodi di classe

evento

Esempi

Gli esempi che seguono tramite connessione (connessione) evento dimostra applicazioni di classe EventEmitter.

Creare file di main.js, come segue:

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("程序执行完毕。");

Codice di cui sopra, i risultati di esecuzione sono i seguenti:

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

evento di errore

EventEmitter definisce un errore di evento speciale, contiene un errore di semantica, che normalmente avrebbe generato un evento di errore di fronte alle eccezioni.

Quando viene attivato l'errore, EventEmitter stabilire che se nessuna risposta ad un ascoltatore, Node.js lo userà come eccezione, uscire dal programma con un messaggio di errore.

Per indirizzare generalmente sarà innescare impostazioni listener di eventi errore, evitare si verifica l'errore in tutto il programma va in crash. Ad esempio:

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

Esegui viene visualizzato il seguente errore:

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 Inheritance

Il più delle volte non usiamo direttamente EventEmitter, ma ereditato nell'oggetto. Tra cui FS, al netto, http, tra cui, a condizione che i moduli di base il supporto di risposta agli incidenti sono sottoclassi EventEmitter.

Perché? Ci sono due ragioni:

Innanzitutto, l'oggetto ha la funzionalità di una realizzazione fisica di eventi che soddisfano il monitor di emissione e la semantica, l'evento deve essere un oggetto.

In secondo luogo, il meccanismo oggetto JavaScript è un prototipo-based, multi-parte supporta l'ereditarietà, oggetti EventEmitter non disturbare l'eredità originale.