Node.js 怎么使用 Event Emitters 实现事件驱动？

在本步骤中，我们将探索在 Node.js 中创建 event emitter 的两种最常见方式。第一种是直接使用 event emitter 对象，第二种是创建一个扩展 event emitter 对象的对象。

选择哪种方式取决于你的 event 与对象动作的耦合程度。如果你要发射的 event 是对象动作的结果，你可能会扩展 event emitter 对象，以便方便地访问其函数。如果你要发射的 event 独立于你的业务对象，或者是多个业务对象动作的结果，你则应该创建一个独立的 event emitter 对象，并让你的对象引用它。

让我们开始创建一个独立的、发射 event 的对象。我们首先创建一个文件夹来存储所有代码。在你的终端中，创建一个名为 event-emitters 的新文件夹：

mkdir event-emitters

然后进入该文件夹：

cd event-emitters

在文本编辑器中打开第一个 event emitter 文件 firstEventEmitter.js。我们将使用 nano，因为它在终端中可用：

nano firstEventEmitter.js

在 Node.js 中，我们通过 EventEmitter class 来发射 event。这个 class 是 events module 的一部分。让我们首先在文件中加载 events module，添加以下行：

event-emitters/firstEventEmitter.js

const { EventEmitter } = require("events");

导入 class 后，我们可以使用它来创建新对象实例：

event-emitters/firstEventEmitter.js

const { EventEmitter } = require("events");

const firstEmitter = new EventEmitter();

让我们通过在 firstEventEmitter.js 末尾添加以下突出显示的行来发射一个 event：

event-emitters/firstEventEmitter.js

const { EventEmitter } = require("events");

const firstEmitter = new EventEmitter();


firstEmitter.emit("My first event");

emit() 函数用于触发 event。我们需要将 event 名称作为字符串传递给它。可以在 event 名称后添加任意数量的参数。只包含名称的 event 相当有限；其他参数允许我们向 listener 发送数据。当我们设置票务管理器时，我们的 event 将在购买发生时传递购买相关数据。请记住 event 的名称，因为 event listener 将通过此名称来识别它。

注意：虽然在本示例中我们没有捕获它，但 emit() 函数如果 event 有 listener，则返回 true。如果 event 没有 listener，则返回 false。

让我们运行这个文件看看会发生什么。保存并退出 nano，然后使用 node 命令执行文件：

node firstEventEmitter.js

当脚本执行完毕后，你会在终端中看到没有输出。这是因为我们在 firstEventEmitter.js 中没有记录任何消息，也没有监听发送的 event。event 被发射了，但没有任何东西对这些 event 做出响应。

让我们逐步实现一个更完整的示例，包括发布、监听和响应 event。我们将通过创建一个票务管理器示例应用来实现。票务管理器将暴露一个购买票务的函数。当票务被购买时，将发送一个包含购买者详情的 event。后来，我们将创建另一个 Node.js module 来模拟向购买者邮箱发送确认购买的邮件。

让我们开始创建票务管理器。它将扩展 EventEmitter class，这样我们就不必创建单独的 event emitter 对象来发射 event。

在同一工作目录中，创建并打开一个名为 ticketManager.js 的新文件：

nano ticketManager.js

与第一个 event emitter 一样，我们需要从 events module 导入 EventEmitter class。在文件开头放入以下代码：

event-emitters/ticketManager.js

const EventEmitter = require("events");

现在，创建一个新的 TicketManager class，它很快将定义购买票务的方法：

event-emitters/ticketManager.js

const EventEmitter = require("events");

class TicketManager extends EventEmitter {}

在这种情况下，TicketManager class 扩展了 EventEmitter class。这意味着 TicketManager class 继承了 EventEmitter class 的方法和属性。这就是它获得 emit() 方法访问权限的方式。

在我们的票务管理器中，我们希望提供可购买的初始票务供应。我们将通过在 constructor() 中接受初始供应来实现，这是一个当创建 class 的新对象时被调用的特殊函数。在 TicketManager class 中添加以下 constructor：

event-emitters/ticketManager.js

const EventEmitter = require("events");

class TicketManager extends EventEmitter {
    constructor(supply) {
        super();
        this.supply = supply;
    }
}

constructor 有一个 supply 参数。这是一个数字，详细说明我们可售卖的初始票务供应。虽然我们声明 TicketManager 是 EventEmitter 的子类，但我们仍然需要调用 super() 来获得 EventEmitter 的方法和属性访问权限。super() 函数调用父函数的 constructor，在本例中是 EventEmitter。

最后，我们使用 this.supply 为对象创建一个 supply 属性，并赋予它 constructor 传入的值。

现在，让我们添加一个 buy() 方法，当票务被购买时调用它。该方法将减少供应量并发射包含购买数据的 event。

按以下方式添加 buy() 方法：

event-emitters/ticketManager.js

const EventEmitter = require("events");

class TicketManager extends EventEmitter {
    constructor(supply) {
        super();
        this.supply = supply;
    }
    
    buy(email, price) {
        this.supply--;
        this.emit("buy", email, price, Date.now());
    }
}

在 buy() 函数中，我们获取购买者的邮箱地址和他们为票务支付的价格。然后我们将票务供应量减少一。我们以发射一个 buy event 结束。这次，我们发射一个带有额外数据的 event：函数中传入的邮箱和价格，以及购买发生时的时间戳。

为了让我们的其他 Node.js module 可以使用这个 class，我们需要导出它。在文件末尾添加这一行：

event-emitters/ticketManager.js

...

module.exports = TicketManager

保存并退出文件。

我们已经完成了 event emitter TicketManager 的设置。现在我们已经为推送 event 做好了准备，可以继续读取和处理这些 event。为此，我们将在下一步创建 event listener。

步骤 2 — 监听事件

Node.js 允许我们通过 event emitter 对象的 on() 函数为事件添加监听器。这会监听特定的事件名称，并在事件触发时执行回调函数。添加监听器通常看起来像这样：

eventEmitter.on(event_name, callback_function) {
    action
}

注意：Node.js 将 on() 方法别名为 addListener()。它们执行相同的任务。在本教程中，我们将继续使用 on()。

让我们通过监听第一个事件来获得第一手体验。创建一个名为 firstListener.js 的新文件：

nano firstListener.js

作为 on() 函数工作原理的演示，让我们在接收到第一个事件时记录一条简单消息。

首先，将 TicketManager 导入到我们的新 Node.js 模块中。在 firstListener.js 中添加以下代码：

event-emitters/firstListener.js

const TicketManager = require("./ticketManager");

const ticketManager = new TicketManager(10);

回想一下，TicketManager 对象在创建时需要初始的门票供应。这就是为什么我们传递 10 参数。

现在让我们添加第一个 Node.js 事件监听器。它将监听 buy 事件。添加以下突出显示的代码：

event-emitters/firstListener.js

const TicketManager = require("./ticketManager");

const ticketManager = new TicketManager(10);

ticketManager.on("buy", () => {
    console.log("Someone bought a ticket!");
});

要添加新监听器，我们使用了 ticketManager 对象的一部分 on() 函数。on() 方法适用于所有 event emitter 对象，由于 TicketManager 继承自 EventEmitter class，因此该方法在所有 TicketManager 实例对象上都可用。

on() 方法的第二个参数是一个回调函数，以箭头函数的形式编写。该函数中的代码在事件发出后运行。在这种情况下，如果发出 buy 事件，我们会在控制台记录 "Someone bought a ticket!"。

现在我们已经设置了监听器，让我们使用 buy() 函数来发出事件。在文件末尾添加以下内容：

event-emitters/firstListener.js

...

ticketManager.buy("test@email.com", 20);

这将使用用户邮箱 test@email.com 和门票价格 20 执行 buy 方法。

保存并退出文件。

现在使用 node 运行此脚本：

node firstListener.js

你的控制台将显示：

OutputSomeone bought a ticket!

你的第一个事件监听器工作了。让我们看看如果购买多张门票会发生什么。在文本编辑器中重新打开 firstListener.js：

nano firstListener.js

在文件末尾，再次调用 buy() 函数：

event-emitters/firstListener.js

...

ticketManager.buy("test@email.com", 20);
ticketManager.buy("test@email.com", 20);

保存并退出文件。让我们使用 Node.js 运行脚本看看会发生什么：

node firstListener.js

你的控制台将显示：

OutputSomeone bought a ticket!
Someone bought a ticket!

由于 buy() 函数被调用了两次，因此发出了两个 buy 事件。我们的监听器捕获了这两个事件。

有时我们只对事件第一次触发感兴趣，而不是每次发出时都监听。Node.js 为这种情况提供了 on() 的替代方法，即 once() 函数。

与 on() 类似，once() 函数将事件名称作为第一个参数，并在事件触发时调用的回调函数作为第二个参数。在底层，当事件发出并被使用 once() 的监听器接收时，Node.js 会自动移除该监听器，然后执行回调函数中的代码。

通过编辑 firstListener.js 来查看 once() 的实际效果：

nano firstListener.js

在文件末尾，使用 once() 添加一个新的事件监听器，如以下突出显示的行：

event-emitters/firstListener.js

const TicketManager = require("./ticketManager");

const ticketManager = new TicketManager(10);

ticketManager.on("buy", () => {
        console.log("Someone bought a ticket!");
});

ticketManager.buy("test@email.com", 20);
ticketManager.buy("test@email.com", 20);

ticketManager.once("buy", () => {
    console.log("This is only called once");
});

保存并退出文件，然后使用 node 运行此程序：

node firstListener.js

输出与上次相同：

OutputSomeone bought a ticket!
Someone bought a ticket!

虽然我们使用 once() 添加了一个新的事件监听器，但它是在 buy 事件发出之后添加的。因此，该监听器没有检测到这两个事件。你无法监听过去已经发生的事件。添加监听器时，只能捕获之后发生的事件。

让我们再添加几个 buy() 函数调用，以确认 once() 监听器只响应一次。像之前一样在文本编辑器中打开 firstListener.js：

nano firstListener.js

在文件末尾添加以下调用：

event-emitters/firstListener.js

...

ticketManager.once("buy", () => {
    console.log("This is only called once");
});

ticketManager.buy("test@email.com", 20);
ticketManager.buy("test@email.com", 20);

保存并退出，然后执行此程序：

node firstListener.js

你的输出将是：

OutputSomeone bought a ticket!
Someone bought a ticket!
Someone bought a ticket!
This is only called once
Someone bought a ticket!

前两行来自在添加 once() 监听器之前的前两次 buy() 调用。添加新的事件监听器不会移除之前的监听器，因此我们添加的第一个事件监听器仍然活跃并记录消息。

由于使用 on() 的事件监听器是在使用 once() 的事件监听器之前声明的，我们看到 Someone bought a ticket! 在 This is only called once 之前。这两行都响应倒数第二次 buy 事件。

最后，当进行最后一次 buy() 调用时，event emitter 只剩下使用 on() 创建的第一个监听器。如前所述，当使用 once() 创建的事件监听器接收到事件时，它会被自动移除。

现在我们已经添加了事件监听器来检测我们的 emitter，接下来我们将看到如何使用这些监听器捕获数据。

步骤 3 — 捕获事件数据

到目前为止，你已经设置了事件监听器来响应已发出的事件。发出的事件还会传递数据。让我们看看如何捕获伴随事件的数据。

我们将首先创建一些新的 Node.js 模块：一个邮件服务和一个数据库服务。它们分别用于模拟发送邮件和保存到数据库。然后，我们将使用主 Node.js 脚本——index.js——将它们整合在一起。

让我们开始编辑邮件服务模块。用文本编辑器打开文件：

nano emailService.js

我们的邮件服务由一个包含单个方法——send()——的 class 组成。此方法期望接收与 buy 事件一起发出的邮件地址。将以下代码添加到文件中：

event-emitters/emailService.js

class EmailService {
    send(email) {
        console.log(`Sending email to ${email}`);
    }
}

module.exports = EmailService

这段代码创建了一个 EmailService class，其中包含一个 send() function。由于不实际发送邮件，它使用模板字符串向控制台记录一条消息，该消息将包含购买门票的人的邮件地址。保存并退出，然后继续。

让我们设置数据库服务。用文本编辑器打开 databaseService.js：

nano databaseService.js

数据库服务通过其 save() 方法将我们的购买数据保存到数据库。将以下代码添加到 databaseService.js 中：

event-emitters/databaseService.js

class DatabaseService {
    save(email, price, timestamp) {
        console.log(`Running query: INSERT INTO orders VALUES (email, price, created) VALUES (${email}, ${price}, ${timestamp})`);
    }
}

module.exports = DatabaseService

这创建了一个新的 DatabaseService class，其中包含单个 save() 方法。与邮件服务的 send() 方法类似，save() function 使用伴随 buy 事件的数据，将其记录到控制台而不是实际插入数据库。此方法需要购买者的邮件地址、门票价格以及购买门票的时间才能正常工作。保存并退出文件。

我们将使用最后一个文件将 TicketManager、EmailService 和 DatabaseService 整合在一起。它将为 buy 事件设置一个监听器，并调用邮件服务的 send() function 和数据库服务的 save() function。

用文本编辑器打开 index.js 文件：

nano index.js

首先要做的是导入我们使用的模块：

event-emitters/index.js

const TicketManager = require("./ticketManager");
const EmailService = require("./emailService");
const DatabaseService = require("./databaseService");

接下来，为我们导入的 class 创建对象。为本次演示，我们将门票供应量设置为 3：

event-emitters/index.js

const TicketManager = require("./ticketManager");
const EmailService = require("./emailService");
const DatabaseService = require("./databaseService");

const ticketManager = new TicketManager(3);
const emailService = new EmailService();
const databaseService = new DatabaseService();

现在，我们可以使用已实例化的对象设置监听器。每当有人购买门票时，我们希望同时发送邮件并将数据保存到数据库。将以下监听器添加到你的代码中：

event-emitters/index.js

const TicketManager = require("./ticketManager");
const EmailService = require("./emailService");
const DatabaseService = require("./databaseService");

const ticketManager = new TicketManager(3);
const emailService = new EmailService();
const databaseService = new DatabaseService();


ticketManager.on("buy", (email, price, timestamp) => {
    emailService.send(email);
    databaseService.save(email, price, timestamp);
});

与之前一样，我们使用 on() 方法添加监听器。这次的区别在于回调 function 中有三个参数。每个参数对应事件发出时传递的数据。提醒一下，这是 buy() function 中的 emitter 代码：

event-emitters/ticketManager.js

this.emit("buy", email, price, Date.now());

在我们的回调中，首先捕获 emitter 的 email，然后是 price，最后是 Date.now() 数据，我们将其捕获为 timestamp。

当我们的监听器检测到 buy 事件时，它将调用 emailService 对象的 send() function，以及 databaseService 的 save() function。为了测试此设置是否有效，让我们在文件末尾调用 buy() function：

event-emitters/index.js

...

ticketManager.buy("test@email.com", 10);

保存并退出编辑器。现在让我们使用 node 运行此脚本，并观察接下来的输出。在终端中输入：

node index.js

你将看到以下输出：

OutputSending email to test@email.com
Running query: INSERT INTO orders VALUES (email, price, created) VALUES (test@email.com, 10, 1588720081832)

数据已成功捕获并在我们的回调 function 中返回。有了这些知识，你可以为各种具有不同事件名称和数据的 emitter 设置监听器。不过，使用 event emitters 处理错误事件时有一些细微差别。

接下来，让我们看看如何处理错误事件，以及我们应该遵循哪些标准。

步骤 4 — 处理错误事件

如果事件发射器无法执行其操作，它应该发射一个事件来表示该操作失败。在 Node.js 中，事件发射器表示失败的标准方式是发射一个error event。

error 事件必须将其名称设置为error。它还必须伴随一个Error对象。让我们看一个发射 error 事件的实际示例。

我们的票务管理器每次调用buy()函数时都会将供应量减少一个。目前没有任何东西阻止它出售超过可用数量的票。让我们修改buy()函数，以便如果票务供应量达到0且有人想购买票时，我们发射一个错误事件，表示缺货。

再次在文本编辑器中打开ticketManager.js：

nano ticketManager.js

现在按以下方式编辑buy()函数：

event-emitters/ticketManager.js

...

buy(email, price) {
    if (this.supply > 0) {
        this.supply—;
        this.emit("buy", email, price, Date.now());
        return;
    }

    this.emit("error", new Error("There are no more tickets left to purchase"));
}
...

我们添加了一个if语句，如果我们的供应量大于零，则允许购买票。如果我们没有其他票了，我们将发射一个error事件。error事件使用一个新的Error对象发射，该对象包含我们抛出此错误的原因描述。

保存并退出文件。让我们尝试在index.js文件中抛出这个错误。目前，我们只购买一张票。我们用三张票实例化了ticketManager对象，因此如果我们尝试购买四张票，应该会得到一个错误。

使用文本编辑器编辑index.js：

nano index.js

现在在文件末尾添加以下行，以便总共购买四张票：

event-emitters/index.js

...

ticketManager.buy("test@email.com", 10);
ticketManager.buy("test@email.com", 10);
ticketManager.buy("test@email.com", 10);
ticketManager.buy("test@email.com", 10);

保存并退出编辑器。

让我们执行这个文件，看看会发生什么：

node index.js

你的输出将是：

OutputSending email to test@email.com
Running query: INSERT INTO orders VALUES (email, price, created) VALUES (test@email.com, 10, 1588724932796)
Sending email to test@email.com
Running query: INSERT INTO orders VALUES (email, price, created) VALUES (test@email.com, 10, 1588724932812)
Sending email to test@email.com
Running query: INSERT INTO orders VALUES (email, price, created) VALUES (test@email.com, 10, 1588724932812)
events.js:196
      throw er; // Unhandled 'error' event
      ^

Error: There are no more tickets left to purchase
    at TicketManager.buy (/home/sammy/event-emitters/ticketManager.js:16:28)
    at Object.<anonymous> (/home/sammy/event-emitters/index.js:17:15)
    at Module._compile (internal/modules/cjs/loader.js:1128:30)
    at Object.Module._extensions..js (internal/modules/cjs/loader.js:1167:10)
    at Module.load (internal/modules/cjs/loader.js:983:32)
    at Function.Module._load (internal/modules/cjs/loader.js:891:14)
    at Function.executeUserEntryPoint [as runMain] (internal/modules/run_main.js:71:12)
    at internal/main/run_main_module.js:17:47
Emitted 'error' event on TicketManager instance at:
    at TicketManager.buy (/home/sammy/event-emitters/ticketManager.js:16:14)
    at Object.<anonymous> (/home/sammy/event-emitters/index.js:17:15)
    [... lines matching original stack trace ...]
    at internal/main/run_main_module.js:17:47

前三个buy事件被正确处理，但第四个buy事件导致我们的程序崩溃。让我们检查错误消息的开头：

Output...
events.js:196
      throw er; // 未处理的 'error' event
      ^

Error: There are no more tickets left to purchase
    at TicketManager.buy (/home/sammy/event-emitters/ticketManager.js:16:28)
...

前两行突出显示了一个错误被抛出。注释说"Unhandled 'error' event"（未处理的 'error' event）。如果事件发射器发射了一个 error 事件，而我们没有为 error 事件附加监听器，Node.js 会抛出该错误并使程序崩溃。

如果您正在监听事件发射器，最佳实践是始终监听error事件。如果您没有为错误设置监听器，当一个错误被发射时，整个应用程序都会崩溃。使用错误监听器，您可以优雅地处理它。

为了遵循最佳实践，让我们为错误设置一个监听器。重新打开index.js文件：

nano index.js

在开始购买票之前添加一个监听器。请记住，监听器只能响应在其添加之后发射的事件。像这样插入一个错误监听器：

event-emitters/index.js

...

ticketManager.on("error", (error) => {
    console.error(`优雅地处理我们的错误： ${error}`);
});

ticketManager.buy("test@email.com", 10);
ticketManager.buy("test@email.com", 10);
ticketManager.buy("test@email.com", 10);
ticketManager.buy("test@email.com", 10);

当我们收到 error 事件时，我们将使用console.error()将其记录到控制台。

保存并退出nano。重新运行脚本，查看我们的 error 事件被正确处理：

node index.js

这次将显示以下输出：

OutputSending email to test@email.com
Running query: INSERT INTO orders VALUES (email, price, created) VALUES (test@email.com, 10, 1588726293332)
Sending email to test@email.com
Running query: INSERT INTO orders VALUES (email, price, created) VALUES (test@email.com, 10, 1588726293348)
Sending email to test@email.com
Running query: INSERT INTO orders VALUES (email, price, created) VALUES (test@email.com, 10, 1588726293348)
优雅地处理我们的错误：Error: There are no more tickets left to purchase

从最后一行，我们确认我们的 error 事件正由我们的第二个监听器处理，并且 Node.js 进程没有崩溃。

现在我们已经涵盖了发送和监听事件的概念，让我们看看一些可以用来管理事件监听器的额外功能。

步骤 5 — 管理事件监听器

事件发射器提供了一些机制来监控和控制订阅到某个事件上的监听器数量。要获取处理某个事件的监听器数量概览，我们可以使用每个对象中都包含的 listenerCount() 方法。

listenerCount() 方法接受一个参数：你想要获取计数的 event name。让我们在 index.js 中实际查看它的效果。

使用 nano 或你选择的文本编辑器打开文件：

nano index.js

你当前调用了四次 buy() 函数。删除这四行代码。然后添加这两行新代码，使你的整个 index.js 文件如下所示：

event-emitters/index.js

const TicketManager = require("./ticketManager");
const EmailService = require("./emailService");
const DatabaseService = require("./databaseService");

const ticketManager = new TicketManager(3);
const emailService = new EmailService();
const databaseService = new DatabaseService();

ticketManager.on("buy", (email, price, timestamp) => {
    emailService.send(email);
    databaseService.save(email, price, timestamp);
});

ticketManager.on("error", (error) => {
    console.error(`优雅地处理我们的错误： ${error}`);
});

console.log(`buy 事件有 ${ticketManager.listenerCount("buy")} 个监听器`);
console.log(`error 事件有 ${ticketManager.listenerCount("error")} 个监听器`);

我们删除了前一节中对 buy() 的调用，改为向控制台输出两行日志。第一条日志语句使用 listenerCount() 函数显示 buy 事件的监听器数量。第二条日志语句显示 error 事件的监听器数量。

保存并退出。现在使用 node 命令运行你的脚本：

node index.js

你将看到以下输出：

Outputbuy 事件有 1 个监听器
error 事件有 1 个监听器

我们只为 buy 事件和 error 事件各使用了一次 on() 函数，因此这个输出符合我们的预期。

接下来，我们将在从事件发射器中移除监听器时使用 listenerCount()。当某个事件的使用期限不再适用时，我们可能需要移除事件监听器。例如，如果我们的票务管理器用于特定的演唱会，当演唱会结束时，你会移除事件监听器。

在 Node.js 中，我们使用 off() 函数从事件发射器中移除事件监听器。off() 方法接受两个参数：事件名称和监听该事件的函数。

注意：与 on() 函数类似，Node.js 将 off() 方法别名为 removeListener()。它们功能相同，参数也相同。在本教程中，我们将继续使用 off()。

off() 函数的第二个参数需要对监听事件的 callback 的引用。因此，要移除事件监听器，其 callback 必须保存在某个变量或常量中。目前，我们无法使用 off() 函数移除 buy 或 error 的当前事件监听器。

为了查看 off() 的实际效果，让我们添加一个将在后续调用中移除的新事件监听器。首先，将 callback 定义在一个变量中，以便稍后在 off() 中引用它。用 nano 打开 index.js：

nano index.js

在 index.js 的末尾添加以下内容：

event-emitters/index.js

...

const onBuy = () => {
    console.log("我很快就会被移除");
};

现在为 buy 事件添加另一个事件监听器：

event-emitters/index.js

...

ticketManager.on("buy", onBuy);

为了确认我们成功添加了该事件监听器，让我们打印 buy 的监听器数量并调用 buy() 函数。

event-emitters/index.js

...

console.log(`我们添加了一个新的事件监听器，使 buy 事件的总数达到： ${ticketManager.listenerCount("buy")}`);
ticketManager.buy("test@email", 20);

保存并退出文件，然后运行程序：

node index.js

终端中将显示以下消息：

Outputbuy 事件有 1 个监听器
error 事件有 1 个监听器
我们添加了一个新的事件监听器，使 buy 事件的总数达到： 2
向 test@email 发送邮件
执行查询：INSERT INTO orders VALUES (email, price, created) VALUES (test@email, 20, 1588814306693)
我很快就会被移除

从输出中，我们可以看到添加新事件监听器时的日志语句。然后调用 buy() 函数，两个监听器都对此作出响应。第一个监听器发送了邮件并将数据保存到数据库，然后第二个监听器将消息 我很快就会被移除 打印到屏幕上。

现在让我们使用 off() 函数移除第二个事件监听器。在 nano 中重新打开文件：

nano index.js

现在在文件末尾添加以下 off() 调用。你还将添加一个日志语句来确认监听器数量，并再次调用 buy()：

event-emitters/index.js

...

ticketManager.off("buy", onBuy);

console.log(`现在 buy 事件有： ${ticketManager.listenerCount("buy")} 个监听器`);
ticketManager.buy("test@email", 20);

注意 onBuy 变量如何作为 off() 的第二个参数使用。保存并退出文件。

现在用 node 运行它：

node index.js

之前的输出保持不变，但这次我们会发现新添加的日志行确认我们再次只有一个监听器。当再次调用 buy() 时，我们只会看到第一个监听器使用的 callback 的输出：

Outputbuy 事件有 1 个监听器
error 事件有 1 个监听器
我们添加了一个新的事件监听器，使 buy 事件的总数达到： 2
向 test@email 发送邮件
执行查询：INSERT INTO orders VALUES (email, price, created) VALUES (test@email, 20, 1588816352178)
我很快就会被移除
现在 buy 事件有： 1 个监听器
向 test@email 发送邮件
执行查询：INSERT INTO orders VALUES (email, price, created) VALUES (test@email, 20, 1588816352178)

如果我们想使用 off() 移除所有事件，可以使用 removeAllListeners() 函数。该函数接受一个参数：我们要移除监听器的事件名称。

让我们在文件末尾使用这个函数移除我们为 buy 事件添加的第一个事件监听器。再次打开 index.js 文件：

nano index.js

你将首先使用 removeAllListeners() 移除所有监听器。然后使用 listenerCount() 函数记录包含监听器数量的语句。为了确认它不再监听，你将再购买一张票。当事件被触发时，没有任何东西会对此作出响应。

在文件末尾输入以下代码：

event-emitters/index.js

...

ticketManager.removeAllListeners("buy");
console.log(`buy 事件有 ${ticketManager.listenerCount("buy")} 个监听器`);
ticketManager.buy("test@email", 20);
console.log("最后一张票被购买了");

保存并退出文件。

现在使用 node 命令执行我们的代码：

node index.js

我们的最终输出是：

buy 事件有 1 个监听器
error 事件有 1 个监听器
我们添加了一个新的事件监听器，使 buy 事件的总数达到： 2
向 test@email 发送邮件
执行查询：INSERT INTO orders VALUES (email, price, created) VALUES (test@email, 20, 1588817058088)
我很快就会被移除
现在 buy 事件有： 1 个监听器
向 test@email 发送邮件
执行查询：INSERT INTO orders VALUES (email, price, created) VALUES (test@email, 20, 1588817058088)
buy 事件有 0 个监听器
最后一张票被购买了

移除所有监听器后，我们不再为购票发送邮件或保存到数据库。

结论

在本教程中，您学习了如何使用 Node.js event emitters 来触发事件。您使用 EventEmitter 对象的 emit() 函数发出事件，然后使用 on() 和 once() 函数监听事件，以便在事件每次触发时执行代码。您还为 error event 添加了监听器，并使用 listenerCount() 函数监控和管理监听器。

如果使用 callbacks 和 promises，我们的 ticket manager 系统需要与 email 和 database service 模块集成才能获得相同的功能。由于我们使用了 event emitters，事件与实现解耦。此外，任何有权访问 ticket manager 的模块都可以观察其事件并对其作出响应。如果您希望 Node.js 模块（内部或外部）观察您的对象发生的情况，请考虑将其设计为 event emitter 以实现可扩展性。

要深入了解 Node.js 中的事件，您可以阅读 Node.js 官方文档。如果您想继续学习 Node.js，可以返回 How To Code in Node.js 系列，或者浏览我们的 Node 主题页面上的编程项目和配置。

感谢您与 Community 一起学习。请查看我们提供的计算、存储、网络和管理数据库服务。

了解更多我们的产品

教程系列： How To Code in Node.js

Node.js 是一个流行的开源运行时环境，可以在浏览器之外执行 JavaScript。Node 运行时通常用于后端 Web 开发，利用其异步能力创建网络应用和 Web 服务器。Node 也是构建命令行工具的热门选择。

在本系列中，您将通过练习学习 Node.js 编程基础，在此过程中获得后端和全栈开发的有力工具。

Node.js

Development

JavaScript

访问系列页面

浏览系列：14 个教程

1/14 - How To Write and Run Your First Program in Node.js
2/14 - How To Use the Node.js REPL
3/14 - How To Use Node.js Modules with npm and package.json

See author profile

Node.js 怎么使用 Event Emitters 实现事件驱动？

相关问答