Events are an important part of Node.js. They allow different parts of an application to communicate when something happens. For example, an application can respond when a user connects, a file finishes loading, or a custom event is triggered.
Node.js uses an event-driven programming model. Code can register functions that run when particular events occur.
Common examples of events include:
Node.js provides a built-in module named node:events.
It includes the EventEmitter class, which lets us
create, emit, and handle custom events.
const EventEmitter = require('node:events');
console.log("Events Module Loaded");Output:
Events Module Loaded
This example uses CommonJS syntax. In an ES Module
project, use
import { EventEmitter } from 'node:events';.
To work with custom events, create an instance of the
EventEmitter class.
const EventEmitter = require('node:events');
const event = new EventEmitter();
console.log("Event object created");Output:
Event object created
The event object can now register listeners
and emit custom events.
The on() method registers a listener function.
The listener runs whenever the specified event is emitted.
const EventEmitter = require('node:events');
const event = new EventEmitter();
event.on('greet', function() {
console.log("Hello Students!");
});
event.emit('greet');Output:
Hello Students!
The listener is registered with on().
When emit('greet') is called, the listener
executes.
The emit() method triggers an event. If listeners
have been registered for that event, they are called.
const EventEmitter = require('node:events');
const event = new EventEmitter();
event.on('start', function() {
console.log("Program started");
});
event.emit('start');Output:
Program started
We can pass data to listeners by supplying arguments to
emit(). The listener receives those arguments
in the same order.
const EventEmitter = require('node:events');
const event = new EventEmitter();
event.on('student', function(name) {
console.log("Student Name:", name);
});
event.emit('student', 'Amit');Output:
Student Name: AmitAn event can pass multiple values to its listener, such as a student's name, age, and course.
const EventEmitter = require('node:events');
const event = new EventEmitter();
event.on('student', function(name, age, course) {
console.log("Name:", name);
console.log("Age:", age);
console.log("Course:", course);
});
event.emit('student', 'Rahul', 20, 'Node.js');Output:
Name: Rahul
Age: 20
Course: Node.jsWe can register multiple listeners for the same event. Each listener runs when that event is emitted.
const EventEmitter = require('node:events');
const event = new EventEmitter();
event.on('message', function() {
console.log("First listener");
});
event.on('message', function() {
console.log("Second listener");
});
event.emit('message');Output:
First listener
Second listenerFor ordinary synchronous listeners, Node.js calls listeners in registration order.
The once() method registers a listener that runs
only once. After its first execution, that listener is removed.
const EventEmitter = require('node:events');
const event = new EventEmitter();
event.once('login', function() {
console.log("Login event handled");
});
event.emit('login');
event.emit('login');
event.emit('login');Output:
Login event handledEven though the event is emitted three times, the listener runs only on its first emission.
The off() method removes a previously registered
listener. The same function reference must be supplied.
const EventEmitter = require('node:events');
const event = new EventEmitter();
function showMessage() {
console.log("Hello Students");
}
event.on('message', showMessage);
event.emit('message');
event.off('message', showMessage);
event.emit('message');Output:
Hello StudentsThe first emission calls the listener. The second emission does not call it because it has been removed.
The listenerCount() method returns the number of
listeners registered for a particular event on an
EventEmitter instance.
const EventEmitter = require('node:events');
const event = new EventEmitter();
event.on('data', function() {});
event.on('data', function() {});
console.log(event.listenerCount('data'));Output:
2Let's create an event that runs whenever a student registers in an application.
const EventEmitter = require('node:events');
const studentEvents = new EventEmitter();
studentEvents.on('registered', function(name, course) {
console.log("New Student Registered");
console.log("Name:", name);
console.log("Course:", course);
});
studentEvents.emit('registered', 'Amit', 'Node.js');Output:
New Student Registered
Name: Amit
Course: Node.jsThis is a simple example of using events to separate the action that announces a registration from the code that responds to it.
| Method | Purpose |
|---|---|
on() |
Registers a listener. |
emit() |
Triggers an event. |
once() |
Registers a listener that runs once. |
off() |
Removes a specific listener. |
removeListener() |
Removes a specific listener. |
removeAllListeners() |
Removes listeners for one event or all events. |
listenerCount() |
Returns the number of listeners for an event. |
EventEmitter class.enroll.once() and trigger it twice.Starter code:
const EventEmitter = require('node:events');
const school = new EventEmitter();
school.on('enroll', function(name, course) {
console.log(name + " enrolled in " + course);
});
school.emit('enroll', 'Amit', 'Node.js');
school.emit('enroll', 'Rahul', 'JavaScript');Expected output:
Amit enrolled in Node.js
Rahul enrolled in JavaScriptSelect the correct answer for each question.
1. Which method triggers an event?
2. Which method registers a listener that runs only once?
3. Which class is used to create custom event emitters?