Today marked Day 6 of my Node.js learning adventure, and I delved into the fascinating world of the EventEmitter
class. Here’s how I navigated through it and what I learned along the way.
Theory Recap
The EventEmitter
class is a cornerstone in Node.js for managing events. It provides a robust way to create, emit, and handle events, making it essential for building applications that rely on event-driven architecture.
Key Methods of EventEmitter
:
-
on(eventName, listener)
: Registers a listener for a specific event. -
emit(eventName, [...args])
: Emits an event, passing optional arguments to listeners. -
removeListener(eventName, listener)
: Removes a specific listener for an event. -
once(eventName, listener)
: Adds a listener that will be triggered only once.
Practical Task
Task: Create custom events and handlers.
I started by creating a class that extends EventEmitter
and added custom event handlers. Here’s a step-by-step account of what I did:
- Defined the Custom Class:
I created a class called DataProcessor
that extends EventEmitter
. This class had a method processData
to simulate data processing.
const EventEmitter = require('events');
class DataProcessor extends EventEmitter {
processData(data) {
this.emit('start');
// Simulate data processing
setTimeout(() => {
this.emit('data', data);
this.emit('end');
}, 1000);
}
}
- Set Up Event Handlers:
I then initialized the DataProcessor
class and defined handlers for three events: 'start'
, 'data'
, and 'end'
.
// Initialization
const processor = new DataProcessor();
// Event handlers
processor.on('start', () => console.log('Processing started...'));
processor.on('data', (data) => console.log(`Processing data: ${data}`));
processor.on('end', () => console.log('Processing completed.'));
- Emitted Events:
Finally, I called the processData
method to see the events in action.
processor.processData('Some data');
Watching the sequence of events unfold was enlightening. The console output showed the flow from starting the process to handling data and completing it.
Independent Task
Task: Develop a notification system using events.
For the independent task, I designed a Notifier
class. Here’s how I approached it:
- Created the Notifier Class:
const EventEmitter = require('events');
class Notifier extends EventEmitter {
constructor() {
super();
this.notifications = [];
}
addNotification(notification) {
if (typeof notification !== 'string') {
this.emit('error', 'Notification must be a string');
return;
}
this.notifications.push(notification);
this.emit('notify', notification);
if (this.notifications.length > 0) {
this.emit('complete');
}
}
}
- Defined Event Handlers:
I set up handlers for 'notify'
, 'error'
, and 'complete'
.
const notifier = new Notifier();
notifier.on('notify', (message) => console.log(`New notification: ${message}`));
notifier.on('error', (err) => console.error(`Error: ${err}`));
notifier.on('complete', () => console.log('All notifications processed.'));
- Tested the System:
I tested the system by adding notifications and handling potential errors.
notifier.addNotification('This is your first notification.');
notifier.addNotification('This is your second notification.');
notifier.addNotification(123); // This should trigger an error
It was satisfying to see how the notifications were handled, errors were reported, and the completion event was triggered.
Conclusion
Today’s exploration of EventEmitter
has significantly deepened my understanding of event-driven programming in Node.js. Implementing custom events and handlers was a great way to see how events flow and how they can be managed effectively. The independent task further reinforced these concepts and gave me hands-on experience with building a notification system.
I’m excited to continue this journey and see what the next days have in store!
Resources
All lessons created by ChatGPT can be found at: https://king-tri-ton.github.io/learn-nodejs
Top comments (0)