[译]理解 Node.js 事件驱动机制

时间 2019-11-09

原文原文链接

学习 Node.js 必定要理解的内容之一，文中主要涉及到了 EventEmitter 的使用和一些异步状况的处理，比较偏基础，值得一读。node

大多数 Node.js 对象都依赖了 EventEmitter 模块来监听和响应事件，好比咱们经常使用的 HTTP requests, responses, 以及 streams。数组

const EventEmitter = require('events');

事件驱动机制的最简单形式，是在 Node.js 中十分流行的回调函数，例如 fs.readFile。在回调函数这种形式中，事件每被触发一次，回调就会被触发一次。promise

咱们先来探索下这个最基本的方式。架构

你准备好了就叫我哈，Node！

好久好久之前，在 js 里尚未原生支持 Promise，async/await 还只是一个遥远的梦想，回调函数是处理异步问题的最原始的方式。app

回调从本质上讲是传递给其余函数的函数，在 JavaScript 中函数是第一类对象，这也让回调的存在成为可能。异步

必定要搞清楚的是，回调在代码中的并不表示异步调用。回调既能够是同步调用的，也能够是异步调用的。async

举个例子，这里有一个宿主函数 fileSize，它接受一个回调函数 cb，而且能够经过条件判断来同步或者异步地调用该回调函数：函数

function fileSize (fileName, cb) {
  if (typeof fileName !== 'string') {
    // Sync
    return cb(new TypeError('argument should be string')); 
  }  
  fs.stat(fileName, (err, stats) => {
    if (err) {   
      // Async
      return cb(err); 
     } 
     // Async
    cb(null, stats.size);
  });
}

这其实也是个反例，这样写常常会引发一些意外的错误，在设计宿主函数的时候，应当尽量的使用同一种风格，要么始终都是同步的使用回调，要么始终都是异步的。学习

咱们来研究下一个典型的异步 Node 函数的简单示例，它用回调样式编写：

const readFileAsArray = function(file, cb) {
  fs.readFile(file, function(err, data) {
    if (err) {
      return cb(err);
    }
    const lines = data.toString().trim().split('\n');
    cb(null, lines);
  });
};

readFileAsArray 函数接受两个参数：一个文件路径和一个回调函数。它读取文件内容，将其拆分红行数组，并将该数组做为回调函数的参数传入，调用回调函数。

如今设计一个用例，假设咱们在同一目录中的文件 numbers.txt 包含以下内容：

若是咱们有一个需求，要求统计该文件中的奇数数量，咱们可使用 readFileAsArray 来简化代码：

readFileAsArray('./numbers.txt', (err, lines) => {
  if (err) throw err;
  const numbers = lines.map(Number);
  const oddNumbers = numbers.filter(n => n%2 === 1);
  console.log('Odd numbers count:', oddNumbers.length);
});

这段代码将文件内容读入字符串数组中，回调函数将其解析为数字，并计算奇数的个数。

这才是最纯粹的 Node 回调风格。回调的第一个参数要遵循错误优先的原则，err 能够为空，咱们要将回调做为宿主函数的最后一个参数传递。你应该一直用这种方式这样设计你的函数，由于用户可能会假设。让宿主函数把回调当作其最后一个参数，并让回调函数以一个可能为空的错误对象做为其第一个参数。

回调在现代 JavaScript 中的替代品

在现代 JavaScript 中，咱们有 Promise，Promise 能够用来替代异步 API 的回调。回调函数须要做为宿主函数的一个参数进行传递（多个宿主回调进行嵌套就造成了回调地狱），并且错误和成功都只能在其中进行处理。而 Promise 对象可让咱们分开处理成功和错误，还容许咱们链式调用多个异步事件。

若是 readFileAsArray 函数支持 Promise，咱们能够这样使用它，以下所示：

readFileAsArray('./numbers.txt')
  .then(lines => {
    const numbers = lines.map(Number);
    const oddNumbers = numbers.filter(n => n%2 === 1);
    console.log('Odd numbers count:', oddNumbers.length);
  })
  .catch(console.error);

咱们在宿主函数的返回值上调用了一个函数来处理咱们的需求，这个 .then 函数会把刚刚在回调版本中的那个行数组传递给这里的匿名函数。为了处理错误，咱们在结果上添加一个 .catch 调用，当发生错误时，它会捕捉到错误并让咱们访问到这个错误。

在现代 JavaScript 中已经支持了 Promise 对象，所以咱们能够很容易的将其使用在宿主函数之中。下面是支持 Promise 版本的 readFileAsArray 函数（同时支持旧有的回调函数方式）：

const readFileAsArray = function(file, cb = () => {}) {
  return new Promise((resolve, reject) => {
    fs.readFile(file, function(err, data) {
      if (err) {
        reject(err);
        return cb(err);
      }      
      const lines = data.toString().trim().split('\n');
      resolve(lines);
      cb(null, lines);
    });
  });
};

咱们使该函数返回一个 Promise 对象，该对象包裹了 fs.readFile 的异步调用。Promise 对象暴露了两个参数，一个 resolve 函数和一个 reject 函数。

当有异常抛出时，咱们能够经过向回调函数传递 error 来处理错误，也一样可使用 Promise 的 reject 函数。每当咱们将数据交给回调函数处理时，咱们一样也能够用 Promise 的 resolve 函数。

在这种同时可使用回调和 Promise 的状况下，咱们须要作的惟一一件事情就是为这个回调参数设置默认值，防止在没有传递回调函数参数时，其被执行而后报错的状况。在这个例子中使用了一个简单的默认空函数：（）=> {}。

经过 async/await 使用 Promise

当须要连续调用异步函数时，使用 Promise 会让你的代码更容易编写。不断的使用回调会让事情变得愈来愈复杂，最终陷入回调地狱。

Promise 的出现改善了一点，Generator 的出现又改善了一点。处理异步问题的最新解决方式是使用 async 函数，它容许咱们将异步代码视为同步代码，使其总体上更加可读。

如下是使用 async/await 版本的调用 readFileAsArray 的例子：

async function countOdd () {
  try {
    const lines = await readFileAsArray('./numbers');
    const numbers = lines.map(Number);
    const oddCount = numbers.filter(n => n%2 === 1).length;
    console.log('Odd numbers count:', oddCount);
  } catch(err) {
    console.error(err);
  }
}
countOdd();

首先，咱们建立了一个 async 函数 —— 就是一个普通的函数声明以前，加了个 async 关键字。在 async 函数内部，咱们调用了 readFileAsArray 函数，就像把它的返回值赋值给变量 lines 同样，为了真的拿到 readFileAsArray 处理生成的行数组，咱们使用关键字 await。以后，咱们继续执行代码，就好像 readFileAsArray 的调用是同步的同样。

要让代码运行，咱们能够直接调用 async 函数。这让咱们的代码变得更加简单和易读。为了处理异常，咱们须要将异步调用包装在一个 try/catch 语句中。

有了 async/await 这个特性，咱们没必要使用任何特殊的API（如 .then 和 .catch ）。咱们只是把这种函数标记出来，而后使用纯粹的 JavaScript 写代码。

咱们能够把 async/await 这个特性用在支持使用 Promise 处理后续逻辑的函数上。可是，它没法用在只支持回调的异步函数上（例如setTimeout）。

EventEmitter 模块

EventEmitter 是一个处理 Node 中各个对象之间通讯的模块。 EventEmitter 是 Node 异步事件驱动架构的核心。 Node 的许多内置模块都继承自 EventEmitter。

它的概念其实很简单：emitter 对象会发出被定义过的事件，致使以前注册的全部监听该事件的函数被调用。因此，emitter 对象基本上有两个主要特征：

触发定义过的事件
注册或者取消注册监听函数

为了使用 EventEmitter，咱们须要建立一个继承自 EventEmitter 的类。

class MyEmitter extends EventEmitter {
}

咱们从 EventEmitter 的子类实例化的对象，就是 emitter 对象：

const myEmitter = new MyEmitter();

在这些 emitter 对象的生命周期里，咱们能够调用 emit 函数来触发咱们想要的触发的任何被命名过的事件。

myEmitter.emit('something-happened');

emit 函数的使用表示发生某种状况发生了，让你们去作该作的事情。这种状况一般是某些状态变化引发的。

咱们可使用 on 方法添加监听器函数，而且每次 emitter 对象触发其关联的事件时，将执行这些监听器函数。

事件 !== 异步

先看看这个例子：

const EventEmitter = require('events');

class WithLog extends EventEmitter {
  execute(taskFunc) {
    console.log('Before executing');
    this.emit('begin');
    taskFunc();
    this.emit('end');
    console.log('After executing');
  }
}

const withLog = new WithLog();

withLog.on('begin', () => console.log('About to execute'));
withLog.on('end', () => console.log('Done with execute'));

withLog.execute(() => console.log('*** Executing task ***'));

WithLog 是一个事件触发器，它有一个方法 —— execute，该方法接受一个参数，即具体要处理的任务函数，并在其先后包裹 log 以输出其执行日志。

为了看到这里会以什么顺序执行，咱们在两个命名的事件上都注册了监听器，最后执行一个简单的任务来触发事件。

下面是上面程序的输出结果：

Before executing
About to execute
*** Executing task ***
Done with execute
After executing

这里我想证明的是以上的输出都是同步发生的，这段代码里没有什么异步的成分。

第一行输出了 "Before executing"
begin 事件被触发，输出 "About to execute"
真正应该被执行的任务函数被调用，输出 " Executing task "
end 事件被触发，输出 "Done with execute"
最后输出 "After executing"

就像普通的回调同样，不要觉得事件意味着同步或异步代码。

跟以前的回调同样，不要一提到事件就认为它是异步的或者同步的，还要具体分析。

若是咱们传递 taskFunc 是一个异步函数，会发生什么呢？

// ...

withLog.execute(() => {
  setImmediate(() => {
    console.log('*** Executing task ***')
  });
});

输出结果变成了这样：

Before executing
About to execute
Done with execute
After executing
*** Executing task ***

这样就有问题了，异步函数的调用致使 "Done with execute" 和 "After executing" 的输出并不许确。

要在异步函数完成后发出事件，咱们须要将回调（或 Promise）与基于事件的通讯相结合。下面的例子说明了这一点。

使用事件而不是常规回调的一个好处是，咱们能够经过定义多个监听器对相同的信号作出多个不一样的反应。若是使用回调来完成这件事，咱们要在单个回调中写更多的处理逻辑。事件是应用程序容许多个外部插件在应用程序核心之上构建功能的好办法。你能够把它们当成钩子来挂一些因为状态变化而引起执行的程序。

异步事件

咱们把刚刚那些同步代码的示例改为异步的：

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

class WithTime extends EventEmitter {
  execute(asyncFunc, ...args) {
    this.emit('begin');
    console.time('execute');
    asyncFunc(...args, (err, data) => {
      if (err) {
        return this.emit('error', err);
      }

      this.emit('data', data);
      console.timeEnd('execute');
      this.emit('end');
    });
  }
}

const withTime = new WithTime();

withTime.on('begin', () => console.log('About to execute'));
withTime.on('end', () => console.log('Done with execute'));

withTime.execute(fs.readFile, __filename);

用 WithTime 类执行 asyncFunc 函数，并经过调用 console.time 和 console.timeEnd 报告该asyncFunc 所花费的时间。它在执行以前和以后都将以正确的顺序触发相应的事件，而且还会发出 error/data 事件做为处理异步调用的信号。

咱们传递一个异步的 fs.readFile 函数来测试一下 withTime emitter。咱们如今能够直接经过监听 data 事件来处理读取到的文件数据，而不用把这套处理逻辑写到 fs.readFile 的回调函数中。

执行这段代码，咱们以预期的顺序执行了一系列事件，而且获得异步函数的执行时间，这些是十分重要的。

About to execute
execute: 4.507ms
Done with execute

请注意，咱们是将回调与事件触发器 emitter 相结合实现的这部分功能。若是 asynFunc 支持Promise，咱们可使用 async/await 函数来作一样的事情：

class WithTime extends EventEmitter {
  async execute(asyncFunc, ...args) {
    this.emit('begin');
    try {
      console.time('execute');
      const data = await asyncFunc(...args);
      this.emit('data', data);
      console.timeEnd('execute');
      this.emit('end');
    } catch(err) {
      this.emit('error', err);
    }
  }
}

我认为这段代码比以前的回调风格的代码以及使用 .then/.catch 风格的代码更具可读性。async/await 让咱们更加接近 JavaScript 语言自己（没必要再使用 .then/.catch 这些 api）。

事件参数和错误

在以前的例子中，有两个事件被发出时还携带了别的参数。

error 事件被触发时会携带一个 error 对象。

this.emit('error', err);

data 事件被触发时会携带一个 data 对象。

this.emit('data', data);

咱们能够在 emit 函数中不断的添加参数，固然第一个参数必定是事件的名称，除去第一个参数以外的全部参数均可以在该事件注册的监听器中使用。

例如，要处理 data 事件，咱们注册的监听器函数将访问传递给 emit 函数的 data 参数，而这个 data 也正是由 asyncFunc 返回的数据。

withTime.on('data', (data) => {
  // do something with data
});

error 事件比较特殊。在咱们基于回调的那个示例中，若是不使用监听器处理 error 事件，node 进程将会退出。

举个因为错误使用参数而形成程序崩溃的例子：

class WithTime extends EventEmitter {
  execute(asyncFunc, ...args) {
    console.time('execute');
    asyncFunc(...args, (err, data) => {
      if (err) {
        return this.emit('error', err); // Not Handled
      }

      console.timeEnd('execute');
    });
  }
}

const withTime = new WithTime();

withTime.execute(fs.readFile, ''); // BAD CALL
withTime.execute(fs.readFile, __filename);

第一次调用 execute 将会触发 error 事件，因为没有处理 error ，Node 程序随之崩溃：

events.js:163
      throw er; // Unhandled 'error' event
      ^
Error: ENOENT: no such file or directory, open ''

第二次执行调用将受到此崩溃的影响，而且可能根本不会被执行。

若是咱们为这个 error 事件注册一个监听器函数来处理 error，结果将大不相同：

withTime.on('error', (err) => {
  // do something with err, for example log it somewhere
  console.log(err)
});

若是咱们执行上述操做，将会报告第一次执行 execute 时发送的错误，可是此次 node 进程不会崩溃退出，其余程序的调用也都能正常完成：

{ Error: ENOENT: no such file or directory, open '' errno: -2, code: 'ENOENT', syscall: 'open', path: '' }
execute: 4.276ms

须要注意的是，基于 Promise 的函数有些不一样，它们暂时只是输出一个警告:

UnhandledPromiseRejectionWarning: Unhandled promise rejection (rejection id: 1): Error: ENOENT: no such file or directory, open ''

DeprecationWarning: Unhandled promise rejections are deprecated. In the future, promise rejections that are not handled will terminate the Node.js process with a non-zero exit code.

另外一种处理异常的方式是在监听全局的 uncaughtException 进程事件。然而，使用该事件全局捕获错误并非一个好办法。

关于 uncaughtException，通常都会建议你避免使用它，可是若是必须用它，你应该让进程退出：

process.on('uncaughtException', (err) => {
  // something went unhandled.
  // Do any cleanup and exit anyway!

  console.error(err); // don't do just that.

  // FORCE exit the process too.
  process.exit(1);
});

可是，假设在同一时间发生多个错误事件，这意味着上面的 uncaughtException 监听器将被屡次触发，这可能会引发一些问题。

EventEmitter 模块暴露了 once 方法，这个方法发出的信号只会调用一次监听器。因此，这个方法常与 uncaughtException 一块儿使用。

监听器的顺序

若是针对一个事件注册多个监听器函数，当事件被触发时，这些监听器函数将按其注册的顺序被触发。

// first
withTime.on('data', (data) => {
  console.log(`Length: ${data.length}`);
});

// second
withTime.on('data', (data) => {
  console.log(`Characters: ${data.toString().length}`);
});

withTime.execute(fs.readFile, __filename);

上述代码会先输出 Length 信息，再输出 Characters 信息，执行的顺序与注册的顺序保持一致。

若是你想定义一个新的监听函数，可是但愿它可以第一个被执行，你还可使用 prependListener 方法：

withTime.on('data', (data) => {
  console.log(`Length: ${data.length}`);
});

withTime.prependListener('data', (data) => {
  console.log(`Characters: ${data.toString().length}`);
});

withTime.execute(fs.readFile, __filename);

上述代码中，Charaters 信息将首先被输出。

最后，你能够用 removeListener 函数来删除某个监听器函数。