JS `Node.js Event Emitter`：构建高效的事件驱动系统

各位观众老爷们，大家好！今天咱们来聊聊 Node.js 的 Event Emitter，这玩意儿听起来高大上，其实就是个加强版的“你拍一，我拍一”的游戏，只不过拍的不是手，是事件。咱要学会用它，就能构建出高效的事件驱动系统，让你的代码像打了鸡血一样，嗖嗖的！

开场白：事件驱动，是个啥玩意儿？

在传统的编程模式里，程序像个乖宝宝，一步一步按照你写好的流程走。但在事件驱动的世界里，程序就像个侦探，时刻监听着各种事件的发生，一旦有风吹草动，立刻做出反应。比如，用户点击了一个按钮，这就是一个事件；服务器接收到一个请求，这也是一个事件。

这种模式的好处是啥呢？灵活！你的代码不再被固定的流程束缚，可以根据不同的事件做出不同的响应，从而提高程序的并发能力和响应速度。

Event Emitter：事件的“中央电视台”

Node.js 的 Event Emitter 就是一个事件的“中央电视台”，负责管理各种事件的发射和监听。它就像一个邮局，你往里面投递信件（事件），它会把信件分发给对应的收件人（监听器）。

咱来看看 Event Emitter 的基本用法：

引入模块

首先，你需要引入 events 模块：
```
const EventEmitter = require('events');
```
这就像你要开邮局，总得先有个招牌吧？
创建实例

然后，你需要创建一个 EventEmitter 的实例：
```
const myEmitter = new EventEmitter();
```
这就是你的邮局，以后所有的事件都从这里发出。
监听事件

接下来，你需要告诉 EventEmitter，你要监听哪些事件，以及当这些事件发生时，你要做什么。这就是注册监听器：
```
myEmitter.on('事件名称', (参数1, 参数2, ...) => {
  // 事件发生时要执行的代码
});
```
on 方法就是用来注册监听器的。第一个参数是事件的名称，第二个参数是一个回调函数，当事件发生时，这个函数会被执行。回调函数可以接收到事件传递过来的参数。

比如，咱要监听一个名为 data 的事件：
```
myEmitter.on('data', (data) => {
  console.log('接收到数据：', data);
});
```
这就像告诉邮局，如果收到 data 的信件，就打印出来。
发射事件

最后，你需要发射事件，告诉 EventEmitter，某个事件发生了。这就是发送事件：
```
myEmitter.emit('事件名称', 参数1, 参数2, ...);
```
emit 方法就是用来发射事件的。第一个参数是事件的名称，后面的参数是事件要传递的数据。

比如，咱要发射一个 data 事件，并传递一个数据：
```
myEmitter.emit('data', 'Hello, world!');
```
这就像往邮局投递一封 data 的信件，内容是 "Hello, world!"。

代码示例：一个简单的事件驱动程序

咱来写一个简单的程序，模拟一个计数器：

const EventEmitter = require('events');

class Counter extends EventEmitter {
  constructor() {
    super();
    this.count = 0;
  }

  increment() {
    this.count++;
    this.emit('count', this.count); // 发射 count 事件，并传递 count 的值
  }

  decrement() {
    this.count--;
    this.emit('count', this.count); // 发射 count 事件，并传递 count 的值
  }
}

const counter = new Counter();

counter.on('count', (count) => {
  console.log('当前计数：', count);
});

counter.increment(); // 输出：当前计数： 1
counter.increment(); // 输出：当前计数： 2
counter.decrement(); // 输出：当前计数： 1

在这个例子中，Counter 类继承了 EventEmitter。 increment 和 decrement 方法会改变 count 的值，并发射 count 事件，通知所有监听器。

进阶用法：更高级的事件处理技巧

除了 on 和 emit 方法，EventEmitter 还提供了一些其他的有用的方法：

once(event, listener): 只监听一次事件，事件发生后，监听器会自动移除。这就像一次性的优惠券，用完就失效了。

myEmitter.once('greet', () => {
  console.log('你好！');
});

myEmitter.emit('greet'); // 输出：你好！
myEmitter.emit('greet'); // 不会输出任何内容

removeListener(event, listener): 移除指定的监听器。这就像撤销订阅，你不想再收到某个频道的节目了。

const listener = () => {
  console.log('收到通知！');
};

myEmitter.on('notification', listener);
myEmitter.emit('notification'); // 输出：收到通知！
myEmitter.removeListener('notification', listener);
myEmitter.emit('notification'); // 不会输出任何内容

removeAllListeners([event]): 移除所有监听器。如果指定了事件名称，则只移除该事件的所有监听器。这就像清空收件箱，把所有的信件都扔掉。

myEmitter.on('message', () => {
  console.log('收到消息！');
});

myEmitter.on('error', () => {
  console.log('发生错误！');
});

myEmitter.removeAllListeners('message'); // 只移除 message 事件的监听器
myEmitter.emit('message'); // 不会输出任何内容
myEmitter.emit('error');   // 输出：发生错误！

myEmitter.removeAllListeners(); // 移除所有事件的监听器
myEmitter.emit('error');   // 不会输出任何内容

listeners(event): 返回指定事件的所有监听器。这就像查看订阅列表，看看你都订阅了哪些频道。

const listener1 = () => {
  console.log('监听器 1');
};

const listener2 = () => {
  console.log('监听器 2');
};

myEmitter.on('update', listener1);
myEmitter.on('update', listener2);

const listeners = myEmitter.listeners('update');
console.log(listeners); // 输出：[ [Function: listener1], [Function: listener2] ]

listenerCount(event): 返回指定事件的监听器数量。这就像统计订阅人数，看看有多少人订阅了某个频道。

myEmitter.on('download', () => {});
myEmitter.on('download', () => {});

const count = myEmitter.listenerCount('download');
console.log(count); // 输出：2

getMaxListeners() 和 setMaxListeners(n): EventEmitter 默认最多允许一个事件注册 10 个监听器。可以使用 getMaxListeners() 获取当前的最大监听器数量，使用 setMaxListeners(n) 设置新的最大监听器数量。这就像设置频道容量，防止频道被挤爆。
```
console.log(myEmitter.getMaxListeners()); // 输出：10

myEmitter.setMaxListeners(20);
console.log(myEmitter.getMaxListeners()); // 输出：20
```

错误处理：防止程序崩溃

在使用 EventEmitter 时，最重要的事情之一就是错误处理。如果在事件处理函数中抛出异常，如果没有捕获，Node.js 进程会直接崩溃。

为了避免这种情况，你可以使用 try...catch 语句来捕获异常：

myEmitter.on('error', (err) => {
  console.error('发生错误：', err);
});

myEmitter.on('data', (data) => {
  try {
    // 可能会抛出异常的代码
    if (typeof data !== 'string') {
      throw new Error('数据类型不正确');
    }
    console.log('接收到数据：', data.toUpperCase());
  } catch (err) {
    myEmitter.emit('error', err); // 发射 error 事件，通知错误
  }
});

myEmitter.emit('data', 123); // 触发异常
myEmitter.emit('data', 'hello'); // 正常处理

在这个例子中，如果 data 不是字符串，toUpperCase() 方法会抛出异常。 try...catch 语句会捕获这个异常，并使用 emit 方法发射 error 事件，通知错误。

EventEmitter 的应用场景

EventEmitter 在 Node.js 中被广泛应用，比如：

HTTP 服务器: http.Server 继承了 EventEmitter，可以监听 request 和 close 等事件。
文件系统: fs.ReadStream 和 fs.WriteStream 继承了 EventEmitter，可以监听 data、end 和 error 等事件。
流 (Stream): Node.js 中的流都继承了 EventEmitter，可以监听 data、end 和 error 等事件。
自定义模块: 你可以使用 EventEmitter 来构建自己的事件驱动模块，实现灵活的事件处理。

EventEmitter 和 Promise/async/await 的结合

EventEmitter 和 Promise/async/await 可以结合使用，让你的代码更加简洁易读。

你可以使用 util.promisify 方法将 EventEmitter 的事件转换为 Promise：

const EventEmitter = require('events');
const util = require('util');

class MyEmitter extends EventEmitter {
  constructor() {
    super();
    this.emitAfterDelay = (event, value, delay) => {
        setTimeout(() => {
            this.emit(event, value);
        }, delay);
    }
}

const myEmitter = new MyEmitter();

const once = util.promisify(myEmitter.once).bind(myEmitter);

async function main() {
  myEmitter.emitAfterDelay('done', 'result', 1000);
  const result = await once('done');
  console.log('Done!', result);
}

main();

在这个例子中，util.promisify(myEmitter.once) 将 myEmitter.once 方法转换成了一个返回 Promise 的函数。 async/await 可以等待 done 事件的发生，并获取事件传递的数据。

总结：Event Emitter，你的代码加速器

EventEmitter 是 Node.js 中一个非常重要的模块，它可以帮助你构建高效的事件驱动系统。掌握 EventEmitter 的用法，可以让你的代码更加灵活、可扩展和易于维护。

灵魂拷问：

你觉得 EventEmitter 最酷的地方是什么？
你还能想到哪些 EventEmitter 的应用场景？
你打算用 EventEmitter 做什么有趣的事情？

希望今天的讲座对大家有所帮助。谢谢大家！

最后，留个小作业：

写一个程序，模拟一个简单的聊天室。当用户发送消息时，程序会把消息广播给所有在线用户。用 EventEmitter 来实现消息的广播功能。期待大家的精彩作品！

表格总结

方法	描述
`on(event, listener)`	注册一个监听器，当指定的事件发生时，监听器会被调用。
`once(event, listener)`	注册一个只调用一次的监听器。当指定的事件第一次发生时，监听器会被调用，然后监听器会被移除。
`emit(event, ...args)`	触发一个事件，并传递任意数量的参数给监听器。
`removeListener(event, listener)`	移除指定的监听器。
`removeAllListeners([event])`	移除所有监听器。如果指定了事件名称，则只移除该事件的所有监听器。
`listeners(event)`	返回指定事件的所有监听器数组。
`listenerCount(event)`	返回指定事件的监听器数量。
`getMaxListeners()`	获取当前允许的最大监听器数量。
`setMaxListeners(n)`	设置允许的最大监听器数量。

发表回复 取消回复

发表回复取消回复