Was sind gängige Entwurfsmuster in Node.js?

Question

IT Interview Practice · Accepted Answer

Node.js stützt sich auf eine Handvoll Entwurfsmuster, die zu seinem Modulsystem, seinem asynchronen Modell und seinem Streaming-I/O passen. Die gängigsten, die jeder Backend-Entwickler erkennen sollte:

## Erzeugungsmuster (Creational)

- **Module pattern** — jede Datei ist ihr eigener Scope; du stellst ein öffentliches API über `module.exports` / `export` bereit und hältst Internas privat. Die Grundlage der Codeorganisation in Node.
- **Singleton** — die Exporte eines Moduls werden **gecacht**, sodass der Export einer Instanz jedem Importeur dasselbe Objekt gibt. Perfekt für einen DB Pool oder eine Config.

```js
// db.js — jedes `require("./db")` erhält denselben Pool (Singleton über den Modul-Cache).
const pool = createPool(process.env.DATABASE_URL);
module.exports = pool;
```

- **Factory** — eine Funktion, die Objekte erzeugt und zurückgibt, die Konstruktionslogik verbirgt und dir erlaubt, Implementierungen auszutauschen.

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

## Verhaltensmuster (Behavioral)

- **Observer / EventEmitter** — das zentrale asynchrone Muster von Node: benannte Events aussenden, Listener anhängen. `EventEmitter`, Streams und die meisten Kernmodule nutzen es.

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

- **Middleware** — eine Pipeline von Funktionen, die jeweils `(ctx, next)` erhalten, popularisiert durch Express/Koa. Ideal für Querschnittsbelange (Auth, Logging, Validierung).

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

- **Strategy** — einen Algorithmus zur Laufzeit auswählen (z. B. einen Zahlungsanbieter oder eine Hashing-Strategie hinter einer einzigen Schnittstelle wählen).

## Strukturmuster (Structural)

- **Adapter** — umhülle ein Drittanbieter-API mit deiner eigenen Schnittstelle, sodass du Anbieter wechseln kannst, ohne die Aufrufstellen anzufassen.
- **Streams (pipeline)** — setze die Stufen readable → transform → writable zusammen, um Daten inkrementell mit Backpressure zu verarbeiten, statt alles im Speicher zu puffern.

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

- **Dependency Injection** — übergib Kollaborateure (db, Logger, Clients) an ein Modul, statt sie direkt zu importieren; macht Code testbar und entkoppelt. Frameworks wie **NestJS** bauen DI ein; du kannst es auch von Hand über Konstruktor-/Funktionsargumente machen.

## Faustregel

| Bedarf | Muster |
|---|---|
| Eine geteilte Ressource | Singleton (Modul-Cache) |
| Objekte bauen, `new` verbergen | Factory |
| Auf asynchrone Events reagieren | Observer / EventEmitter |
| Querschnittslogik pro Request | Middleware |
| Große Daten sicher verarbeiten | Streams / pipeline |
| Testbare, entkoppelte Abhängigkeiten | Dependency Injection |

## Warum es wichtig ist

Muster sind ein gemeinsames Vokabular: zu sagen „die Config ist ein modul-gecachtes Singleton" oder „Auth ist Middleware" vermittelt ein Design in wenigen Worten. Nodes eigener Kern (EventEmitter, Streams, das Modulsystem) ist aus diesen aufgebaut, sodass ihr Erkennen dir hilft, Frameworks zu lesen und deine eigenen Services zu strukturieren. Interviewer nutzen diese Frage, um zu prüfen, dass du Callbacks nicht bloß ad hoc verdrahtest, sondern zum passenden Muster greifst — und seine Kompromisse kennst, etwa dass ein Singleton globalen Zustand schwerer testbar macht.

Bedarf	Muster
Eine geteilte Ressource	Singleton (Modul-Cache)
Objekte bauen, `new` verbergen	Factory
Auf asynchrone Events reagieren	Observer / EventEmitter
Querschnittslogik pro Request	Middleware
Große Daten sicher verarbeiten	Streams / pipeline
Testbare, entkoppelte Abhängigkeiten	Dependency Injection

Erzeugungsmuster (Creational)

Verhaltensmuster (Behavioral)

Strukturmuster (Structural)

Faustregel

Warum es wichtig ist

Ähnliche Fragen