Node.js Events

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:

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:

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)

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

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.