Introduction to the NodeJS EventEmitter

If you have experience with JavaScript in browser, you're likely familiar with how user interactions, such as mouse clicks, keyboard inputs, and responding to mouse movements, are managed through events.

Similarly, Node.js provides the capability to create event-driven systems on the backend using its `events` module.

This module includes the `EventEmitter` class, which allows us to effectively manage and respond to events or state changes asynchronously in our applications.

Here's an overview of key concepts:

• ➢Basic Concepts: In event-driven programming, events are signals that something has happened. Event emitters are objects that `emit` events, and `listeners` are functions that subscribe to these events and respond to them. Event loops are central to managing and dispatching events in Node.js applications.
• ➢Event-Driven Architecture: This architecture promotes loose coupling, scalability, and responsiveness in applications. EventEmitter plays a crucial role in facilitating communication between different parts of an application through events.

Let's have a simple illustration:

// Import EventEmitter module
const EventEmitter = require('events');

// Create an instance of EventEmitter
const emitter = new EventEmitter();

// Register a listener for the 'greet' event
emitter.on('greet', () => {
  console.log('Hello, world!');
});

// Emitting a 'greet' event
emitter.emit('greet'); // Output: Hello, world!

Breakdown: we create an EventEmitter instance `emitter`, define an event listener for the `greet` event using the `on` method, and emit the 'greet' event using the `emit` method.

When the event is emitted, the listener function is executed, printing 'Hello, world!' to the console.

Working with the EventEmitter Class

The EventEmitter provides methods to work with events, such as adding event listeners, emitting events, and handling errors. In this guide, we wouldn't get into the intricacies or cover all the public methods of the EventEmitter. If you're interested, you can read more on events.

Let's explore these functionalities in detail:

• ➢Adding Event Listeners: The `on` or `addListener` method is used to add event listeners to EventEmitter instances. Event listeners are functions that execute when a specific event is emitted.
• ➢Emitting Events: The `emit` method is used to emit events. When an event is emitted, all registered listeners for that event are invoked asynchronously.
• ➢Removing Event Listeners: The `off` or `removeListener` method can be used to remove event listeners from EventEmitter instances. This helps in avoiding memory leaks and unnecessary execution of listener functions.
  

Let's have an example that uses some popular methods:

// Importe EventEmitter module
const EventEmitter = require('events');

// Create an instance of EventEmitter
const emitter = new EventEmitter();

// Define event listeners
const listener1 = (msg) => console.log('Message received by listener1:', msg);
const listener2 = (msg) => console.log('Message received by listener2:', msg);


// register listeners
emitter.on('message', listener1);
//emitter.addListener('message', listener1);
emitter.on('message', listener2);
//emitter.addListener('message', listener2);

// Get the listener count for the 'message' event
console.log('Number of listeners for the message event: ', emitter.listenerCount('message'));

// Emitting events
emitter.emit('message', 'Hello, world!');

console.log('************ After removing listener1 **********************')
// Removing a listener (use either)
emitter.off('message', listener1);
//emitter.removeListener('message', listener1);

// Try emitting the 'message' event one more time
emitter.emit('message', 'Another Hello, world!');

// Get the listener count for the 'message' event
console.log('Upadted number of listeners for the message event: ', emitter.listenerCount('message'));

Breakdown: This example illustrates just how powerful and dynamic the nodejs events are.

- Run the code and see what you get in the console. The result are quite straight-forward and code is self-explanatory.

- Then for the event listener registering part, comment the active lines and uncomment the comment ones. Do the same for the listener removal part, then run the code again. As expected, you should get the exactly the same results.

- Also notice how emitter.once registers `listener3` but then removes it immediately after it responds to the first emit call.

Real-World Examples

Let's explore some real-world scenarios where the Node.js EventEmitter shines.

1. Simple Chat Application

In a chat application, the EventEmitter can be used to handle incoming messages, user connections, and disconnections.
Each user connection can be represented as an EventEmitter instance, allowing the server to emit events for messages received from clients and broadcast them to other connected users.

const EventEmitter = require('events');

class ChatRoom extends EventEmitter {
  constructor() {
    super();
    this.users = new Map();
  }

  addUser(user) {
    this.users.set(user.id, user);
    user.on('message', (message) => {
      // Broadcast message to other users
      this.emit('message', { userId: user.id, message });
    });
    user.on('disconnect', () => {
      // Handle user disconnection
      this.users.delete(user.id);
      this.emit('userDisconnected', user.id);
    });
    this.emit('userConnected', user.id);
  }
}

2. Event-Driven Microservices

In a microservices architecture, EventEmitter can facilitate communication between different `services`. Each microservice can emit events for various actions, such as user registration, order processing, or data synchronization. Other services can listen for these events and react accordingly.

// Service A
const EventEmitter = require('events');
const emitter = new EventEmitter();

// Service B
emitter.on('userRegistered', (user) => {
  console.log(`New user registered: ${user}`);
});

// Service C
emitter.emit('userRegistered', { id: 123, name: 'John Doe' });

3. Web Server

In a web server application, EventEmitter can be used to handle HTTP requests and responses. The HTTP server instance in Node.js is an EventEmitter, allowing us developers to listen for incoming requests and respond accordingly.

const http = require('http');

const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('Hello World\n');
});

server.listen(3000, () => {
  console.log('Server running on port 3000');
});

You're probably hoping for a runnable example, not like those provided above.
Gotcha! Let's have a more or less complete and runnable example.

const EventEmitter = require('events');

// ChatRoom class
class ChatRoom extends EventEmitter {
  constructor() {
    super();
    this.users = new Map();
  }

  addUser(user) {
    this.users.set(user.id, user);
    user.on('message', (message) => {
      // Broadcast message to other users
      this.emit('message', { userId: user.id, message });
    });
    user.on('disconnect', () => {
      // Handle user disconnection
      this.users.delete(user.id);
      this.emit('userDisconnected', user.id);
    });
    this.emit('userConnected', user.id);
  }

  sendMessage(userId, message) {
    const user = this.users.get(userId);
    if (user) {
      user.emit('message', message);
    }
  }
}

// Setup User class
class User extends EventEmitter {
  constructor(id) {
    super();
    this.id = id;
  }
}

// Create a chatroom 
const chatRoom = new ChatRoom();

// Create 2 users and add them to the chatroom
const user1 = new User(1);
const user2 = new User(2);
chatRoom.addUser(user1);
chatRoom.addUser(user2);

// Register a 'message' event listener in the chatroom
chatRoom.on('message', ({ userId, message }) => {
  console.log(`User ${userId} says: ${message}`);
});

// Simulate sending messages by various users
setTimeout(() => {
  chatRoom.sendMessage(1, 'Greetings from User 1!');
}, 1000);

setTimeout(() => {
  chatRoom.sendMessage(2, 'Hola from User 2!');
}, 2000);

Breakdown:

- we have a `ChatRoom` class that extends `EventEmitter`, representing a chatroom where users can send and receive messages.

- Each `User` instance also extends `EventEmitter` and represents a user in the chatroom. We create two users (user1 and user2) and add them to the chatroom.

- Then, we simulate sending messages from each user, which are emitted as events and broadcasted to other users in the chatroom.

The example above is a contrived and servers just as an illustrative use case.

Conclusion

The Node.js EventEmitter is a powerful tool for building event-driven applications in nodeJS. By understanding its core concepts, API methods, and best practices, developers can create robust and scalable applications that leverage the event-driven architecture effectively.

In the next part, we'll dive into an important and sensitive topic in nodejs, Blocking the Event loop.