Previous
Written by: rJTutorial Team | Last Updated:

Node.js Event Emitter

The EventEmitter class is the backbone of Node.js's asynchronous, event-driven architecture. Many of Node's core modules like HTTP for servers or FS for file streams are built on top of it. It provides a way for one part of your application to "signal" that something has happened, and for other parts to "react" to that signal without being tightly coupled together.

Developer Tip: Think of EventEmitter as a "Pub/Sub" (Publisher/Subscriber) system. One part of your code publishes a message, and any other part can subscribe to it to take action.

 

Key Features of EventEmitter

  1. Custom Events: Unlike browser events (like 'click' or 'submit'), you can name your EventEmitter events anything you want, such as user-logged-in or data-processed.
  2. Event Listeners: These are callback functions that stay "on guard." When the specific event name is triggered, the listener executes its logic immediately.
  3. Synchronous Execution: By default, EventEmitter calls all listeners synchronously in the order they were registered. This ensures proper sequencing of logic.
Best Practice: While listeners are called synchronously, you can use setImmediate() or process.nextTick() inside your listener if you need the actual logic to execute asynchronously to avoid blocking the event loop.

 

Using EventEmitter

To use the EventEmitter, you need to import it from the built-in events module. You don't need to install anything via NPM; it's part of the Node.js core.

1. Importing EventEmitter and Creating an Event

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

// 1. Define an event and its listener
myEmitter.on('order-placed', () => {
  console.log('Notification: A new order has been placed!');
});

// 2. Emit the event
myEmitter.emit('order-placed');

Output:

Notification: A new order has been placed!
  • The on() method is used to register a listener. It takes the event name (string) and a callback function.
  • The emit() method triggers the event. You can call this from anywhere in your logic when a specific milestone is reached.

2. Multiple Listeners for the Same Event

One of the biggest strengths of this pattern is that multiple independent parts of your app can listen for the same event without interfering with each other.

myEmitter.on('user-signup', () => {
  console.log('Sending welcome email...');
});

myEmitter.on('user-signup', () => {
  console.log('Adding user to the database analytics...');
});

myEmitter.emit('user-signup');

Output:

Sending welcome email...
Adding user to the database analytics...
  • Both listeners execute in the order they were defined. This is great for keeping your code modular your "Email Logic" and "Analytics Logic" can live in separate files.
Watch Out: By default, Node.js allows up to 10 listeners for a single event. If you add more, you’ll see a memory leak warning in the console. You can increase this using emitter.setMaxListeners(n).

3. Listening Once with once()

Sometimes you only care about an event the very first time it happens. For example, you might want to run a setup script the first time a database connects, but ignore subsequent connection pulses.

myEmitter.once('db-connect', () => {
  console.log('Connection established! Initializing schema...');
});

myEmitter.emit('db-connect');
myEmitter.emit('db-connect'); // This will be ignored

Output:

Connection established! Initializing schema...
  • The once() method automatically unregisters the listener after it is fired for the first time, saving memory and preventing redundant logic.

4. Handling Arguments in Events

Events rarely happen in a vacuum; you usually need to pass data along. You can pass any number of arguments to the emit() method, and they will be passed to the listener.

myEmitter.on('payment-received', (amount, currency) => {
  console.log(`Success! We received ${amount} ${currency}.`);
});

myEmitter.emit('payment-received', 49.99, 'USD');

Output:

Success! We received 49.99 USD.
Developer Tip: If you have more than two arguments, it's often cleaner to pass a single object: myEmitter.emit('event', { id: 1, status: 'ok' }).

5. Removing Event Listeners

To keep your application performant, you should remove listeners when they are no longer needed, especially in long-running applications.

const onDataReceived = () => {
  console.log('Processing incoming data stream...');
};

myEmitter.on('data', onDataReceived);
myEmitter.emit('data');

// Remove the specific listener
myEmitter.removeListener('data', onDataReceived);

myEmitter.emit('data'); // This will not trigger anything

Output:

Processing incoming data stream...
Common Mistake: You cannot remove a listener if you used an anonymous function (e.g., myEmitter.on('event', () => { ... })). You must have a reference to the function name to remove it later.

 

Summary

The EventEmitter class is a powerful tool for creating decoupled, scalable systems in Node.js. By mastering on, once, and emit, you can build applications where different modules communicate seamlessly through events rather than direct function calls. This makes your code easier to test, maintain, and expand as your project grows. Remember to always clean up your listeners to prevent memory leaks in production environments!

Previous