Event-Driven Architecture of NodeJS

NodeJS uses an event-driven architecture, which is a key part of how it handles many tasks at once without blocking. This approach relies on events, event emitters, and listeners to manage asynchronous operations efficiently.

It is a design pattern where applications respond to events—changes in state, user input, or messages from other programs. Instead of a program's logic being tied to a specific sequence of steps, it reacts to events as they occur.This makes applications more flexible and responsive.

Event-Driven Architecture Working

NodeJS is inherently event-driven. The main focus is on a single-threaded event loop, which efficiently manages asynchronous operations. Here's how it works

• Events: Things that happen in your application, like a user clicking a button, a file being read, or a network request completing, are represented as "events."
• Event Loop: NodeJS has a central "event loop" that constantly monitors these events. It's like a traffic controller for your application.
• Callbacks: When an event occurs, NodeJS executes a corresponding "callback" function.This function contains the code that should run in response to that specific event.
• Non-Blocking: The event loop is non-blocking. This means that while waiting for an event (like a file to finish reading), NodeJS can handle other tasks.This is what makes NodeJS so efficient at handling many things at once.
• Asynchronous Operations: Many operations in NodeJS are asynchronous. For example, reading a file doesn't stop the rest of your program. Instead, NodeJS registers a callback function to be executed when the file is read.

Important Components

Here are the key components of NodeJS event-driven architecture:

1. EventEmitter Module

The EventEmitter module is a core part of NodeJS that provides a way to create and manage custom events. It's how you build things that can send and receive event signals.

• Events are like signals that something has happened in your application.
• Event emitters are objects that can trigger (emit) these signals.

const EventEmitter = require("events");

class MyEmitter extends EventEmitter {
}

const myEmitter = new MyEmitter();

myEmitter.on("dataReceived",
             (data) => { // More descriptive event name
                 console.log("Data received:", data);
             });

myEmitter.emit("dataReceived", {
    message : "Hello from event emitter!"
}); // Pass data with the event
myEmitter.emit("dataReceived", {
    message : "Another message!"
}); // Emit event again with different data

• EventEmitter is used to create objects that can emit and listen for events.
• .on() registers a listener for a specific event.
• .emit() triggers an event, which then calls any associated listeners.

Event Registration

Event Registration means attaching a listener(callback) to an event so it executes when that event occurs.

Syntax:

const EventEmitter = require('events');
const emitter = new EventEmitter();
emitter.on('eventName', (data) => {
  console.log('Event received:', data);
});

Event Emission

It is the act of firing or triggering an event so that all registered events execute.

Syntax:

emitter.emit('eventName', 'Hello World');

Custom Events

It allows developers to define their own events so that all registered listeners execute.

Syntax:

emitter.on('userLoggedIn', (username) => {
  console.log(`${username} has logged in.`);
});
emitter.emit('userLoggedIn', 'Mahima');

2. Events

Events are the signals that are emitted by event emitters. They represent something that has happened in your application, like data being received, a file being opened, or an error occurring.

• Event Types: There are different kind of event that can be handled in Node.js - such as built-in events (data, end error on streams)or developer defined customer events
• Event Naming: Event in Node.js are identified by string names.These names should be descriptive (e.g., userLoggedIn, fileUploaded) to make code Readable.
• Event Payload: Event Payload is the data passed along with the event when it is emitted. Listeners recieved this payload as function arguments.

3. Listeners

Listeners are functions that are executed when a specific event is emitted. They are registered with an event emitter using the .on() method.

• Listeners are functions that react to specific events.
• They define the logic to be executed when an event occurs.

This is the sample text file 

const fs = require('fs');

fs.readFile('example.txt', 'utf8', (err, data) => { // Listen for the 'file read' event (implicit)
    if (err) throw err;
    console.log(data); // When the file is read, print the content
});

console.log('Reading file...'); // This will likely print *before* the file contents

• fs.readFile is a non-blocking operation. It starts reading the file and then immediately moves on to the next line of code.
• The callback function we provide is a listener. It will be executed only when the file reading is complete (an implicit 'file read' event).

Output

• Event Binding: means attaching a listener function to an event using methods like .on() and .once() . This tells
• Execution of Listeners:
• Listener Parameter:

Event-Driven Programming

It is a way of writing code where you focus on creating events and deciding how your program should react to them. It's like setting up a system of notifications and responses.

• Developers define custom events using the EventEmitter class.
• Events are triggered using emit().
• Event listeners, set up with on(), define how the program responds to each event.
• This asynchronous approach keeps the application running smoothly without waiting for each task to fully complete before starting the next.

Benefits of Event-Driven Architecture

It offers several advantages for building applications, making them efficient and maintainable.

• Scalability: Handles many simultaneous tasks without performance degradation. It's like a traffic controller managing many cars smoothly.
• Asynchronous Processing & Non-Blocking I/O: Taks that take time don't block other operations. The application remains responsive and can handle other requests while waiting.
• Modularity: Code is organized into smaller, independent modules, making it easier to develop, test, and maintain. It's like building with Lego blocks.
• Responsiveness: Enables real-time interactions and quick responses to user actions, leading to a better user experience