What is the EventEmitter and how is it used?

Question

IT Interview Practice · Accepted Answer

**EventEmitter** is a core Node class implementing the **publish/subscribe** pattern: objects emit named events, and listeners registered for those events run when they fire. Much of Node's own API (streams, HTTP servers, process) is built on it.

## Basic usage

```js
import { EventEmitter } from "events";

const emitter = new EventEmitter();

// SUBSCRIBE: register a listener for an event
emitter.on("order", (order) => {
  console.log(`Processing order ${order.id}`);
});

// PUBLISH: emit the event (with optional data)
emitter.emit("order", { id: 123 }); // → "Processing order 123"
```

The pattern: `on(event, listener)` subscribes; `emit(event, ...args)` triggers all listeners for that event synchronously, passing the arguments.

## Extending EventEmitter for your own classes

```js
class OrderService extends EventEmitter {
  placeOrder(order) {
    // ...save the order...
    this.emit("order:created", order);  // notify anyone interested
  }
}

const service = new OrderService();
service.on("order:created", (o) => sendEmail(o));   // decoupled listeners
service.on("order:created", (o) => updateAnalytics(o));
service.placeOrder({ id: 1 }); // both listeners run
```

This decouples the emitter from its listeners — `OrderService` doesn't know or care who's listening, so you can add reactions (email, analytics, logging) without modifying it.

## Useful methods

```js
emitter.once("ready", fn);          // listener runs only ONCE, then auto-removes
emitter.off("order", fn);           // remove a listener (prevent leaks)
emitter.emit("error", new Error()); // "error" is special — throws if no listener!
emitter.listenerCount("order");
```

## Two important gotchas

```text
⚠️ Memory leaks: forgetting to remove listeners (use off/once). Node warns at >10
   listeners on one event ("possible EventEmitter memory leak").
⚠️ The "error" event: if emitted with no listener, Node THROWS and may crash —
   always attach an error listener to emitters that can error (streams!).
```

## Where it's used in Node itself

```text
streams (data, end, error events), http.Server (request event),
process (SIGTERM, exit), sockets — all are EventEmitters.
```

## Why it matters

EventEmitter is the foundation of Node's event-driven architecture — understanding it explains how streams, servers, and the process object work (they're all emitters), and it's the standard tool for decoupled, event-based communication in your own code.

Knowing the `on`/`emit`/`once`/`off` API, the memory-leak risk from un-removed listeners, and the special crash-causing `error` event is essential for both using Node's APIs correctly and building maintainable event-driven systems.

Basic usage

Extending EventEmitter for your own classes

Useful methods

Two important gotchas

Where it's used in Node itself

Why it matters

Related questions