Melyek a gyakori design patternek a Node.js-ben?

Question

IT Interview Practice · Accepted Answer

A Node.js néhány olyan design patternre támaszkodik, amely illik a modulrendszeréhez, aszinkron modelljéhez és streaming I/O-jához. A leggyakoribbak, amelyeket minden backend fejlesztőnek fel kell ismernie:

## Létrehozó (Creational)

- **Module pattern** — minden fájl saját scope-pal rendelkezik; a publikus API-t a `module.exports` / `export` révén teszed elérhetővé, a belső részeket priváttá téve. A kódszervezés alapja a Node-ban.
- **Singleton** — egy modul exportjai **cache-elődnek**, így egy példány exportálása minden importálónak ugyanazt az objektumot adja. Tökéletes egy DB poolhoz vagy confighoz.

```js
// db.js — minden `require("./db")` ugyanezt a poolt kapja (singleton a module cache révén).
const pool = createPool(process.env.DATABASE_URL);
module.exports = pool;
```

- **Factory** — egy függvény, amely objektumokat hoz létre és ad vissza, elrejtve a konstrukciós logikát, és lehetővé téve az implementációk cseréjét.

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

## Viselkedési (Behavioral)

- **Observer / EventEmitter** — a Node alapvető aszinkron patternje: nevesített eventeket bocsátasz ki, listenereket csatolsz. Az `EventEmitter`, a streamek és a legtöbb core modul ezt használja.

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

- **Middleware** — függvények pipeline-ja, mindegyik `(ctx, next)`-et kap, az Express/Koa tette népszerűvé. Kiváló a keresztmetszeti feladatokhoz (auth, logging, validáció).

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

- **Strategy** — algoritmus kiválasztása futásidőben (pl. fizetési szolgáltató vagy hashelési stratégia választása egyetlen interfész mögött).

## Szerkezeti (Structural)

- **Adapter** — egy harmadik féltől származó API-t a saját interfészedbe csomagolsz, hogy anélkül válthass szállítót, hogy a hívási helyekhez nyúlnál.
- **Streams (pipeline)** — readable → transform → writable szakaszokat állítasz össze, hogy az adatot fokozatosan, backpressure-rel dolgozd fel, ahelyett hogy mindent a memóriában puffereznél.

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

- **Dependency Injection** — a közreműködőket (db, logger, kliensek) átadod egy modulnak, ahelyett hogy közvetlenül importálnád őket; ez tesztelhetővé és szétcsatolttá teszi a kódot. Az olyan keretrendszerek, mint a **NestJS**, beépítik a DI-t; kézzel is megteheted konstruktor-/függvényargumentumokon keresztül.

## Ökölszabály

| Igény | Pattern |
|---|---|
| Egy megosztott erőforrás | Singleton (module cache) |
| Objektumok építése, a `new` elrejtése | Factory |
| Reagálás aszinkron eventekre | Observer / EventEmitter |
| Keresztmetszeti request-logika | Middleware |
| Nagy adat biztonságos feldolgozása | Streams / pipeline |
| Tesztelhető, szétcsatolt függőségek | Dependency Injection |

## Miért fontos

A patternek közös szókincs: azt mondani, hogy "a config egy module-cache-elt singleton" vagy "az auth middleware", néhány szóban közöl egy tervet. Maga a Node core-ja (EventEmitter, streamek, a modulrendszer) ezekből épül, így felismerésük segít a keretrendszerek olvasásában és a saját szolgáltatásaid strukturálásában. Az interjúztatók ezzel a kérdéssel ellenőrzik, hogy nem csak ad hoc kötöd össze a callbackeket, hanem az illeszkedő patternhez nyúlsz — és ismered a kompromisszumait, például hogy egy singleton nehezebben tesztelhetővé teszi a globális állapotot.

Igény	Pattern
Egy megosztott erőforrás	Singleton (module cache)
Objektumok építése, a `new` elrejtése	Factory
Reagálás aszinkron eventekre	Observer / EventEmitter
Keresztmetszeti request-logika	Middleware
Nagy adat biztonságos feldolgozása	Streams / pipeline
Tesztelhető, szétcsatolt függőségek	Dependency Injection

Létrehozó (Creational)

Viselkedési (Behavioral)

Szerkezeti (Structural)

Ökölszabály

Miért fontos

Kapcsolódó kérdések