Jaké jsou běžné návrhové vzory v Node.js?

Question

IT Interview Practice · Accepted Answer

Node.js se opírá o hrstku návrhových vzorů, které sedí k jeho modulovému systému, asynchronnímu modelu a streamovanému I/O. Ty nejběžnější, které by měl znát každý backendový vývojář:

## Vytvářející (Creational)

- **Module pattern** — každý soubor má vlastní scope; veřejné API vystavíte přes `module.exports` / `export` a vnitřnosti necháte privátní. Základ organizace kódu v Node.
- **Singleton** — exporty modulu se **kešují**, takže export instance dá každému importérovi tentýž objekt. Ideální pro DB pool nebo konfiguraci.

```js
// db.js — každý `require("./db")` dostane tentýž pool (singleton přes keš modulů).
const pool = createPool(process.env.DATABASE_URL);
module.exports = pool;
```

- **Factory** — funkce, která vytváří a vrací objekty, skrývá logiku konstrukce a umožňuje zaměňovat implementace.

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

## Chování (Behavioral)

- **Observer / EventEmitter** — klíčový asynchronní vzor Node: vysíláte pojmenované události, připojujete listenery. Používá ho `EventEmitter`, streamy i většina základních modulů.

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

- **Middleware** — pipeline funkcí, z nichž každá dostává `(ctx, next)`, zpopularizovaná Express/Koa. Skvělá pro průřezové záležitosti (auth, logování, validace).

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

- **Strategy** — výběr algoritmu za běhu (např. zvolit poskytovatele plateb nebo strategii hashování za jedním rozhraním).

## Strukturální (Structural)

- **Adapter** — obalte API třetí strany vlastním rozhraním, abyste mohli měnit dodavatele bez zásahu do míst volání.
- **Streams (pipeline)** — složte fáze readable → transform → writable pro postupné zpracování dat s backpressure, místo bufferování všeho v paměti.

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

- **Dependency Injection** — předávejte spolupracovníky (db, logger, klienty) do modulu místo jejich přímého importu; kód je pak testovatelný a rozvázaný. Frameworky jako **NestJS** mají DI zabudované; můžete to dělat i ručně přes argumenty konstruktoru/funkce.

## Orientační pravidlo

| Potřeba | Vzor |
|---|---|
| Jeden sdílený zdroj | Singleton (keš modulů) |
| Tvořit objekty, skrýt `new` | Factory |
| Reagovat na asynchronní události | Observer / EventEmitter |
| Průřezová logika požadavku | Middleware |
| Bezpečně zpracovat velká data | Streams / pipeline |
| Testovatelné, rozvázané závislosti | Dependency Injection |

## Proč je to důležité

Vzory jsou sdílený slovník: říci „konfigurace je singleton kešovaný na úrovni modulu" nebo „auth je middleware" sdělí návrh několika slovy. Samotné jádro Node (EventEmitter, streamy, modulový systém) je z těchto vzorů postavené, takže jejich rozpoznání vám pomůže číst frameworky a strukturovat vlastní služby. Tazatelé touto otázkou ověřují, že jen ad hoc nespojujete callbacky, ale saháte po vzoru, který sedí — a znáte jeho kompromisy, třeba že singleton ztěžuje testování globálního stavu.

Potřeba	Vzor
Jeden sdílený zdroj	Singleton (keš modulů)
Tvořit objekty, skrýt `new`	Factory
Reagovat na asynchronní události	Observer / EventEmitter
Průřezová logika požadavku	Middleware
Bezpečně zpracovat velká data	Streams / pipeline
Testovatelné, rozvázané závislosti	Dependency Injection

Vytvářející (Creational)

Chování (Behavioral)

Strukturální (Structural)

Orientační pravidlo

Proč je to důležité

Související otázky