Qu'est-ce que EventEmitter et comment l'utiliser?

Question

Accepted Answer

**EventEmitter** est une classe centrale de Node implémentant le motif **publication/souscription** : les objets émettent des événements nommés, et les auditeurs enregistrés pour ces événements s'exécutent quand ils se déclenchent. La plupart de l'API propre de Node (streams, serveurs HTTP, process) est construite dessus.

## Utilisation basique

```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"
```

Le motif : `on(event, listener)` s'abonne ; `emit(event, ...args)` déclenche synchroniquement tous les auditeurs pour cet événement, en passant les arguments.

## Étendre EventEmitter pour vos propres 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
```

Ceci découple l'émetteur de ses auditeurs — `OrderService` ne sait pas ou ne se soucie pas de qui écoute, donc vous pouvez ajouter des réactions (e-mail, analytique, journalisation) sans le modifier.

## Méthodes utiles

```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");
```

## Deux pièges importants

```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!).
```

## Où c'est utilisé dans Node lui-même

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

## Pourquoi c'est important

EventEmitter est le fondement de l'architecture orientée événements de Node — la comprendre explique comment fonctionnent les streams, les serveurs et l'objet process (ce sont tous des émetteurs), et c'est l'outil standard pour la communication découplée basée sur les événements dans votre propre code.

Connaitre l'API `on`/`emit`/`once`/`off`, le risque de fuite mémoire des auditeurs non supprimés, et l'événement spécial `error` causant des plantages, est essentiel à la fois pour utiliser correctement les API de Node et pour construire des systèmes orientés événements maintenables.