Node.js EventEmitter

All asynchronous I/O operations in Node.js send an event to the event queue when they complete.

Many objects in Node.js dispatch events: a net.Server object emits an event every time a new connection is established, and an fs.readStream object emits an event when a file is opened. All of these objects that produce events are instances of events.EventEmitter.

EventEmitter is a core module in Node.js used for creating, registering, and triggering events.

EventEmitter is the foundation of event-driven programming and helps developers easily implement event publishing and subscription mechanisms.

EventEmitter Class

The events module provides only one object: events.EventEmitter.

The core of EventEmitter is the encapsulation of event triggering and event listener functionality.

You can userequire("events");to access this module.

If an error occurs while instantiating an EventEmitter object, the error event is emitted. The newListener event is emitted when a new listener is added, and the removeListener event is emitted when a listener is removed.

Below we use a simple example to illustrate the usage of EventEmitter:

After running this code, the console outputs the following after 1 second:some_event event triggeredThe principle is that the event object registers a listener for the some_event event. Then, after 1000 milliseconds, we send the some_event event to the event object via setTimeout, at which point the some_event listener is called.

The execution result is as follows:

$ node event.js 
some_event 事件触发

Each EventEmitter event consists of an event name and several parameters. The event name is a string that usually expresses a certain meaning. For each event, EventEmitter supports several event listeners.

When an event is triggered, the event listeners registered for that event are called in sequence, and the event parameters are passed as callback function arguments.

Let us explain this process with the following example:

Running the above code produces the following result:

$ node event.js 
listener1 arg1 参数 arg2 参数
listener2 arg1 参数 arg2 参数

In the above example, emitter registers two event listeners for the event someEvent, and then triggers the someEvent event.

From the running result, you can see that the two event listener callback functions are called one after another. This is the simplest usage of EventEmitter.

EventEmitter provides several properties, such asonandemit。ona function for binding event handlers,emitand a property for triggering an event. Next, let us take a closer look at the EventEmitter properties.

Methods

server.on('connection', function (stream) {
  console.log('someone connected!');
});

server.once('connection', function (stream) {
  console.log('Ah, we have our first user!');
});

var callback = function(stream) {
  console.log('someone connected!');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);

Class Methods

events.EventEmitter.listenerCount(emitter, eventName) //已废弃，不推荐
events.emitter.listenerCount(eventName) //推荐

Register an event listener:

Output:

Hello, Alice!

Use once() to register a one-time event:

myEmitter.once('init', () => {
  console.log('Initialization event occurred');
});

myEmitter.emit('init'); // 打印: Initialization event occurred
myEmitter.emit('init'); // 不会再触发

Parameters can be passed when an event is triggered for use by the listeners:

If the triggered event has no corresponding listener, EventEmitter will throw an error:

Events

Example

The following example demonstrates the application of the EventEmitter class through the connection event.

Create a main.js file with the following code:

The execution result of the above code is as follows:

$ node main.js
2 个监听器监听连接事件。
监听器 listener1 执行。
监听器 listener2 执行。
listener1 不再受监听。
监听器 listener2 执行。
1 个监听器监听连接事件。
程序执行完毕。

error Event

EventEmitter defines a special event, error, which carries the semantics of an error. We usually trigger the error event when an exception occurs.

When error is triggered, EventEmitter stipulates that if there is no corresponding listener, Node.js will treat it as an exception, exit the program, and output an error message.

We generally set listeners for objects that may trigger the error event to prevent the whole program from crashing after an error occurs. For example:

var events = require('events'); 
var emitter = new events.EventEmitter(); 
emitter.emit('error'); 

The following error will be displayed at runtime:

node.js:201 
throw e; // process.nextTick error, or 'error' event on first tick 
^ 
Error: Uncaught, unspecified 'error' event. 
at EventEmitter.emit (events.js:50:15) 
at Object.<anonymous> (/home/byvoid/error.js:5:9) 
at Module._compile (module.js:441:26) 
at Object..js (module.js:459:10) 
at Module.load (module.js:348:31) 
at Function._load (module.js:308:12) 
at Array.0 (module.js:479:10) 
at EventEmitter._tickCallback (node.js:192:40) 

Inheriting EventEmitter

Most of the time we do not use EventEmitter directly, but inherit it in objects. All core modules that support event responses, including fs, net, and http, are subclasses of EventEmitter.

Why do we do this? There are two reasons:

• First, implementing events in an object with a certain concrete functionality is semantically appropriate; event listening and emitting should be methods of an object.

• Second, JavaScript's object mechanism is prototype-based and supports partial multiple inheritance. Inheriting EventEmitter will not disturb the object's original inheritance relationship.

Most Node.js core modules (such as HTTP and the file system) inherit EventEmitter. You can create your own classes to inherit EventEmitter.