Quels sont les design patterns courants en Node.js ?

Question

IT Interview Practice · Accepted Answer

Node.js s'appuie sur une poignée de design patterns qui conviennent à son système de modules, son modèle async et son I/O en streaming. Les plus courants que tout développeur backend devrait reconnaître :

## Créationnels (Creational)

- **Module pattern** — chaque fichier est son propre scope ; vous exposez une API publique via `module.exports` / `export`, en gardant les internes privés. Le fondement de l'organisation du code dans Node.
- **Singleton** — les exports d'un module sont **mis en cache**, donc exporter une instance donne à chaque importateur le même objet. Parfait pour un pool DB ou une config.

```js
// db.js — chaque require("./db") obtient ce même pool (singleton via le cache de modules).
const pool = createPool(process.env.DATABASE_URL);
module.exports = pool;
```

- **Factory** — une fonction qui crée et renvoie des objets, cachant la logique de construction et permettant d'interchanger les implémentations.

```js
function createLogger(kind) {
  return kind === "json" ? new JsonLogger() : new TextLogger();
}
```

## Comportementaux (Behavioral)

- **Observer / EventEmitter** — le pattern async central de Node : émettre des events nommés, attacher des listeners. `EventEmitter`, les streams et la plupart des modules core l'utilisent.

```js
const { EventEmitter } = require("node:events");
const bus = new EventEmitter();
bus.on("order:paid", (o) => sendReceipt(o));
bus.emit("order:paid", order);
```

- **Middleware** — un pipeline de fonctions recevant chacune `(ctx, next)`, popularisé par Express/Koa. Idéal pour les préoccupations transversales (auth, logging, validation).

```js
app.use((req, res, next) => { req.startedAt = Date.now(); next(); });
```

- **Strategy** — sélectionner un algorithme à l'exécution (par ex. choisir un fournisseur de paiement ou une stratégie de hachage derrière une seule interface).

## Structurels (Structural)

- **Adapter** — envelopper une API tierce dans votre propre interface pour pouvoir changer de fournisseur sans toucher aux sites d'appel.
- **Streams (pipeline)** — composer des étapes readable → transform → writable pour traiter les données de façon incrémentale avec backpressure, au lieu de tout bufferiser en mémoire.

```js
const { pipeline } = require("node:stream/promises");
await pipeline(fs.createReadStream("in"), gzip(), fs.createWriteStream("out.gz"));
```

- **Dependency Injection** — passer les collaborateurs (db, logger, clients) à un module au lieu de les importer directement ; rend le code testable et découplé. Des frameworks comme **NestJS** intègrent la DI ; vous pouvez aussi le faire à la main via les arguments de constructeur/fonction.

## Règle générale

| Besoin | Pattern |
|---|---|
| Une ressource partagée | Singleton (cache de modules) |
| Construire des objets, cacher `new` | Factory |
| Réagir à des events async | Observer / EventEmitter |
| Logique de requête transversale | Middleware |
| Traiter de grosses données en sécurité | Streams / pipeline |
| Dépendances testables et découplées | Dependency Injection |

## Pourquoi c'est important

Les patterns sont un vocabulaire partagé : dire « la config est un singleton mis en cache par module » ou « l'auth est un middleware » communique un design en quelques mots. Le core de Node lui-même (EventEmitter, streams, système de modules) est construit à partir de ceux-ci, donc les reconnaître aide à lire les frameworks et à structurer vos propres services. Les recruteurs utilisent cette question pour vérifier que vous ne câblez pas juste des callbacks au hasard, mais que vous choisissez le pattern qui convient — et que vous connaissez ses compromis, comme un singleton qui rend l'état global plus difficile à tester.

Besoin	Pattern
Une ressource partagée	Singleton (cache de modules)
Construire des objets, cacher `new`	Factory
Réagir à des events async	Observer / EventEmitter
Logique de requête transversale	Middleware
Traiter de grosses données en sécurité	Streams / pipeline
Dépendances testables et découplées	Dependency Injection

Créationnels (Creational)

Comportementaux (Behavioral)

Structurels (Structural)

Règle générale

Pourquoi c'est important

Questions connexes