Node.js Events and EventEmitter

Node.js' efficiency is partly due to its event-based architecture. Unlike reading all necessary files (like PHP) every request, Node.js simply starts the server, initializes most variables, declares the function, and then waits for the event to happen. Although Node.js has some useful events built in, such as request events, wouldn't it be more useful to be able to create and trigger custom events? This article will explore how to achieve this. First, we will demonstrate how to issue a normal event. For example, when someone enters a store, the bell rings to indicate its existence, which is similar to the observer pattern where events act as subjects and all functions attached to events are like observers. The store example is as follows:

<code class="language-javascript">const events = require('events');
const eventEmitter = new events.EventEmitter();

const ringBell = () => {
  console.log('ring ring ring');
};

eventEmitter.on('doorOpen', ringBell);

eventEmitter.emit('doorOpen');</code>

First, we load the Node.js core module events. Then, create an instance of the EventEmitter class (we will extend it later). After that, we put the ringBell function into a variable so that it can be called this way. It just prints "ring ring ring" in the console. Next is the key point. We use the eventEmitter.on() method to add the ringBell function to the function list of doorOpen events. The first parameter is the event name and the second parameter is the function to be added. This actually did nothing, just registered our function. The real magic happens in the next line, when we issue an event. Calling the emit() method will execute all functions registered with the on method. This is not that interesting, if we just want the bell to ring, we can call the function directly. But that's what's interesting about events: you can register as many functions as you like. For example, we can also do this:

<code class="language-javascript">eventEmitter.on('doorOpen', ringBell);
eventEmitter.on('doorOpen', doSomething);
eventEmitter.on('doorOpen', doSomethingElse);

eventEmitter.emit('doorOpen');</code>

This works just as well and makes full use of the features provided by EventEmitter. We can also use a function with parameters as a listener:

<code class="language-javascript">eventEmitter.on('doorOpen', (ring) => {
  console.log(ring);
});
eventEmitter.emit('doorOpen', 'ringeling');</code>

We just need to pass the parameters in the emit() method. Although this is very powerful, in the Node.js community, a common practice is to inherit from the EventEmitter class. We can do this by creating a Door class that has a open() method that will emit doorOpen events. Please see this code:

<code class="language-javascript">const events = require('events');

function Door(colour) {
  this.colour = colour;
  events.EventEmitter.call(this);

  this.open = () => {
    this.emit('open');
  };
}

Door.prototype.__proto__ = events.EventEmitter.prototype;

const frontDoor = new Door('brown');

frontDoor.on('open', () => {
  console.log('ring ring ring');
});
frontDoor.open();</code>

In our constructor of the Door object, we set the door color and execute the constructor method of the EventEmitter using the call() object's EventEmitter method. Then, we declare the open method, which emits the "open" event. This line of code:

<code class="language-javascript">const events = require('events');
const eventEmitter = new events.EventEmitter();

const ringBell = () => {
  console.log('ring ring ring');
};

eventEmitter.on('doorOpen', ringBell);

eventEmitter.emit('doorOpen');</code>

Copy all EventEmitter properties to Door objects. Then we create frontDoor, which is an instance of Door with a brown color. Then we add an event listener, finally open the door and print a message in the console. I hope everyone can see this events module is very powerful and useful! Finally, the events module provides us with a way to list all event listeners attached to events and delete event listeners.

<code class="language-javascript">eventEmitter.on('doorOpen', ringBell);
eventEmitter.on('doorOpen', doSomething);
eventEmitter.on('doorOpen', doSomethingElse);

eventEmitter.emit('doorOpen');</code>

You can use the listeners attribute to achieve it. Of course, this only works if you are not using anonymous functions as event listeners. If we want, we can remove the bell from the door:

<code class="language-javascript">eventEmitter.on('doorOpen', (ring) => {
  console.log(ring);
});
eventEmitter.emit('doorOpen', 'ringeling');</code>

Or, we can even remove all listeners:

<code class="language-javascript">const events = require('events');

function Door(colour) {
  this.colour = colour;
  events.EventEmitter.call(this);

  this.open = () => {
    this.emit('open');
  };
}

Door.prototype.__proto__ = events.EventEmitter.prototype;

const frontDoor = new Door('brown');

frontDoor.on('open', () => {
  console.log('ring ring ring');
});
frontDoor.open();</code>

Thank you for reading this guide and hope you gain something! See you next time!

Node.js Events and EventEmitter FAQs (FAQs)

What is the EventEmitter class in Node.js? How does it work?

The

EventEmitter class is a core module in Node.js that facilitates communication between objects. It is part of the events module for issuing and handling custom events. The EventEmitter class works by registering a function or event handler to a named event. When an event is emitted by an EventEmitter object, all functions attached to the event are called synchronously.

How to create an instance of EventEmitter?

Creating an instance of EventEmitter is simple. First, you need to import the events module. You can then create a new instance using the new keyword. Here is a simple example:

<code class="language-javascript">Door.prototype.__proto__ = events.EventEmitter.prototype;</code>

How to emit events using EventEmitter?

To issue an event, you can use the EventEmitter method of the emit instance. This method allows you to specify the event name and pass any number of parameters to the event listener. Here is an example:

<code class="language-javascript">const ring = () => {
  console.log('ring');
};
frontDoor.on('open', ring);

console.log(require('util').inspect(frontDoor.listeners('open'))); // 输出 [ ring ]</code>

How to listen for events using EventEmitter?

To listen for events, you can use the EventEmitter method of the on instance. This method allows you to specify the event name and a callback function that will be called when the event is emitted. Here is an example:

<code class="language-javascript">frontDoor.removeListener('open', ring);</code>

What is the difference between 'on' and 'once' methods in EventEmitter?

The

on method allows you to add a callback function that will be called every time the event is emitted. On the other hand, the once method allows you to add a callback function that will only be called when the event is emitted the first time.

How to remove event listener from EventEmitter?

To remove the event listener, you can use the EventEmitter or removeListener method of the off instance. This method allows you to specify the event name and the callback function that should be removed. Here is an example:

<code class="language-javascript">const events = require('events');
const eventEmitter = new events.EventEmitter();

const ringBell = () => {
  console.log('ring ring ring');
};

eventEmitter.on('doorOpen', ringBell);

eventEmitter.emit('doorOpen');</code>

Can I limit the number of listeners for events in EventEmitter?

Yes, you can use the EventEmitter method of the setMaxListeners instance to limit the number of listeners for events. This method allows you to specify the maximum number of listeners that can be added for events.

How to get the number of listeners for events in EventEmitter?

To get the number of listeners for an event, you can use the EventEmitter method of the listenerCount instance. This method allows you to specify an event name and return the number of listeners for that event.

Can I issue and handle errors in EventEmitter?

Yes, you can issue and handle errors in EventEmitter. If EventEmitter does not register at least a listener for error event and the error event is emitted, an error is thrown, a stack trace is printed, and the Node.js process will exit.

Can I use EventEmitter in my browser?

Although EventEmitter is a Node.js module and is mainly used for server-side applications, there are also available browser versions. These can be used like the Node.js version, allowing you to use the same event-driven architecture in your client code.

The above is the detailed content of Node.js Events and EventEmitter. For more information, please follow other related articles on the PHP Chinese website!