Node.js Events

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();

var fun1 = (msg) => { console.log("Message from fun1: " + msg); };
var fun2 = (msg) => { console.log("Message from fun2: " + msg); };
var fun3 = (msg) => { console.log("Message from fun3: " + msg); };
var fun4 = (msg) => { console.log("Message from fun4 (once): " + msg); };

// 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.
Comment

Explore