Hvad er almindelige designmønstre i Node.js?

Question

IT Interview Practice · Accepted Answer

Node.js læner sig op ad en håndfuld designmønstre, der passer til dets modulsystem, asynkrone model og streaming-I/O. De mest almindelige, som enhver backend-udvikler bør genkende:

## Skabende (Creational)

- **Module pattern** — hver fil har sit eget scope; du eksponerer et offentligt API via `module.exports` / `export` og holder det interne privat. Fundamentet for kodeorganisering i Node.
- **Singleton** — et moduls eksporter **caches**, så eksport af en instans giver enhver importør det samme objekt. Perfekt til en DB pool eller config.

```js
// db.js — hvert `require("./db")` får den samme pool (singleton via modul-cache).
const pool = createPool(process.env.DATABASE_URL);
module.exports = pool;
```

- **Factory** — en funktion, der opretter og returnerer objekter, skjuler konstruktionslogikken og lader dig udskifte implementeringer.

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

## Adfærd (Behavioral)

- **Observer / EventEmitter** — Nodes centrale asynkrone mønster: udsend navngivne events, tilknyt listeners. `EventEmitter`, streams og de fleste kernemoduler bruger det.

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

- **Middleware** — en pipeline af funktioner, der hver modtager `(ctx, next)`, populariseret af Express/Koa. Fremragende til tværgående hensyn (auth, logging, validering).

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

- **Strategy** — vælg en algoritme ved runtime (f.eks. vælg en betalingsudbyder eller en hashing-strategi bag ét interface).

## Strukturelle (Structural)

- **Adapter** — pak et tredjeparts-API ind i dit eget interface, så du kan udskifte leverandører uden at røre kaldstederne.
- **Streams (pipeline)** — sammensæt readable → transform → writable-trin for at behandle data trinvist med backpressure i stedet for at buffere alt i hukommelsen.

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

- **Dependency Injection** — send samarbejdspartnere (db, logger, klienter) ind i et modul i stedet for at importere dem direkte; gør koden testbar og løst koblet. Frameworks som **NestJS** har DI indbygget; du kan også gøre det manuelt via constructor-/funktionsargumenter.

## Tommelfingerregel

| Behov | Mønster |
|---|---|
| Én delt ressource | Singleton (modul-cache) |
| Byg objekter, skjul `new` | Factory |
| Reagér på asynkrone events | Observer / EventEmitter |
| Tværgående request-logik | Middleware |
| Behandl store data sikkert | Streams / pipeline |
| Testbare, løst koblede afhængigheder | Dependency Injection |

## Hvorfor det betyder noget

Mønstre er et fælles ordforråd: at sige "config'en er en modul-cachet singleton" eller "auth er middleware" formidler et design med få ord. Nodes egen kerne (EventEmitter, streams, modulsystemet) er bygget af disse, så at genkende dem hjælper dig med at læse frameworks og strukturere dine egne tjenester. Interviewere bruger dette spørgsmål til at tjekke, at du ikke bare kobler callbacks ad hoc, men griber efter det mønster, der passer — og kender dets afvejninger, som at en singleton gør global state sværere at teste.

Behov	Mønster
Én delt ressource	Singleton (modul-cache)
Byg objekter, skjul `new`	Factory
Reagér på asynkrone events	Observer / EventEmitter
Tværgående request-logik	Middleware
Behandl store data sikkert	Streams / pipeline
Testbare, løst koblede afhængigheder	Dependency Injection

Skabende (Creational)

Adfærd (Behavioral)

Strukturelle (Structural)

Tommelfingerregel

Hvorfor det betyder noget

Relaterede spørgsmål