Hva er vanlige design patterns i Node.js?

Question

IT Interview Practice · Accepted Answer

Node.js lener seg på en håndfull design patterns som passer til modulsystemet, async-modellen og streaming-I/O. De vanligste som enhver backend-utvikler bør kjenne igjen:

## Opprettelse (Creational)

- **Module-pattern** — hver fil har sitt eget scope; du eksponerer et offentlig API via `module.exports` / `export`, mens du holder det interne privat. Grunnlaget for kodeorganisering i Node.
- **Singleton** — en moduls exports blir **cachet**, så å eksportere en instance gir hver importør det samme objektet. Perfekt for en DB-pool eller config.

```js
// db.js — hver `require("./db")` får denne samme poolen (singleton via module cache).
const pool = createPool(process.env.DATABASE_URL);
module.exports = pool;
```

- **Factory** — en funksjon som oppretter og returnerer objekter, skjuler konstruksjonslogikken og lar deg bytte implementasjoner.

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

## Atferd (Behavioral)

- **Observer / EventEmitter** — Nodes sentrale async-pattern: send navngitte events, koble på listeners. `EventEmitter`, streams og de fleste core-moduler bruker 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 av funksjoner som hver mottar `(ctx, next)`, gjort populær av Express/Koa. Utmerket for tverrgående hensyn (auth, logging, validation).

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

- **Strategy** — velg en algoritme ved runtime (f.eks. velg en betalingsleverandør eller en hashing-strategi bak ett interface).

## Struktur (Structural)

- **Adapter** — pakk et tredjeparts-API inn i ditt eget interface slik at du kan bytte leverandør uten å røre call sites.
- **Streams (pipeline)** — sett sammen readable → transform → writable-trinn for å behandle data trinnvis med backpressure, i stedet for å bufre alt i minnet.

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

- **Dependency Injection** — send inn samarbeidspartnere (db, logger, klienter) til en modul i stedet for å importere dem direkte; gjør koden testbar og frakoblet. Frameworks som **NestJS** har DI innebygd; du kan også gjøre det for hånd via constructor-/funksjonsargumenter.

## Tommelfingerregel

| Behov | Pattern |
|---|---|
| Én delt ressurs | Singleton (module cache) |
| Bygg objekter, skjul `new` | Factory |
| Reager på async events | Observer / EventEmitter |
| Tverrgående request-logikk | Middleware |
| Behandle store data trygt | Streams / pipeline |
| Testbare, frakoblede dependencies | Dependency Injection |

## Hvorfor det er viktig

Patterns er et felles vokabular: å si "config-en er en module-cachet singleton" eller "auth er middleware" formidler et design med noen få ord. Nodes egen kjerne (EventEmitter, streams, modulsystemet) er bygget av disse, så å gjenkjenne dem hjelper deg å lese frameworks og strukturere dine egne tjenester. Intervjuere bruker dette spørsmålet for å sjekke at du ikke bare kobler sammen callbacks ad hoc, men griper etter pattern-et som passer — og kjenner avveiningene, som at en singleton gjør global state vanskeligere å teste.

Behov	Pattern
Én delt ressurs	Singleton (module cache)
Bygg objekter, skjul `new`	Factory
Reager på async events	Observer / EventEmitter
Tverrgående request-logikk	Middleware
Behandle store data trygt	Streams / pipeline
Testbare, frakoblede dependencies	Dependency Injection

Opprettelse (Creational)

Atferd (Behavioral)

Struktur (Structural)

Tommelfingerregel

Hvorfor det er viktig

Relaterte spørsmål