Nodejs Events And Eventemitter Complete Guide

Node.js Events and EventEmitter

What are Events?

In Node.js, events are communication channels between different components of your application. They allow you to react programmatically to certain occurrences, such as user input, file system operations, or network data reception. Unlike traditional callback-based programming, where a function is provided upfront to be called when an operation completes, the event-driven approach allows for more dynamic and scalable code structures.

Examples of Node.js Built-in Events:

• http.Server emits request when a new HTTP incoming request is received.
• fs.WriteStream emits finish when all data has been flushed to the underlying system.
• process emits exit before the Node.js process terminates.

EventEmitter Class

The EventEmitter class is at the heart of the event-driven system in Node.js. It provides methods to listen for and handle events. Here’s how to use EventEmitter:

1. Creating an EventEmitter Instance:

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

2. Adding Event Listeners:

   • Use .on(eventName, listener): Registers a listener for the specified event.

     myEmitter.on('greet', function(name) {
       console.log(`Hello, ${name}!`);
     });
     

   • Use .once(eventName, listener): Registers a listener for the specified event only once.

     myEmitter.once('greet-once', function(name) {
       console.log(`Hello only once, ${name}!`);
     });
     

3. Emitting Events:

   • Utilize .emit(eventName, [arg1], [arg2], [...]): Triggers all listeners associated with the specified event.

     myEmitter.emit('greet', 'Alice'); // Hello, Alice!
     myEmitter.emit('greet-once', 'Bob'); // Hello only once, Bob!
     myEmitter.emit('greet-once', 'Bob'); // Nothing printed
     

4. Removing Event Listeners:

   • Use .removeListener(eventName, listener): Removes a specific listener from the list of listeners for the event.

     myEmitter.removeListener('greet', function(name) {
       console.log(`Hello, ${name}!`);
     });
     

   • Alternatively, use .off(eventName, listener) starting from Node.js v10.x (same as removeListener).

5. Handling Errors:

   • By default, if an EventEmitter instance emits an error event and no listeners are added to handle it, the error will be thrown, leading to the Node.js process crashing. Handle it using:

     myEmitter.on('error', function(err) {
       console.error('Error occurred:', err);
     });
     

6. Counting Listeners:

   • Use .listenerCount(eventName): Returns the number of listeners subscribed to a given event.

     console.log(myEmitter.listenerCount('greet')); // 1
     

7. Getting All Event Names:

   • Use .eventNames(): Retrieves an array of all event names for which the emitter has registered listeners.

     console.log(myEmitter.eventNames()); // ['greet', 'greet-once']
     

8. Managing Listener Limits:

   • You can adjust the maximum number of listeners by default (set to 10) using .setMaxListeners(n), where n is the maximum number of listeners.

     myEmitter.setMaxListeners(5);
     

• Get the current limit using .getMaxListeners().

9. Synchronous vs Asynchronous Behavior:

   • When an event is emitted, event listeners are called synchronously in the order they are added. However, you can make them asynchronous by using process.nextTick(), setImmediate(), or Promises within them.

   myEmitter.on('data', function(data) {
     process.nextTick(() => {
       console.log(`Data received asynchronously: ${data}`);
     });
   });
   myEmitter.emit('data', 'Example data');
   

10. Using EventEmitter with Custom Classes:

    • You can also create custom classes that extend EventEmitter to incorporate event handling functionality.

      class MyCustomClass extends EventEmitter {};
      const customInstance = new MyCustomClass();
      
      customInstance.on('custom-event', function(payload) {
        console.log('Custom event received:', payload);
      });
      
      setTimeout(() => {
        customInstance.emit('custom-event', { message: 'Sample payload'});
      }, 1000);
      

Important Points

• Scalability: The event-driven nature of Node.js and the EventEmitter make it possible to handle numerous tasks concurrently without blocking.

• Performance: Efficiently handles asynchronous operations, reducing the need for multiple threads, which keeps the memory footprint low and enhances performance.

• Extensibility: Allows any object to become an event emitter, making it versatile for various use cases including but not limited to streams, sockets, and custom modules.

• Debugging: Events can sometimes complicate debugging due to the distributed and asynchronous flow. Tools like Node’s --trace-events-enabled flag can help track events in real-time.

• Best Practices:

  • Always handle errors with appropriate listeners to prevent process crashes.
  • Be cautious about memory leaks caused by too many listeners for a single event.
  • Avoid adding large numbers of listeners to a single event by using patterns which consolidate or remove listeners efficiently.

• Advanced Usage:

  • Node.js has a robust event system that supports wildcard events and error propagation via domains in older versions (domains were deprecated as of v7.x and removed in v14.x).

Conclusion