Ever wondered how Node.js handles real-time events?
Imagine you’re at a rock concert:
The band plays music (an event happens).
The crowd cheers and claps (listeners react).
That’s exactly how the events module in Node.js works! Instead of fans, your app has event listeners that respond when an event is emitted.
In this guide, we’ll cover:
-
What is the
eventsmodule? -
How does
EventEmitterwork? - Real-world examples (custom events, multiple listeners, error handling, and async events).
Ready? Let’s dive in!
What Is the events Module?
Node.js is event-driven. This means it can:
- Emit (trigger) events
- Listen (react) to those events
And the best part? The events module is built into Node.js, so there’s no need to install anything!
Just import it like this:
const EventEmitter = require('events');
Why use events?
- Makes async programming easier
- Prevents callback hell
- Perfect for real-time apps (chat apps, notifications, etc.)
Creating an EventEmitter
To use EventEmitter, you create an instance of it:
const EventEmitter = require('events');
const eventEmitter = new EventEmitter();
Now, you can start emitting and listening to events like a pro!
Emitting and Listening to Events
Let’s create an event and listen to it!
eventEmitter.on('greet', () => {
console.log('Hello, Node.js world!');
});
eventEmitter.emit('greet');
Output:
Hello, Node.js world!
How does it work?
on('greet', callback)→ Listens for the"greet"event.emit('greet')→ Triggers the event.
Passing Data with Events
What if you need to send data with an event?
eventEmitter.on('sayHello', (name) => {
console.log(`Hello, ${name}!`);
});
eventEmitter.emit('sayHello', 'Alice');
eventEmitter.emit('sayHello', 'Bob');
Output:
Hello, Alice!
Hello, Bob!
Why use this?
- Send dynamic data when an event is triggered.
- Great for chat apps, logging, and notifications!
Handling Multiple Listeners
An event can have multiple listeners:
eventEmitter.on('order', () => console.log(' Order placed!'));
eventEmitter.on('order', () => console.log(' Sending email confirmation...'));
eventEmitter.emit('order');
Output:
Order placed!
Sending email confirmation...
Use case:
When an order is placed, multiple actions happen simultaneously.
Using .once() for One-Time Events
Sometimes, you want a listener that runs only once (like a limited-time offer ).
Use .once() instead of .on():
eventEmitter.once('discount', () => {
console.log(' You got a 50% discount!');
});
eventEmitter.emit('discount'); // Runs
eventEmitter.emit('discount'); // Ignored
Output:
You got a 50% discount!
Removing Event Listeners
You can remove an event listener using .off() or .removeListener().
const sayBye = () => console.log('Goodbye! ');
eventEmitter.on('farewell', sayBye);
eventEmitter.emit('farewell'); // Runs
eventEmitter.off('farewell', sayBye);
eventEmitter.emit('farewell'); // Ignored
Output:
Goodbye!
Why remove listeners?
- Prevent memory leaks.
- Stop unnecessary event triggers.
Handling Errors with error Events
Node.js crashes if an "error" event isn’t handled!
eventEmitter.on('error', (err) => {
console.error(' Error:', err.message);
});
eventEmitter.emit('error', new Error('Database failed!'));
Output:
Error: Database failed!
Always handle errors!
Extending EventEmitter in a Class
For real-world apps, extend EventEmitter inside a class:
class Logger extends EventEmitter {
log(message) {
console.log(` ${message}`);
this.emit('logMessage', message);
}
}
const logger = new Logger();
logger.on('logMessage', (msg) => console.log(`Logged: ${msg}`));
logger.log('Event-driven logging in action!');
Output:
Event-driven logging in action!
Logged: Event-driven logging in action!
Making Events Asynchronous
By default, event listeners run synchronously. But you can make them async!
eventEmitter.on('asyncTask', async () => {
await new Promise(resolve => setTimeout(resolve, 2000));
console.log(' Async task completed!');
});
console.log('⏳ Starting async task...');
eventEmitter.emit('asyncTask');
console.log(' Moving on...');
Output:
Starting async task...
Moving on...
Async task completed! (after 2 seconds)
Conclusion
Now you're an EventEmitter pro!
- You can emit, listen, and handle events.
- You understand error handling, async events, and removing listeners.
- You know how to extend EventEmitter in a class for better organization.
Happy coding!
0 Comments