Node.js EventEmitter

The EventEmitter class in Node.js supports event-driven, asynchronous communication between objects.

• Provided by the core events module.
• Allows objects to emit and listen to events.
• Used to create and manage custom events.

Importing EventEmitter

The EventEmitter class is imported from the core events module to create and handle custom events in Node.js.

Syntax

const EventEmitter = require('events');

• All EventEmitter instances emit the newListener event when a new listener is added.
• All EventEmitter instances emit the removeListener event when an existing listener is removed.
• EventEmitter provides the captureRejections option.
• captureRejections is of type boolean.
• The default value of captureRejections is false.
• When set to true, Promise rejections from async listeners are automatically emitted as 'error' events.

Listening events

Before emits any event, it must register functions(callbacks) to listen to the events.

Syntax

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

• eventEmitter.on(event, listener) and eventEmitter.addListener(event, listener) are functionally equivalent.
• Both add the listener to the end of the listeners array for the specified event.
• Registering the same listener multiple times results in multiple executions.
• Each listener is triggered once per registration.
• Both methods return the emitter, enabling method chaining.

Emitting events

In Node.js, each event is represented by a specific event name. We can trigger an event using the emit(event, [arg1], [arg2], [...]) function. Arbitrary arguments can be passed to the listener functions when the event is emitted.

• Events in Node.js are identified by unique event names and triggered using emit(event, ...args).
• Arguments passed to emit() are received by the registered listener functions.

Example: Creates an EventEmitter, registers a listener for a custom event, and emits the event with data in Node.js.

// Importing events
const EventEmitter = require('events');
 
// Initializing event emitter instances 
let eventEmitter = new EventEmitter();

// Registering to myEvent 
eventEmitter.on('myEvent', (msg) => {
   console.log(msg);
});

// Triggering myEvent
eventEmitter.emit('myEvent', "First event");

Output:

First event

Syntax:

eventEmitter.emit(event, [arg1], [arg2], [...])

Removing Listener

Node.js provides methods to remove individual event listeners or all listeners associated with an event.

• removeListener(event, listener) removes a specific listener for an event.
• removeAllListeners(event) removes all listeners registered for the event.
• Helps manage memory and prevent unwanted event handling.

Example: Registers multiple listeners using EventEmitter, then removes a specific listener or all listeners to manage event handling in Node.js.

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

// Initializing event emitter instances 
let eventEmitter = new EventEmitter();
 
let geek1= (msg) => {
    console.log("Message from geek1: " + msg);
};
 
let geek2 = (msg) => {
    console.log("Message from geek2: " + msg);
};

// Registering geek1 and geek2
eventEmitter.on('myEvent', geek1);
eventEmitter.on('myEvent', geek1);
eventEmitter.on('myEvent', geek2);
 
// Removing listener geek1 that was
// registered on the line 13
eventEmitter.removeListener('myEvent', geek1);
 
// Triggering myEvent
eventEmitter.emit('myEvent', "Event occurred");

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

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

Output:

Message from geek1: Event occurred
Message from geek2: Event occurred

• geek1 is registered twice and geek2 once.
• removeListener('myEvent', geek1) removes one geek1 instance.
• removeAllListeners('myEvent') removes all listeners for myEvent.

Syntax:

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

Special Events

All EventEmitter instances emit specific built-in events when listeners are added, removed, or when errors occur.

Event: newListener

The newListener event is emitted before a new listener is added to an EventEmitter.

• Emitted before a new listener is added to the internal listeners array.
• Provides the event name and listener function being added.
• Useful for tracking or modifying listener behavior.

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

Event: removeListener

The removeListener event is emitted after an existing listener is removed from an EventEmitter.

• Emitted after a listener is removed from an event.
• Helps monitor listener cleanup and resource management.

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

Event: error

The error event is emitted when an error occurs within an EventEmitter instance.

• Emitted when an error occurs inside an EventEmitter.
• Error is thrown if no error listener is registered.
• Stack trace is printed to the console.
• Node.js process exits immediately.

eventEmitter.on('error', listener)

Example: Emitted on runtime errors within an EventEmitter.

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

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

// Register to error
eventEmitter.on('error', (err) => {
    console.error('Attention! 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 geek1 to myEvent1
let geek1  = (msg) => {
    console.log("Message from geek1: " + msg);
};

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

// Listening to myEvent with geek1 and geek2
eventEmitter.on('myEvent', geek1);
eventEmitter.on('myEvent', geek2);

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

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

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

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 geek2: Event occurred
Attention! There was an error