目标：通过 demos 对事件驱动架构有个初步的认识

简述：
EventEmitter 在实际工作中使用相对较少，快速将 demos 给过一遍即可。重点在于认识“事件驱动架构”是一种什么样的编程体验，这对于我们学习那些基于 NodeJS 实现的框架而言，帮助是很大的。比如，Electron 就是基于 NodeJS 来实现的，在 Electron 中，用于实现 IPC 通信的模块 ipcMain、ipcRenderer 都是基于 EventEmitter 实现的，了解 EventEmitter 的一些常用 API，有助于我们快速上手 ipcMain、ipcRenderer。

参考资料：

概述

EventEmitter 是 Node.js 的核心模块之一，它提供了实现 事件驱动架构 的基本工具。在 Node.js 和基于 Node.js 的应用程序（例如 Electron）中，事件驱动架构是一个核心的设计理念。

  1. 异步编程：在 Node.js 中，异步编程是常态，EventEmitter 可以让你在某件事情完成（或者发生错误）时触发回调函数。
  2. 模块间解耦：通过事件，不同的模块可以相互通信，而不需要直接引用对方。
  3. 实现观察者模式：EventEmitter 提供了一种实现观察者模式的机制，观察者模式是一种设计模式，它定义了对象间的一种一对多的关系，当一个对象的状态发生改变时，所有依赖于它的对象都将得到通知。
  4. 提升应用程序性能：通过使用事件驱动的编程模型，我们可以非阻塞地处理 I/O，这可以让我们的应用程序在等待 I/O（如网络请求或文件读取）完成时做其他事情，从而提高应用程序的性能。

对于 Node.js 和基于 Node.js 的开发者来说，理解和掌握 EventEmitter 是非常重要的。

on、emit、addListener

  1. const {
  2.   EventEmitter
  3. } = require('events')
  5. const eIns = new EventEmitter()
  7. eIns.on('event', () => {
  8.   console.log('emit event')
  9. })
  11. // eIns.addListener('event', () => {
  12. //   console.log('emit event')
  13. // })
  15. eIns.emit('event')
  17. /* 
  18. emit event
  19. */

addListener 和 on 是 EventEmitter 类的两个方法，它们在功能上是完全相同的，用于注册事件监听器。实际上，on 方法就是 addListener 方法的别名，它们可以互换使用，没有实质性的区别。我们可以根据个人喜好和代码风格选择使用 addListener 或 on

多次 emit

  1. const {
  2.   EventEmitter
  3. } = require('events')
  5. const eIns = new EventEmitter()
  7. eIns.on('event', () => {
  8.   console.log('emit event')
  9. })
  11. eIns.emit('event')
  12. eIns.emit('event')
  13. eIns.emit('event')
  15. /*
  16. emit event
  17. emit event
  18. emit event
  19. */

传递参数

  1. const {
  2.   EventEmitter
  3. } = require('events')
  5. const eIns = new EventEmitter()
  7. eIns.on('event', (...args) => {
  8.   console.log('[emit event]:', ...args)
  9. })
  11. eIns.emit('event', 1)
  12. eIns.emit('event', 1, 2)
  13. eIns.emit('event', 1, 2, 3)
  15. /*
  16. [emit event]: 1
  17. [emit event]: 1 2
  18. [emit event]: 1 2 3
  19. */

once

  1. const {
  2.   EventEmitter
  3. } = require('events')
  5. const eIns = new EventEmitter()
  7. eIns.once('event', (...args) => {
  8.   console.log('[emit event]:', ...args)
  9. })
  11. eIns.emit('event', 1)
  12. eIns.emit('event', 1, 2)
  13. eIns.emit('event', 1, 2, 3)
  15. /*
  16. [emit event]: 1
  17. */

off、removeListener

  1. const {
  2.   EventEmitter
  3. } = require('events')
  5. const eIns = new EventEmitter()
  7. function cb(...args) {
  8.   console.log('[emit event]:', ...args)
  9. }
  11. eIns.on('event', cb)
  13. eIns.emit('event', 1)
  14. eIns.emit('event', 1, 2)
  16. eIns.off('event', cb)
  17. // eIns.removeListener('event', cb)
  19. eIns.emit('event', 1, 2, 3)
  21. /*
  22. [emit event]: 1
  23. [emit event]: 1 2
  24. */

与 on、addListener 一样，off 和 removeListener 也是等效的，根据自己习惯，选择一个喜欢的使用即可。

注意：

  • 如果我们在绑定 event 事件的监听器，使用的是匿名函数式的写法，那么 removeListener 是没法用的。因为匿名函数没有函数名，这将导致我们没法找到这个函数引用（监听器）。

多次 on

  1. const {
  2.   EventEmitter
  3. } = require('events')
  5. const eIns = new EventEmitter()
  7. function cb(...args) {
  8.   console.log('[emit event]:', ...args)
  9. }
  11. eIns.on('event', cb)
  12. eIns.on('event', cb)
  13. eIns.on('event', cb)
  15. eIns.emit('event', 1)
  17. eIns.off('event', cb)
  19. eIns.emit('event', 1, 2)
  21. eIns.off('event', cb)
  23. eIns.emit('event', 1, 2, 3)
  25. /*
  26. [emit event]: 1
  27. [emit event]: 1
  28. [emit event]: 1
  29. [emit event]: 1 2
  30. [emit event]: 1 2
  31. [emit event]: 1 2 3
  32. */

listenerCount

  1. const {
  2.   EventEmitter
  3. } = require('events')
  5. const eIns = new EventEmitter()
  7. function cb(...args) {
  8.   console.log('[emit event]:', ...args)
  9. }
  11. eIns.on('event', cb)
  12. eIns.on('event', cb)
  13. eIns.on('event', cb)
  15. console.log(`[eIns.listenerCount('event')]:`, eIns.listenerCount('event'))
  17. eIns.emit('event', 1)
  19. eIns.removeListener('event', cb)
  21. console.log(`[eIns.listenerCount('event')]:`, eIns.listenerCount('event'))
  23. eIns.emit('event', 1, 2)
  25. eIns.removeListener('event', cb)
  27. console.log(`[eIns.listenerCount('event')]:`, eIns.listenerCount('event'))
  29. eIns.emit('event', 1, 2, 3)
  31. /*
  32. [eIns.listenerCount('event')]: 3
  33. [emit event]: 1
  34. [emit event]: 1
  35. [emit event]: 1
  36. [eIns.listenerCount('event')]: 2
  37. [emit event]: 1 2
  38. [emit event]: 1 2
  39. [eIns.listenerCount('event')]: 1
  40. [emit event]: 1 2 3
  41. */

removeAllListeners

  1. const {
  2.   EventEmitter
  3. } = require('events')
  5. const eIns = new EventEmitter()
  7. function cb(...args) {
  8.   console.log('[emit event]:', ...args)
  9. }
  11. eIns.on('event', cb)
  12. eIns.on('event', cb)
  13. eIns.on('event', cb)
  15. console.log(`[eIns.listenerCount('event')]:`, eIns.listenerCount('event'))
  17. eIns.emit('event', 1)
  19. eIns.removeListener('event', cb)
  21. console.log(`[eIns.listenerCount('event')]:`, eIns.listenerCount('event'))
  23. eIns.emit('event', 1, 2)
  25. eIns.removeAllListeners('event')
  27. console.log(`[eIns.listenerCount('event')]:`, eIns.listenerCount('event'))
  29. eIns.emit('event', 1, 2, 3)
  31. /*
  32. [eIns.listenerCount('event')]: 3
  33. [emit event]: 1
  34. [emit event]: 1
  35. [emit event]: 1
  36. [eIns.listenerCount('event')]: 2
  37. [emit event]: 1 2
  38. [emit event]: 1 2
  39. [eIns.listenerCount('event')]: 0
  40. */
  1. const {
  2.   EventEmitter
  3. } = require('events')
  5. const eIns = new EventEmitter()
  7. eIns.on('event', (...args) => {
  8.   console.log('[emit event]:', ...args)
  9. })
  11. eIns.on('event', (...args) => {
  12.   console.log('[emit event]:', ...args)
  13. })
  15. eIns.emit('event', 1)
  16. eIns.emit('event', 1, 2)
  18. eIns.removeAllListeners('event')
  20. eIns.emit('event', 1, 2, 3)
  22. /*
  23. [emit event]: 1
  24. [emit event]: 1
  25. [emit event]: 1 2
  26. [emit event]: 1 2
  27. */

立即执行

  1. const {
  2.   EventEmitter
  3. } = require('events')
  5. const eIns = new EventEmitter()
  7. eIns.on('event1', () => {
  8.   console.log('1')
  9.   eIns.emit('event2')
  10.   console.log('3')
  11. })
  13. eIns.on('event2', () => {
  14.   console.log('2')
  15. })
  17. eIns.emit('event1')
  19. console.log("4")
  21. /*
  22. 1
  23. 2
  24. 3
  25. 4
  26. */

emit 一个不存在的事件，相当于什么也没做

  1. const {
  2.   EventEmitter
  3. } = require('events')
  5. const eIns = new EventEmitter()
  7. console.log(1)
  9. eIns.emit('event')
  11. console.log(2)
  13. /*
  14. 1
  15. 2
  16. */

当我们在 EventEmitter 实例上 emit 一个不存在的事件时，它将静默失败，没有任何影响，不会引发错误或抛出异常。

emit(‘error’)

  1. const {
  2.   EventEmitter
  3. } = require('events')
  5. const eIns = new EventEmitter()
  7. console.log(1)
  9. // eIns.on('error', () => {
  10. //   // ...
  11. // })
  13. eIns.emit('error')
  15. console.log(2)
  17. /*
  18. 1
  19. node:events:504
  20.     throw err; // Unhandled 'error' event
  21.     ^
  23. Error [ERR_UNHANDLED_ERROR]: Unhandled error. (undefined)
  24.     at new NodeError (node:internal/errors:399:5)
  25.     at EventEmitter.emit (node:events:502:17)
  26.     at Object.<anonymous> (/Users/huyouda/0000/0.js:9:6)
  27.     at Module._compile (node:internal/modules/cjs/loader:1254:14)
  28.     at Module._extensions..js (node:internal/modules/cjs/loader:1308:10)
  29.     at Module.load (node:internal/modules/cjs/loader:1117:32)
  30.     at Module._load (node:internal/modules/cjs/loader:958:12)
  31.     at Function.executeUserEntryPoint [as runMain] (node:internal/modules/run_main:81:12)
  32.     at node:internal/main/run_main_module:23:47 {
  33.   code: 'ERR_UNHANDLED_ERROR',
  34.   context: undefined
  35. }
  37. Node.js v18.15.0
  38. */

所有的 EventEmitter 实例默认都会注册一个 error 事件监听器。这意味着如果在 EventEmitter 实例中没有显式地注册 error 事件监听器，当触发了一个错误事件且没有对其进行处理时，Node.js 将会打印错误堆栈信息，并可能导致程序退出。

  1. const {
  2.   EventEmitter
  3. } = require('events')
  5. const eIns = new EventEmitter()
  7. console.log(1)
  9. try {
  10.   eIns.emit('error')
  11. } catch (error) {
  12.   console.error('[emit error event]:', error)
  13. }
  15. console.log(2)
  17. /*
  18. 1
  19. [emit error event]: Error [ERR_UNHANDLED_ERROR]: Unhandled error. (undefined)
  20.     at new NodeError (node:internal/errors:399:5)
  21.     at EventEmitter.emit (node:events:502:17)
  22.     at Object.<anonymous> (/Users/huyouda/0000/0.js:10:8)
  23.     at Module._compile (node:internal/modules/cjs/loader:1254:14)
  24.     at Module._extensions..js (node:internal/modules/cjs/loader:1308:10)
  25.     at Module.load (node:internal/modules/cjs/loader:1117:32)
  26.     at Module._load (node:internal/modules/cjs/loader:958:12)
  27.     at Function.executeUserEntryPoint [as runMain] (node:internal/modules/run_main:81:12)
  28.     at node:internal/main/run_main_module:23:47 {
  29.   code: 'ERR_UNHANDLED_ERROR',
  30.   context: undefined
  31. }
  32. 2
  33. */

为了避免程序崩溃，我们可以使用 try-catch 包裹一下 eIns.emit('error')。这样可以保证即使出现错误，程序也能够继续执行，并采取适当的措施来处理错误情况。

  1. const {
  2.   EventEmitter
  3. } = require('events')
  5. const eIns = new EventEmitter()
  7. console.log(1)
  9. eIns.on('error', (...args) => {
  10.   console.error('[emit error event]:', ...args)
  11. })
  13. eIns.emit('error', 1, 2, 3)
  15. console.log(2)
  17. /*
  18. 1
  19. [emit error event]: 1 2 3
  20. 2
  21. */

如果不想使用 try-catch，同时又要避免程序崩溃，建议在使用 EventEmitter 的时候，始终为 error 事件注册一个监听器，以便能够捕获和处理错误。

  1. const fs = require('fs');
  2. const {
  3.   EventEmitter
  4. } = require('events')
  6. const readStream = fs.createReadStream('1.txt');
  8. console.log('[readStream instanceof EventEmitter]:', readStream instanceof EventEmitter)
  10. readStream.on('error', (error) => {
  11.   console.error('发生错误:', error);
  12. });
  14. readStream.on('data', (data) => {
  15.   console.log('文件内容:', data.toString());
  16. });
  18. /* 
  19. [readStream instanceof EventEmitter]: true
  20. 文件内容: 现在时间：
  21. 23.05.18 周四 下午 11:22
  23. 写完这个 demo 滚去睡觉了
  24. */
  1. 现在时间：
  2. 23.05.18 周四 下午 11:22
  4. 写完这个 demo 滚去睡觉了