Node.js Events (original) (raw)

Last Updated : 3 Jun, 2026

An event represents an action or occurrence, such as a user interaction, file operation, or incoming request—that the system can detect and respond to. Events are handled using the EventEmitter class from the built-in events module, enabling Node.js to execute code asynchronously whenever specific actions occur.

Enables non-blocking, event-driven execution, which is core to Node.js performance
Uses the EventEmitter pattern to define, emit, and listen to custom or built-in events.

**How Do Events Work in NodeJS

**1. Event-Driven Model

NodeJS uses an event-driven approach, meaning it waits for events (such as a user action or data) to occur and then takes action when those events happen.

**2. EventEmitter

An EventEmitter is an object that can generate events in NodeJS.
You can set up "listeners" that wait for these events to happen and then run a function (called a callback) when the event occurs.

**3. Event Loop

The event loop is a mechanism that runs in the background, continuously checking for events.
When an event occurs, the event loop triggers the callback function that was registered for that event.

EventEmitter Class

At the core of the NodeJS event system is EventEmitter class, allowing objects to emit named events that can be listened to by other parts of your application. It is included in the built-in events module.

Key Features of EventEmitter

**on(event, listener): Adds a listener that waits for a specific event to occur.
**emit(event, [arg1, arg2, ...]): Triggers an event and calls all the listeners associated with it.
**once(event, listener): Adds a listener that is executed only the first time the event is triggered.
**removeListener(event, listener): Removes a specific listener for an event.
**removeAllListeners(event): Removes all listeners for a particular event.

Working with Events in NodeJS

**Step 1: To use events in your application, first import the events module and create an instance of the EventEmitter class.

const EventEmitter = require('events');
const myEmitter = new EventEmitter();

**Step 2: You can register listeners for specific events using the on() method. The first argument is the event name, and the second is the callback function that gets executed when the event is emitted.

myEmitter.on('event', () => {
console.log('An event occurred!');
});

**Step 3: To trigger an event, use the emit() method with the event name as the first argument. It will call all the listeners attached to that event.

myEmitter.emit('event');

**Output:

An event occurred!

**Adding Listeners

**Listening events

Before emitting an event, you must first register listeners (callback functions) that will listen for the event.

**Syntax:

eventEmitter.addListener(event, listener)
eventEmitter.on(event, listener)
eventEmitter.once(event, listener)

**eventEmitter.prependOnceListener()

It will add the one-time listener to the beginning of the array.

**Syntax:

eventEmitter.prependOnceListener(event, listener)

**eventEmitter.prependListener()

It will add the listener to the beginning of the array.

**Syntax:

eventEmitter.prependListener(event, listener)

**Removing Listeners

To remove a listener for an event, use removeListener() method with the event name and listener function. If you want to remove all listeners for an event, use removeAllListeners().

**Syntax:

eventEmitter.removeListener(event, listener)
eventEmitter.removeAllListeners([event])

**Note: Removing a listener with eventEmitter.removeListener() must be done carefully, as it removes only one instance of the specified listener (the first occurrence in the queue) and also alters the order of the remaining listeners in the array.

**Example:

javascript `

const EventEmitter = require('events'); var eventEmitter = new EventEmitter();

// Adding listener using on() eventEmitter.on('myEvent', fun1);

// Adding listener using addListener() eventEmitter.addListener('myEvent', fun2);

// Adding listener at the beginning using prependListener() eventEmitter.prependListener('myEvent', fun3);

// Adding a one-time listener at the beginning using prependOnceListener() eventEmitter.prependOnceListener('myEvent', fun4);

// First emit — fun4 fires and is auto-removed after this eventEmitter.emit('myEvent', "First emit");

// Removing fun1 using removeListener() eventEmitter.removeListener('myEvent', fun1);

// Second emit — fun1 won't fire, fun4 already removed itself eventEmitter.emit('myEvent', "Second emit");

// Removing all remaining listeners eventEmitter.removeAllListeners('myEvent');

// Third emit — no output, all listeners gone eventEmitter.emit('myEvent', "Third emit");

**Output:

Message from fun4 (once): First emit
Message from fun3: First emit
Message from fun1: First emit
Message from fun2: First emit
Message from fun3: Second emit
Message from fun2: Second emit

Inspecting Listeners

**eventEmitter.listeners()

It returns an array of listeners for the specified event.

**Syntax:

eventEmitter.listeners(event)

**eventEmitter.listenerCount()

It returns the number of listeners listening to the specified event.

**Syntax:

eventEmitter.listenerCount(event)

**Example:

javascript `

// Importing events const EventEmitter = require('events');

// Initializing event emitter instances var eventEmitter = new EventEmitter();

// Declaring listener fun1 to myEvent1 var fun1 = (msg) => { console.log("Message from fun1: " + msg); };

// Declaring listener fun2 to myEvent2 var fun2 = (msg) => { console.log("Message from fun2: " + msg); };

// Listening to myEvent with fun1 and fun2 eventEmitter.addListener('myEvent', fun1);

// fun2 will be inserted in front of listeners array eventEmitter.prependListener('myEvent', fun2);

// Listing listeners console.log(eventEmitter.listeners('myEvent'));

// Count the listeners registered to myEvent console.log(eventEmitter.listenerCount('myEvent'));

// Triggering myEvent eventEmitter.emit('myEvent', 'Event occurred');

**Output:

[ [Function: fun2], [Function: fun1] ]
2
Message from fun2: Event occurred
Message from fun1: Event occurred

**Special Events

All EventEmitter instances emit the event 'newListener' when new listeners are added and 'removeListener' existing listeners are removed.

**newListener: This event is emitted when a new listener is added. It's triggered before the listener is added to the internal array.

eventEmitter.once( 'newListener', listener)
eventEmitter.on( 'newListener', listener)

**removeListener: This event is emitted after a listener is removed.

eventEmitter.once( ‘removeListener’, listener)
eventEmitter.on( 'removeListener’, listener)

**error: When an error occurs, the 'error' event is emitted. If no listener is attached to this event, Node.js will throw an error and terminate the process.

eventEmitter.on('error', listener)

javascript ``

// Importing events const EventEmitter = require('events');

// Initializing event emitter instances var eventEmitter = new EventEmitter();

// Register to error eventEmitter.on('error', (err) => { console.error('whoops! there was an error'); });

// Register to newListener eventEmitter.on( 'newListener', (event, listener) => { console.log(The listener is added to ${event}); });

// Register to removeListener eventEmitter.on( 'removeListener', (event, listener) => { console.log(The listener is removed from ${event}); });

// Declaring listener fun1 to myEvent1 var fun1 = (msg) => { console.log("Message from fun1: " + msg); };

// Declaring listener fun2 to myEvent2 var fun2 = (msg) => { console.log("Message from fun2: " + msg); };

// Listening to myEvent with fun1 and fun2 eventEmitter.on('myEvent', fun1); eventEmitter.on('myEvent', fun2);

// Removing listener eventEmitter.off('myEvent', fun1);

// Triggering myEvent eventEmitter.emit('myEvent', 'Event occurred');

// Triggering error eventEmitter.emit('error', new Error('whoops!'));

**Output:

The listener is added to removeListener
The listener is added to myEvent
The listener is added to myEvent
The listener is removed from myEvent
Message from fun2: Event occurred
whoops! there was an error

**Asynchronous events

The EventEmitter calls all listeners synchronously in order to which they were registered. However, we can perform asynchronous calls by using setImmediate() or process.nextTick().

javascript `

// Importing events const EventEmitter = require('events');

// Initializing event emitter instances var eventEmitter = new EventEmitter();

// Async function listening to myEvent eventEmitter.on('myEvent', (msg) => { setImmediate( () => { console.log("Message from async: " + msg); }); });

// Declaring listener fun to myEvent var fun = (msg) => { console.log("Message from fun: " + msg); };

// Listening to myEvent with fun eventEmitter.on('myEvent', fun);

// Triggering myEvent eventEmitter.emit('myEvent', "Event occurred");

**Output:

Message from fun: Event occurred
Message from async: Event occurred

**Role of Events in NodeJS

**Asynchronous & Non-blocking: Events allow NodeJS to handle multiple tasks simultaneously without blocking the main thread, making them ideal for user actions, data streams, and network requests.
**Scalability: They help manage numerous connections or operations at the same time, improving overall application performance.
**Modular & Flexible: Custom events decouple different parts of your application, keeping code cleaner, more maintainable, and adaptable to specific requirements.