Lassen Sie uns über Ereignistreiber und EventEmitter-Klassen in Node.js sprechen

Dieser Artikel wird Ihnen helfen, die Ereignisse in Node zu verstehen und über den Event-Treiber und die EventEmitter-Klasse zu sprechen. Ich hoffe, dass er für alle hilfreich ist!

Nodejs ist eine Single-Threaded-Anwendung mit einem Prozess. Aufgrund der von der V8-Engine bereitgestellten Rückrufschnittstelle für die asynchrone Ausführung kann jedoch ein großer Teil der Parallelität über diese Schnittstellen verarbeitet werden, sodass die Leistung sehr hoch ist .

Fast jede API in Node.js unterstützt Callback-Funktionen.

Node.js Grundsätzlich werden alle Ereignismechanismen mithilfe des Beobachtermusters im Entwurfsmuster implementiert.

Der einzelne Thread von Node.j ähnelt dem Eintritt in eine while(true)-Ereignisschleife, bis kein Ereignisbeobachter mehr auftritt. Wenn ein Ereignis auftritt, wird die Rückruffunktion aufgerufen.

Ereignisgesteuertes Programm

Node.js verwendet das ereignisgesteuerte Modell. Wenn der Webserver eine Anfrage empfängt, schließt er diese, verarbeitet sie und bedient dann die nächste Webanfrage.

Wenn diese Anfrage abgeschlossen ist, wird sie wieder in die Verarbeitungswarteschlange gestellt, und wenn sie den Anfang der Warteschlange erreicht, wird das Ergebnis an den Benutzer zurückgegeben.

Dieses Modell ist sehr effizient und skalierbar, da der Webserver immer Anfragen annimmt, ohne auf Lese- oder Schreibvorgänge warten zu müssen. (Dies wird auch als nicht blockierende E/A oder ereignisgesteuerte E/A bezeichnet)

Im ereignisgesteuerten Modell wird eine Hauptschleife generiert, um auf Ereignisse zu warten, und eine Rückruffunktion wird ausgelöst, wenn ein Ereignis erkannt wird.

Node.js verfügt über mehrere integrierte Ereignisse. Wir können Ereignisse binden und abhören, indem wir das Ereignismodul einführen und die EventEmitter-Klasse instanziieren, wie im folgenden Beispiel gezeigt:

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

Das folgende Programm bindet Ereignishandler:

// 绑定事件及事件的处理程序
eventEmitter.on('eventName', eventHandler);

us Ereignisse können programmgesteuert ausgelöst werden:

// 触发事件
eventEmitter.emit('eventName');

Instance

Erstellen Sie die Datei index.js, der Code lautet wie folgt: index.js 文件，代码如下所示：

//引入 fs 模块
var fs = require("fs");

// 引入 events 模块
var events = require('events');

// 创建对象
var ee = new events.EventEmitter();

// 绑定事件及事件的处理程序
ee.on('res', function (data) {
    console.log('res-1');
    console.log(data);
});
ee.on('res', function () {
    console.log('res-2');
});

fs.readFile('hello.txt',{flag:'r',encoding:'utf-8'},function(err,data){
    if(err){
        console.log("读取出错:"+err);
    }else{
        console.log("读取成功:"+data);
        // 触发res事件
        ee.emit('res',data);
    }
})

接下来让我们执行以上代码：

EventEmitter 类

events 模块只提供了一个对象： events.EventEmitter。EventEmitter 的核心就是事件触发与事件监听器功能的封装。

你可以通过require("events");来访问该模块。

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

EventEmitter 对象如果在实例化时发生错误，会触发 error 事件。当添加新的监听器时，newListener 事件会触发，当监听器被移除时，removeListener 事件被触发。

下面我们用一个简单的例子说明 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);

执行结果如下：

运行这段代码，1 秒后控制台输出了 'some_event 事件触发' 。其原理是 event 对象注册了事件 some_event 的一个监听器，然后我们通过 setTimeout 在 1000 毫秒以后向 event 对象发送事件 some_event，此时会调用some_event 的监听器。

$ node event.js 
some_event 事件触发

EventEmitter 的每个事件由一个事件名和若干个参数组成，事件名是一个字符串，通常表达一定的语义。对于每个事件，EventEmitter 支持 若干个事件监听器。

当事件触发时，注册到这个事件的事件监听器被依次调用，事件参数作为回调函数参数传递。

让我们以下面的例子解释这个过程：

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

执行以上代码，运行的结果如下：

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

以上例子中，emitter 为事件 someEvent 注册了两个事件监听器，然后触发了 someEvent 事件。

运行结果中可以看到两个事件监听器回调函数被先后调用。 这就是EventEmitter最简单的用法。

EventEmitterrrreeeAls nächstes führen wir den obigen Code aus:

EventEmitter-Klasseevents-Modul stellt nur ein Objekt bereit: events.EventEmitter. Der Kern von EventEmitter ist die Kapselung von Ereignisauslöse- und Ereignis-Listener-Funktionen.

Sie können über require("events"); auf dieses Modul zugreifen. Das rrreeeEventEmitter-Objekt löst das Fehlerereignis aus, wenn während der Instanziierung ein Fehler auftritt. Das Ereignis „newListener“ wird ausgelöst, wenn ein neuer Listener hinzugefügt wird, und das Ereignis „removeListener“ wird ausgelöst, wenn ein Listener entfernt wird.

Das obige ist der detaillierte Inhalt vonLassen Sie uns über Ereignistreiber und EventEmitter-Klassen in Node.js sprechen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!