Let's talk about the events module in Node.js

This article will take you to understand the events module in the Node.js module, and introduce what is event-driven, the event architecture of NodeJS, the core API of the Events module, etc. I hope it will be helpful to everyone!

Quoting the official description: Most of the core API of Node.js is built around an idiomatic asynchronous event-driven architecture, in which certain types The object (called the "trigger") fires the named event, causing the Function object (the "listener") to be called.

Through the study and application of Node, we know that NodeJS adopts single-threaded, event-driven, non-blocking I/O and other architectural designs, which is very suitable for high concurrency, I /O intensive applications.

1. What is event-driven?

Event-driven, simply put, is to monitor changes in event status through effective methods, and take corresponding actions when changes occur.

Let’s take a life application scenario to understand: when we go to a restaurant to order food, after we place the order, the waiter tells us the order number (this can be understood as registering an event), and we are sitting While waiting, our ears have been listening to the waiter's call. When we are called, we can go to the front desk to pick up the meal. 2. Event model

The event architecture of NodeJS adopts the classic subscription-publishing model

The subscription-publishing model can also be called a message mechanism, which defines a Dependency, this dependency can be understood as a pair of N (multiple or single) observers that simultaneously monitor the corresponding state transition of an object. Once a change occurs, all observers are notified, thereby triggering the corresponding event registered by the observer. This design pattern solves the functional coupling between the subject object and the observer.

3. events module

The events module is a very important module of NodeJS. The implementation of most modules in node inherits the Events class, such as fs, http, net, etc. It provides an object events.EventEmitter. The core of EventEmitter is event emission and event listener.

Simple use:

import { EventEmitter } from 'events';

class MyEmiter extends EventEmitter{};

const myEmitter = new MyEmiter();

myEmitter.on('hello', () => {
  console.log('hello 有人喊你啦');
});

myEmitter.emit('hello');

4. Events module core API

eventEmitter.on(eventName, callback)Register to listen for events

Parameters:

• callback: the callback function called when the event is triggered

eventEmitter.once(eventName, callback)You can register a listener that can be called at most once for a specific event. Once the event is triggered, the listener is unregistered and then called.

Parameters:

• callback: the callback function called when the event triggers

eventEmitter.emit(eventName[, ...args])Trigger the specified listening event

Parameters:

• args optional parameters, passed in the parameters of the callback function in order;

eventEmitter.removeListener(eventName, callback)Remove the listener for the specified event. Note: the listener must be registered. Otherwise it is invalid.

Parameters:

• callback: callback function

EventEmitter.removeAllListeners (eventName)Remove all listeners. An event can have multiple listeners. If you need to remove them all, you can use this method.

Parameters:

EventEmitter.listeners(eventName)Returns the listener binding for the event named

A copy of the specified callback function array.

EventEmitter.eventNames() Returns an array listing the events for which the trigger has registered listeners.

EventEmitter.setMaxListeners(n)By default, if more than

are added for a specific event listener, EventEmitter will print a warning. The emitter.setMaxListeners() method allows modifying the limits for this specific

instance. The value can be set to Infinity (or 0) to indicate an unlimited number of listeners.

Call all listeners synchronously in the order of registration. This ensures correct ordering of events and helps avoid race conditions and logic errors.

When an error occurs in the

instance, the typical operation is to trigger 'error' event. These are treated as special cases in Node.js. <p>如果 <code>EventEmitter 没有为 'error' 事件注册至少一个监听器，并且触发 'error' 事件，则会抛出错误，打印堆栈跟踪，然后退出 Node.js 进程。

作为最佳实践，应始终为 'error' 事件添加监听器。

import { EventEmitter } from 'events';

class MyEmiter extends EventEmitter{};

const myEmitter = new MyEmiter();

myEmitter.on('hello', () => {
  console.log('hello 有人喊你啦');
});

myEmitter.on('error', (e) => {
  console.log(e)
})

myEmitter.emit('hello');
myEmitter.emit('error', new Error('an error happen'))

更多node相关知识，请访问：nodejs 教程！！

The above is the detailed content of Let's talk about the events module in Node.js. For more information, please follow other related articles on the PHP Chinese website!