11) Node Event Emitter

Introduction
The Event Emitter module in Node.js is a core part of its event-driven architecture. It allows objects to emit events and other parts of your code to listen and react to those events.
Node.js is asynchronous and non-blocking,
so instead of waiting for tasks: It emits events when something happens Listeners handle those events.
👉 Think of it like: Button click → event emitted Event listener → handles it
Importing and Creating an Emitter
EventEmitter is part of Node’s events module
Used to emit and listen to events
Key methods:
on() → listen
emit() → trigger
once() → one-time listener
Used heavily in streams, HTTP, and async flows
Important: always handle error events

const EventEmitter = require('events');

Create an instance

const emitter = new EventEmitter();

Example

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

// Listener
emitter.on('greet', () => {
  console.log('Hello Rahul');
});

// Emit event
emitter.emit('greet');

Passing Arguments

emitter.on('greet', (name) => {
  console.log(`Hello ${name}`);
});

emitter.emit('greet', 'Rahul');

Multiple Listeners

emitter.on('event', () => console.log('Listener 1'));
emitter.on('event', () => console.log('Listener 2'));

emitter.emit('event');

Important Methods
i) on(event, listener) - Register a listener

emitter.on('data', callback);

ii) emit(event, ...args) - Trigger event

emitter.emit('data', 'some data');

iii) once(event, listener) - Runs only once

emitter.once('login', () => {
  console.log('Logged in once');
});

iv) off() / removeListener() - Remove listener

emitter.off('event', callback);

v) removeAllListeners()

emitter.removeAllListeners('event');

Real world example

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

emitter.on('orderPlaced', (orderId) => {
  console.log(`Order ${orderId} received`);
});

emitter.on('orderPlaced', (orderId) => {
  console.log(`Processing order ${orderId}`);
});

emitter.emit('orderPlaced', 101);

Error Handling
If an error event is emitted and not handled → app crashes ❌

emitter.on('error', (err) => {
  console.error('Error occurred:', err.message);
});

emitter.emit('error', new Error('Something went wrong'));

Event Driven Architecture
Event-driven architecture in Node.js is the core design pattern that allows it to handle many operations efficiently without blocking execution. Instead of executing tasks sequentially, Node.js reacts to events (like requests, file reads, timers) and triggers callbacks/listeners when those events occur.
The system emits events, and listeners respond to those events.
Event occurs → Event emitted → Listener executes → Action performed

Why Node.js uses Event-Driven Architecture
Node.js is: Single-threaded Non-blocking Built for high concurrency
👉 Instead of creating multiple threads (like Java),
Node: Registers tasks Delegates heavy work (I/O) to the system Executes callbacks when ready