Vilka är vanliga designmönster i Node.js?

Question

IT Interview Practice · Accepted Answer

Node.js lutar sig mot en handfull designmönster som passar dess modulsystem, asynkrona modell och strömmande I/O. De vanligaste som varje backend-utvecklare bör känna igen:

## Skapande (Creational)

- **Modulmönster** — varje fil har sitt eget scope; du exponerar ett publikt API via `module.exports` / `export` och håller interna delar privata. Grunden för kodorganisation i Node.
- **Singleton** — en moduls exports **cachas**, så att exportera en instans ger varje importör samma objekt. Perfekt för en DB-pool eller config.

```js
// db.js — varje `require("./db")` får denna samma pool (singleton via module cache).
const pool = createPool(process.env.DATABASE_URL);
module.exports = pool;
```

- **Factory** — en funktion som skapar och returnerar objekt, döljer konstruktionslogiken och låter dig byta implementationer.

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

## Beteende (Behavioral)

- **Observer / EventEmitter** — Nodes centrala asynkrona mönster: sänd ut namngivna events, koppla på lyssnare. `EventEmitter`, streams och de flesta core-moduler använder 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 funktioner som var och en får `(ctx, next)`, populariserad av Express/Koa. Utmärkt för genomskärande angelägenheter (auth, loggning, validering).

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

- **Strategy** — välj en algoritm vid runtime (t.ex. välj en betalleverantör eller en hashningsstrategi bakom ett gränssnitt).

## Strukturella (Structural)

- **Adapter** — slå in ett tredjeparts-API i ditt eget gränssnitt så att du kan byta leverantör utan att röra anropsställena.
- **Streams (pipeline)** — sätt samman stegen readable → transform → writable för att bearbeta data inkrementellt med backpressure, i stället för att buffra allt i minnet.

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

- **Dependency Injection** — skicka in medarbetare (db, logger, klienter) i en modul i stället för att importera dem direkt; gör koden testbar och avkopplad. Ramverk som **NestJS** bygger in DI; du kan också göra det för hand via constructor-/funktionsargument.

## Tumregel

| Behov | Mönster |
|---|---|
| En delad resurs | Singleton (module cache) |
| Bygg objekt, dölj `new` | Factory |
| Reagera på asynkrona events | Observer / EventEmitter |
| Genomskärande request-logik | Middleware |
| Bearbeta stor data säkert | Streams / pipeline |
| Testbara, avkopplade beroenden | Dependency Injection |

## Varför det är viktigt

Mönster är ett gemensamt ordförråd: att säga "config är en module-cachad singleton" eller "auth är middleware" kommunicerar en design med några få ord. Nodes egen core (EventEmitter, streams, modulsystemet) är byggd av dessa, så att känna igen dem hjälper dig att läsa ramverk och strukturera dina egna tjänster. Intervjuare använder denna fråga för att kontrollera att du inte bara kopplar callbacks ad hoc, utan sträcker dig efter mönstret som passar — och känner till dess avvägningar, som att en singleton gör globalt tillstånd svårare att testa.

Behov	Mönster
En delad resurs	Singleton (module cache)
Bygg objekt, dölj `new`	Factory
Reagera på asynkrona events	Observer / EventEmitter
Genomskärande request-logik	Middleware
Bearbeta stor data säkert	Streams / pipeline
Testbara, avkopplade beroenden	Dependency Injection

Skapande (Creational)

Beteende (Behavioral)

Strukturella (Structural)

Tumregel

Varför det är viktigt

Relaterade frågor