Node.js EventEmitter

Node.js alle asynchronen I / O-Operation nach Abschluss wird ein Ereignis in das Ereigniswarteschlange senden.

Node.js, die viele Objekte Veranstaltung verteilt sind: ein verteiltes Objekt net.Server ein Ereignis jedes Mal, wenn eine neue Verbindung, ein fs.readStream Objekte werden im Falle ausgegeben werden eine Datei, wenn sie geöffnet wird. Alle diese Aufgaben werden Ereignisse events.EventEmitter Instanz erzeugt.

EventEmitter Klasse

Ereignisse Modul bietet nur ein Objekt: events.EventEmitter. Kern EventEmitter ist ereignisgesteuert und Funktionspaket Ereignis-Listener.

Sie können ( "Events") durch erfordern, um das Modul zuzugreifen.

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

EventEmitter Tritt ein Fehler auf, wenn ein Objekt instanziiert wird, wird es die "Fehler" Ereignis auslösen. Wenn Sie einen neuen Hörer Hinzufügen 'newListener' Ereignis ausgelöst wird, wenn der Hörer abgenommen wird, 'removeListener' Ereignis ausgelöst wird.

Hier verwenden wir ein einfaches Beispiel EventEmitter Nutzung zeigt:

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

Ausführungsergebnisse sind wie folgt:

Führen Sie diesen Code, eine Sekunde nach dem Konsolenausgabe'some_event Triggerereignis ".Das Prinzip ist, dass das Objekt Ereignis some_event Ereignis eines Hörers registriert ist, und dann Ereignisse, die wir senden durch SetTimeout 1000 Millisekunden nach dem Ereignis in dem Objekt some_event, dann ruft some_event Zuhörer.

$ node event.js 
some_event 事件触发

Jedes Ereignis EventEmitter von einem Ereignisnamen und eine Reihe von Parametern, ist Ereignisname eine Zeichenfolge, in der Regel ausgedrückt bestimmte Semantik. Für jedes Ereignis unterstützt EventEmitter mehrere Ereignis-Listener.

Wenn das Ereignis eintritt, um das Ereignis zu Ereignis-Listener registrieren sequentiell als Callback-Ereignisparameter Argument aufgerufen werden.

Lassen Sie uns das folgende Beispiel nehmen veranschaulicht diesen Prozess:

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

Führen Sie den Code oben, führen Sie wie folgt vor:

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

Das obige Beispiel, Emitter jeweiliges Ereignis für das Ereignis registriert, zwei Event-Listener, dann ausgelöst, someevent Ereignis.

Die operativen Ergebnisse können in zwei Event-Listener-Rückruffunktion gesehen werden aufgerufen wurde. Dies ist EventEmitter einfachste Nutzung.

EventEmitter bietet eine Reihe von Attributen, wie etwaauf und emittieren.On - Funktion verwendet wird , Event -Funktionzubinden,emittieren Attribut verwendet, um ein Ereignis auszulösen. Als nächstes sehen wir EventEmitter spezifischen Eigenschaften beschrieben.

Weg

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

Klassenmethoden

Ereignis

Beispiele

Die folgenden Beispiele über die Verbindung (Verbindung) Ereignis demonstriert EventEmitter Anwendungen ermöglichen.

Erstellen Sie main.js Datei wie folgt:

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

Code oben, sind die Ausführungsergebnisse wie folgt:

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

Fehlerereignis

EventEmitter definiert ein besonderes Ereignis Fehler, es eine semantische Fehler enthält, würden wir normalerweise ein Fehlerereignis angesichts der Ausnahmen auslösen.

Wenn der Fehler ausgelöst wird, EventEmitter sehen vor, dass, wenn keine Antwort auf einen Hörer, wird Node.js es als Ausnahme zu verwenden, um das Programm mit einer Fehlermeldung beenden.

So streben wir im allgemeinen Einstellungen Fehler Ereignis-Listener auslöst, vermeiden wird der Fehler in den Programmabstürze auftreten. Zum Beispiel:

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

Führen Sie die folgende Fehlermeldung angezeigt:

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) 

Inheritance EventEmitter

Die meisten der Zeit, die wir nicht direkt verwenden EventEmitter, aber es in dem Objekt geerbt. Einschließlich fs, net, http, einschließlich, solange die Unterstützung Incident-Response-Kernmodule Subklassen von EventEmitter sind.

Warum? Es gibt zwei Gründe:

Zunächst wird das Objekt die Funktionalität einer physischen Realisierung von Ereignissen aufweist, die den Emissionsmonitor und Semantik zu erfüllen, sollte das Ereignis ein Objekt sein.

Zweitens ist das Objekt Mechanismus JavaScript ein Prototyp-basierte, mehrteilige Unterstützung Vererbung, Objekte EventEmitter nicht das ursprüngliche Erbe stören.