¿Qué es el EventEmitter y cómo se usa?

Question

Accepted Answer

**EventEmitter** es una clase central de Node que implementa el patrón **publicación/suscripción**: los objetos emiten eventos con nombre, y los listeners registrados para esos eventos se ejecutan cuando se disparan. Gran parte de la propia API de Node (streams, servidores HTTP, process) está construida sobre ella.

## Uso básico

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

const emitter = new EventEmitter();

// SUSCRIBIR: registrar un listener para un evento
emitter.on("order", (order) => {
  console.log(`Processing order ${order.id}`);
});

// PUBLICAR: emitir el evento (con datos opcionales)
emitter.emit("order", { id: 123 }); // → "Processing order 123"
```

El patrón: `on(event, listener)` suscribe; `emit(event, ...args)` dispara todos los listeners de ese evento de forma síncrona, pasando los argumentos.

## Extender EventEmitter para tus propias clases

```js
class OrderService extends EventEmitter {
  placeOrder(order) {
    // ...guardar la orden...
    this.emit("order:created", order);  // notificar a quien le interese
  }
}

const service = new OrderService();
service.on("order:created", (o) => sendEmail(o));   // listeners desacoplados
service.on("order:created", (o) => updateAnalytics(o));
service.placeOrder({ id: 1 }); // ambos listeners se ejecutan
```

Esto desacopla el emisor de sus listeners — `OrderService` no sabe ni le importa quién está escuchando, por lo que puedes agregar reacciones (correo, analytics, logging) sin modificarlo.

## Métodos útiles

```js
emitter.once("ready", fn);          // el listener se ejecuta solo UNA vez, luego se elimina solo
emitter.off("order", fn);           // eliminar un listener (prevenir fugas)
emitter.emit("error", new Error()); // "error" es especial — ¡lanza si no hay listener!
emitter.listenerCount("order");
```

## Dos trampas importantes

```text
⚠️ Fugas de memoria: olvidar eliminar listeners (usa off/once). Node advierte con >10
   listeners en un mismo evento ("possible EventEmitter memory leak").
⚠️ El evento "error": si se emite sin listener, Node LANZA y puede crashear —
   siempre adjunta un listener de error a los emisores que pueden fallar (¡streams!).
```

## Dónde se usa dentro del propio Node

```text
streams (eventos data, end, error), http.Server (evento request),
process (SIGTERM, exit), sockets — todos son EventEmitters.
```

## Por qué es importante

EventEmitter es el cimiento de la arquitectura orientada a eventos de Node — entenderlo explica cómo funcionan los streams, los servidores y el objeto process (todos son emisores), y es la herramienta estándar para la comunicación desacoplada basada en eventos en tu propio código.

Conocer la API `on`/`emit`/`once`/`off`, el riesgo de fugas de memoria por listeners no eliminados y el especial evento `error` que provoca crasheos es esencial tanto para usar correctamente las APIs de Node como para construir sistemas mantenibles orientados a eventos.