Parlons des pilotes d'événements et de la classe EventEmitter dans Node.js

Cet article vous amènera à comprendre les événements dans Node et à parler du pilote d'événement et de la classe EventEmitter. J'espère qu'il sera utile à tout le monde !

Nodejs est une application mono-processus mono-thread, mais en raison de l'interface de rappel d'exécution asynchrone fournie par le moteur V8, une grande quantité de concurrence peut être traitée via ces interfaces, les performances sont donc très élevées .

Presque toutes les API de Node.js prennent en charge les fonctions de rappel.

Node.js Fondamentalement, tous les mécanismes d'événements sont implémentés à l'aide du modèle d'observateur dans le modèle de conception.

Le thread unique Node.js est similaire à la saisie d'une boucle d'événement while (true) jusqu'à ce qu'aucun observateur d'événement ne se termine. Chaque événement asynchrone génère un observateur d'événement. Si un événement se produit, la fonction de rappel est appelée.

---

Programme basé sur les événements

Node.js utilise le modèle basé sur les événements Lorsque le serveur Web reçoit une requête, il la ferme et la traite, puis sert la requête Web suivante.

Lorsque cette requête est terminée, elle est remise dans la file d'attente de traitement, et lorsqu'elle atteint le début de la file d'attente, le résultat est renvoyé à l'utilisateur.

Ce modèle est très efficace et évolutif car le serveur Web accepte toujours les requêtes sans attendre aucune opération de lecture ou d'écriture. (Cela est également appelé IO non bloquant ou IO piloté par événement)

Dans le modèle piloté par événement, une boucle principale est générée pour écouter les événements, et une fonction de rappel est déclenchée lorsqu'un événement est détecté.

Node.js a plusieurs événements intégrés. Nous pouvons lier et écouter des événements en introduisant le module d'événements et en instanciant la classe EventEmitter, comme le montre l'exemple suivant :

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

Le programme suivant lie les gestionnaires d'événements :

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

. us Les événements peuvent être déclenchés par programme :

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

Instance

Créez le fichier index.js, le code est le suivant : 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最简单的用法。

EventEmitterrrreeeEnsuite, exécutons le code ci-dessus :

EventEmitter classLe module events ne fournit qu'un seul objet : events.EventEmitter. Le cœur de EventEmitter est l'encapsulation des fonctions de déclenchement d'événements et d'écoute d'événements.

Vous pouvez accéder à ce module via require("events");. L'objet rrreeeEventEmitter déclenchera l'événement d'erreur si une erreur se produit lors de l'instanciation. L'événement newListener est déclenché lorsqu'un nouvel écouteur est ajouté, et l'événement RemoveListener est déclenché lorsqu'un nouvel écouteur est supprimé.

🎜 Ci-dessous, nous utilisons un exemple simple pour illustrer l'utilisation de EventEmitter : 🎜rrreee🎜Les résultats de l'exécution sont les suivants : 🎜🎜Exécutez ce code, et après 1 seconde, la console affiche 🎜'un événement_event déclenché'🎜. Le principe est que l'objet événement enregistre un écouteur pour l'événement some_event, puis nous utilisons setTimeout pour envoyer l'événement some_event à l'objet événement après 1000 millisecondes. À ce moment, l'écouteur de some_event sera appelé. 🎜rrreee🎜Chaque événement de EventEmitter se compose d'un nom d'événement et de plusieurs paramètres. Le nom de l'événement est une chaîne, qui exprime généralement certaines sémantiques. Pour chaque événement, EventEmitter prend en charge plusieurs écouteurs d'événement. 🎜🎜Lorsqu'un événement est déclenché, les écouteurs d'événement enregistrés pour cet événement sont appelés dans l'ordre et les paramètres de l'événement sont transmis en tant que paramètres de fonction de rappel. 🎜🎜Expliquons ce processus avec l'exemple suivant : 🎜rrreee🎜Exécutez le code ci-dessus, les résultats d'exécution sont les suivants : 🎜rrreee🎜Dans l'exemple ci-dessus, émetteur est enregistré pour l'événement someEvent Deux écouteurs d'événement sont créés, puis l'événement someEvent est déclenché. 🎜🎜Vous pouvez voir dans les résultats en cours d'exécution que deux fonctions de rappel d'écouteur d'événements sont appelées successivement. Il s'agit de l'utilisation la plus simple de EventEmitter. 🎜🎜EventEmitter fournit plusieurs propriétés telles que 🎜on🎜 et 🎜emit🎜. La fonction 🎜on🎜 est utilisée pour lier la fonction d'événement et l'attribut 🎜emit🎜 est utilisé pour déclencher un événement. 🎜🎜Pour plus de connaissances sur les nœuds, veuillez visiter : 🎜tutoriel Nodejs🎜 ! ! 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!