Une brève analyse du module d'événements de Node

Dans les projets vue, nous utilisons parfois le bus d'événements global pour gérer la communication entre les composants. Dans le projet vue2, nous pouvons utiliser $emit, $on et $off pour encapsuler un eventHub ; vue3$on et $off sont supprimés, nous pouvons utiliser la bibliothèque mitt ou la bibliothèque tiny-emitter. Dans Node, il n'est pas nécessaire d'être aussi gênant. Il dispose d'un module d'événements intégré qui peut nous aider à surveiller et à émettre des événements. $emit、 $on 和 $off 封装一个 eventHub；vue3 中 $on 和 $off 被移除了，我们可以使用 mitt 库或 tiny-emitter 库。在 node 里，则不用这么麻烦，其有个内置的 events 模块就可以帮我们实现对于事件的监听和发射。

事件的监听和发射

先使用 CommonJS 的语法导入得到 EventEmitter 类，然后生成实例 emitter（EventEmitter 十分重要，比如后续文章会介绍的 stream 就是 EventEmitter 的实例）：

const EventEmitter = require('events')
const emitter = new EventEmitter()

接着就可以使用 emitter.on() 对事件进行监听，传入的第 1 个参数就是事件名称，第 2 个参数为监听到事件被发射后要执行的回调，如果发射事件时有传入参数，会传递给回调函数，可以一个个单独获取，也可以像下面这样使用函数的剩余参数获取：  【相关教程推荐：nodejs视频教程、编程教学】

// 监听事件
emitter.on('test', (...args) => {
  console.log(args) // [ 1, 2, 3 ]
})
// 发射事件
emitter.emit('test', 1, 2, 3)

如果只需要监听一次性事件，可以使用 emitter.once()：

emitter.once('test', () => {
  console.log('监听到了事件发射')
})

emitter.emit('test')
emitter.emit('test') // 本次发射不会触发打印

如果有多个地方如下例所示对事件进行了监听，一旦事件发射，那么监听回调会按顺序依次触发：

emitter.on('test', () => {
  console.log('监听到了事件发射，1')
})
emitter.on('test', () => {
  console.log('监听到了事件发射，2')
})
emitter.emit('test')

执行结果：

如果想把监听事件添加到最前面，可以使用 emitter.prependListener()（或者 emitter.prependOnceListener()，即提前但只监听一次）：

emitter.on('test', () => {
  console.log('监听到了事件发射，1')
})
emitter.prependListener('test', () => {
  console.log('监听到了事件发射，2')
})

emitter.emit('test')

现在的结果如下：

移除事件监听

可以使用 emitter.off()（或者 emitter.removeListener()）移除对事件的监听，但需要传入对应的事件名称和回调函数，所以我们在监听时的回调就不能直接像上面这样定义在 emitter.on() 内部了，需要在外部定义然后传入对该回调的引用：

function handler(...args) {
  console.log(args) // [ 1, 2, 3 ]
}
emitter.on('test', handler)
emitter.emit('test', 1, 2, 3) 
emitter.off('test', handler)
emitter.emit('test', '无法被监听到')

emitter.off()只能移除一个监听，且必须传入监听回调，如果有多次监听，想全部移除，可以使用 emitter.removeAllListeners()：

emitter.on('test', handler)
emitter.on('test', handler)
emitter.on('test', handler)

emitter.removeAllListeners()

emitter.removeAllListeners()如果不传入任何参数，则移除所有事件名称的所有事件监听。其还可以传入事件名称，则移除对应事件名称的所有事件监听。

其它一些方法

监听器数量限制

1 个 EventEmitter 对象上，某个事件名称的最大监听器数量默认为 10，这可以通过 emitter.getMaxListeners() 来验证：

console.log(emitter.getMaxListeners()) // 10

比如写了 11 次 emitter.on('test', handler)，就会报错，提示说要用 emitter.setMaxListeners() 来增加最大限制数量：

如果我们想知道当前 EventEmitter 对象上某个事件名称的监听器有多少个，有没有超过最大限制，可以使用 emitter.listenerCount() 传入事件名称查看：

console.log(emitter.listenerCount('test'))

获取事件名称和监听器

使用 emitter.eventNames() 可以获取当前 EventEmitter 对象上注册的所有事件名称，返回的是由事件字符串组成的数组：

emitter.on('test1', handler)
emitter.on('test2', handler)

console.log(emitter.eventNames()) // [ 'test1', 'test2' ]

如果想获取某个事件对应的所有监听器，可以使用 emitter.listeners()

Surveillance et émission d'événements

Utilisez d'abord la syntaxe CommonJS pour importer la classe EventEmitter, puis générez une instance émetteur ( EventEmitter est très important. Par exemple, le stream qui sera introduit dans les articles suivants est une instance de EventEmitter) :

function handler1() {}
function handler2() {}
emitter.on('test', handler1)
emitter.on('test', handler2)

console.log(emitter.listeners('test'))

Alors vous pouvez utiliser emitter. on() pour surveiller l'événement. Le premier paramètre transmis est le nom de l'événement et le deuxième paramètre est le rappel à exécuter après la surveillance de l'événement. au lancement de l'événement, il sera transmis. Pour les fonctions de rappel, vous pouvez les obtenir une par une, ou vous pouvez les utiliser comme suitLes paramètres restants de la fonction

Obtenir : [Tutoriels associés recommandés : tutoriel vidéo nodejs, Enseignement de la programmation

】

rrreeeSi vous n'avez besoin d'écouter que des événements ponctuels, vous pouvez utiliser emitter.once() : rrreee

Si plusieurs endroits surveillent les événements comme indiqué dans l'exemple ci-dessous, une fois l'événement est émis, les rappels d'écoute seront déclenchés dans l'ordre : 🎜rrreee🎜Résultat de l'exécution : 🎜🎜 🎜🎜Si vous souhaitez ajouter des événements d'écoute au premier plan, vous pouvez utiliser emitter.prependListener() (ou emitter. prependOnceListener(), ce qui signifie écouter à l'avance mais une seule fois) : 🎜rrreee🎜Le résultat actuel Comme suit : 🎜🎜🎜

Supprimer l'écouteur d'événements

🎜Peut être supprimé en utilisant émetteur.off() (ou emitter.removeListener()) Pour surveiller les événements, vous devez transmettre le nom de l'événement correspondant et la fonction de rappel, de sorte que le rappel lorsque nous écoutons ne peut pas être directement défini à l'intérieur de emitter.on() comme ci-dessus, il doit être défini en externe puis transmettre une référence au rappel : 🎜rrreee🎜emitter.off() ne peut que supprimez un écouteur et le rappel de l'écouteur doit être transmis. S'il y a plusieurs écouteurs et que vous souhaitez tous les supprimer, vous pouvez utiliser emitter.removeAllListeners() : 🎜rrreee🎜emitter. removeAllListeners() Si aucun paramètre n'est transmis, tous les écouteurs d'événements pour tous les noms d'événements seront supprimés. Il peut également transmettre le nom de l'événement et tous les écouteurs d'événement correspondant au nom de l'événement seront supprimés. 🎜

Quelques autres méthodes

🎜Limitation du nombre d'auditeurs🎜 🎜1 Sur un objet EventEmitter, le nombre maximum d'écouteurs pour un certain nom d'événement est de 10 par défaut. Cela peut être vérifié par emitter.getMaxListeners() : 🎜rrreee🎜Par exemple, j'ai écrit 11 fois. emitter.on ('test', handler), une erreur sera signalée, vous invitant à utiliser emitter.setMaxListeners() pour augmenter la limite maximale : 🎜🎜🎜🎜Si nous voulons savoir le nom d'un événement sur l'objet EventEmitter actuel. Combien y a-t-il d'auditeurs et s'ils dépassent la limite maximale ? Vous pouvez utiliser emitter.listenerCount() pour vérifier le nom de l'événement entrant : 🎜rrreee🎜Obtenir les noms d'événements et les auditeurs🎜🎜Utilisez emitter.eventNames() pour obtenir tous les noms d'événements enregistrés sur le objet EventEmitter actuel, et la chaîne d'événement renvoyée est composée de Array : 🎜rrreee🎜Si vous souhaitez obtenir tous les écouteurs correspondant à un événement, vous pouvez utiliser emitter.listeners() et transmettre l'événement nom : 🎜rrreee🎜Le résultat est le suivant : 🎜🎜🎜🎜 🎜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!