Wat zijn veelvoorkomende design patterns in Node.js?

Question

IT Interview Practice · Accepted Answer

Node.js leunt op een handjevol design patterns die passen bij zijn modulesysteem, async-model en streaming I/O. De meest voorkomende die elke backend-ontwikkelaar zou moeten herkennen:

## Creatie (Creational)

- **Module-pattern** — elk bestand heeft zijn eigen scope; je stelt een publieke API bloot via `module.exports` / `export`, terwijl je de interne delen privé houdt. De basis van code-organisatie in Node.
- **Singleton** — de exports van een module worden **gecached**, dus het exporteren van een instance geeft elke importeur hetzelfde object. Perfect voor een DB-pool of config.

```js
// db.js — elke `require("./db")` krijgt deze zelfde pool (singleton via module cache).
const pool = createPool(process.env.DATABASE_URL);
module.exports = pool;
```

- **Factory** — een functie die objecten creëert en teruggeeft, de constructielogica verbergt en je implementaties laat verwisselen.

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

## Gedrag (Behavioral)

- **Observer / EventEmitter** — het kern-async-pattern van Node: zend benoemde events uit, koppel listeners. `EventEmitter`, streams en de meeste core-modules gebruiken het.

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

- **Middleware** — een pipeline van functies die elk `(ctx, next)` ontvangen, populair gemaakt door Express/Koa. Ideaal voor cross-cutting concerns (auth, logging, validation).

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

- **Strategy** — kies een algoritme tijdens runtime (bijv. een betalingsprovider of een hashing-strategie achter één interface).

## Structuur (Structural)

- **Adapter** — verpak een externe API in je eigen interface zodat je van leverancier kunt wisselen zonder de call sites aan te raken.
- **Streams (pipeline)** — stel readable → transform → writable-fasen samen om data incrementeel te verwerken met backpressure, in plaats van alles in het geheugen te bufferen.

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

- **Dependency Injection** — geef samenwerkers (db, logger, clients) door aan een module in plaats van ze rechtstreeks te importeren; maakt code testbaar en ontkoppeld. Frameworks zoals **NestJS** hebben DI ingebouwd; je kunt het ook handmatig doen via constructor-/functieargumenten.

## Vuistregel

| Behoefte | Pattern |
|---|---|
| Eén gedeelde resource | Singleton (module cache) |
| Objecten bouwen, `new` verbergen | Factory |
| Reageren op async events | Observer / EventEmitter |
| Cross-cutting request-logica | Middleware |
| Grote data veilig verwerken | Streams / pipeline |
| Testbare, ontkoppelde dependencies | Dependency Injection |

## Waarom het belangrijk is

Patterns zijn een gedeelde woordenschat: zeggen "de config is een module-gecachte singleton" of "auth is middleware" communiceert een ontwerp in een paar woorden. De core van Node zelf (EventEmitter, streams, het modulesysteem) is uit deze patterns opgebouwd, dus ze herkennen helpt je frameworks te lezen en je eigen services te structureren. Interviewers gebruiken deze vraag om te controleren of je niet zomaar ad hoc callbacks aan elkaar knoopt, maar naar het passende pattern grijpt — en de trade-offs ervan kent, zoals een singleton die globale state moeilijker te testen maakt.

Behoefte	Pattern
Eén gedeelde resource	Singleton (module cache)
Objecten bouwen, `new` verbergen	Factory
Reageren op async events	Observer / EventEmitter
Cross-cutting request-logica	Middleware
Grote data veilig verwerken	Streams / pipeline
Testbare, ontkoppelde dependencies	Dependency Injection

Creatie (Creational)

Gedrag (Behavioral)

Structuur (Structural)

Vuistregel

Waarom het belangrijk is

Gerelateerde vragen