Parlons en profondeur d'EventEmitter dans node.js

Cet article vous amènera à comprendre EventEmitter dans node et à parler brièvement des opérations asynchrones, des événements d'erreur et des classes EventEmitter. J'espère qu'il sera utile à tout le monde !

events (event trigger)

---

events est le déclencheur d'événement intégré de nodejs. Les événements sont utilisés dans de nombreux modules intégrés de node, tels que http.server chaque fois qu'il reçoit une requête. . Déclenchez les événements et les flux sont basés sur des événements et utilisent pour écouter les événements correspondants. Tous les objets qui déclenchent des événements sont des instances EventEmitter. Ces objets exposent EventEmitter.on('event', callback est généralement utilisé pour enregistrer des événements, et EventEmitter.emit déclenche des événements).

Exemple :

  const events= require('events');
const event=new events();//实例化EventEmitter
event.on('data',(a,b)=>{
    console.log('参数'+a+b)
    console.log(this,'this')
    //注意，如果callback是 箭头函数的话this指向的是全局对象
    //      如果callback是function(){}形式的话，this会绑定到EventEmitter实例上
    console.log('emit触发了data事件')
})
event.emit('data',1,2); //使用emit触发事件

Opération asynchrone

Parce que le rappel dans EventEmitter.on('event name', callback) est exécuté de manière synchrone, mais dans certains cas, nous devons utiliser une opération asynchrone pour que nous puissions utiliser SetImmediate pour effectuer des opérations asynchrones

 const events= require('events');
const event=new events();
event.on('event', (a, b) => {
    
  setImmediate(() => {
    console.log('this happens asynchronously');
  });
  //因为这里的监听器是同步执行的，但是我们可以使用setImediate函数等待监听器里的其他内容执行完再执行
});
event.emit('event',1,2);

Déclencher une fois

Lorsque nous déclenchons normalement un événement via émet, émettre sera déclenché plusieurs fois s'il y a plusieurs événements, mais nous pouvons utiliser une fois pour enregistrer l'événement et utiliser une fois pour déclenchez-le L'événement ne peut être déclenché qu'une seule fois

  const EventEmitter =require('events');
  const MyEventEmitter=new EventEmitter();
  let a=0;
  //正常注册事件和触发
  MyEventEmitter.on('add',()=>{
      a++
      console.log(a) 
  })
  MyEventEmitter.emit('add'); // 1;
  MyEventEmitter.emit('add'); // 2;
  // 使用once注册
  MyEventEmitter.once('add',()=>{
      a++
      console.log(a);
  })
  MyEventEmitter.emit('add') // 1
  MyEventEmitter.emit('add') // 不生效了

événement d'erreur

EventEmitter n'a pas d'événement d'erreur, donc lorsqu'une erreur se produit, il ne peut être forcé qu'à quitter l'exécution, nous devons donc enregistrer un événement d'erreur nous-mêmes, de sorte que lorsqu'une erreur se produit, l'événement d'erreur est déclenché lorsqu'une erreur se produit

 const EventEmitter=require('events');
 const MyEventEmitter=new EventEmitter();
 MyEvenEmitter.on('error',(err)=>{
   console.error(err,'报错了')
 })

En plus de la méthode ci-dessus, nous pouvons également utiliser errorMonitor pour surveiller l'erreur déclenchée par l'émission sans enregistrer l'événement d'erreur. En utilisant errorMonitor, nous n'avons plus besoin d'enregistrer manuellement les événements d'erreur

  const {EventEmitter,errorMonitor}=require('events');
  const MyEventEmitter=new EventEmitter();
  MyEventEmitter.on(errorMonitor,(err)=>{
      console.log(err);
  })
  MyEventEmitter('error' , new Error('报错了'))

EventEmitter class

newListener event

Lorsque nous ajoutons l'écoute d'événement, l'événement newListener sera déclenché, afin que nous puissions enregistrer l'événement newListener utilisé faire quelque chose lors de l'ajout d'écouteurs d'événements

 const {EventEmitter}=require('events');
  const MyEvent=new EventEmitter();
  MyEvent.on('newListener',(name,litener)=>{
      //name就是正在监听的事件的名称
      //listener是事件的处理函数
      MyEvent.on('event',()=>{
        console.log('在newListener添加的事件')
      })  
  })
  MyEvent.on('event',()=>{
      console.log('正常注册的event事件')
  })
  //此时我们再不触发event事件的情况下，newListener事件就会执行，因为我们只要正在注册事件就会触发newListener事件
  //注意:newListener事件必须要使用EventEmitter.once()注册，因为如果我们在newListener事件里再去添加注册事件的话，而且外边有多个注册事件就会触发多次newListener事件,就会发生堆栈溢出
 MyEvent.emit('event');

 //打印的结果
   //    在newListener注册的事件
   //     正常注册的event事件

removeListener event

removeListener l'événement est utilisé pour supprimer les événements enregistrés, cependant, RemoveListener n'empêchera pas les événements déclenchés par submit

 const callbackB=()=>{
    console.log('B')
}
const callbackA=()=>{
    console.log('A')
    event.removeListener('data',callbackB)
}
event.on('data',callbackA)
event.on('data',callbackB)

event.emit('data'); //在执行callbackA的时候删除了data，但是不会阻止掉下一个emit的触发
event.emit('data'); //在这里的时候才是真正被删除掉了

addListener et on La fonction est la même

eventNames

Renvoie un tableau, le tableau contient les noms de tous les événements enregistrés

 const {EventEmitter} =require('events');
 const MyEvent=new EventEmitter();
 MyEvent.on('data',()=>{});
 MyEvent.on('finish',()=>{});
 console.log(MyEvent.eventNames());
 
 //打印结果
  ['data','finish']

getMaxListeners

Renvoie le nombre maximum d'événements pouvant être enregistrés, la valeur par défaut est 10, si elle dépasse 10. sera un avertissement Mais nous pouvons le modifier via setMaxListener(20)

const {EventEmitter} =require('events');
 const MyEvent=new EventEmitter();
 console.log(MyEvent.getMaxListener()); //10
 event.setMaxListener(20); 
 console.log(MyEvent.getMaxListener(20));

listenerCount

Renvoyer le nombre d'événements enregistrés

 const {EventEmitter} =require('events');
 const MyEvent=new EventEmitter();
 MyEvent.on('data',()=>{});
 MyEvent.on('data',()=>{});
 MyEvent.on('finish',()={});
 console.log(MyEvent.listenerCount()) // 2

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!