Care sunt tiparele de proiectare frecvente în Node.js?

Question

IT Interview Practice · Accepted Answer

Node.js se bazează pe câteva tipare de proiectare care se potrivesc sistemului său de module, modelului asincron și I/O-ului de streaming. Cele mai comune pe care orice dezvoltator backend ar trebui să le recunoască:

## Creaționale

- **Tiparul modul** — fiecare fișier are propriul domeniu; expui un API public prin `module.exports` / `export`, păstrând internele private. Fundamentul organizării codului în Node.
- **Singleton** — exporturile unui modul sunt **memorate în cache**, așa că exportarea unei instanțe oferă fiecărui importator același obiect. Perfect pentru un pool de DB sau configurație.

```js
// db.js — fiecare `require("./db")` primește același pool (singleton prin cache-ul de module).
const pool = createPool(process.env.DATABASE_URL);
module.exports = pool;
```

- **Factory** — o funcție care creează și returnează obiecte, ascunzând logica de construcție și permițând schimbarea implementărilor.

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

## Comportamentale

- **Observer / EventEmitter** — tiparul async de bază al Node: emite evenimente denumite, atașează ascultători. `EventEmitter`, stream-urile și majoritatea modulelor de bază îl folosesc.

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

- **Middleware** — un pipeline de funcții, fiecare primind `(ctx, next)`, popularizat de Express/Koa. Excelent pentru preocupări transversale (auth, logging, validare).

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

- **Strategy** — selectează un algoritm în timpul execuției (ex.: alegerea unui furnizor de plăți sau a unei strategii de hashing în spatele unei singure interfețe).

## Structurale

- **Adapter** — împachetează un API terț în propria interfață pentru a putea schimba furnizorii fără a atinge punctele de apel.
- **Stream-uri (pipeline)** — compune etape readable → transform → writable pentru a procesa datele incremental cu backpressure, în loc să bufferezi totul în memorie.

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

- **Injecția de dependențe** — transmite colaboratori (db, logger, clienți) într-un modul în loc să-i imporți direct; face codul testabil și decuplat. Framework-uri precum **NestJS** au DI integrat; îl poți face și manual prin argumente de constructor/funcție.

## Regulă practică

| Nevoie | Tipar |
|---|---|
| O resursă partajată | Singleton (cache-ul de module) |
| Construiește obiecte, ascunde `new` | Factory |
| Reacționează la evenimente async | Observer / EventEmitter |
| Logică transversală de cerere | Middleware |
| Procesează date mari în siguranță | Stream-uri / pipeline |
| Dependențe testabile, decuplate | Injecția de dependențe |

## De ce contează

Tiparele sunt un vocabular comun: a spune „configurația este un singleton memorat prin cache-ul de module" sau „auth-ul este middleware" comunică un design în câteva cuvinte. Însuși nucleul Node (EventEmitter, stream-uri, sistemul de module) este construit din ele, așa că recunoașterea lor te ajută să citești framework-uri și să-ți structurezi propriile servicii. Intervievatorii folosesc această întrebare pentru a verifica dacă nu doar conectezi callback-uri ad hoc, ci recurgi la tiparul potrivit — și îi cunoști compromisurile, cum ar fi un singleton care face starea globală mai greu de testat.

Nevoie	Tipar
O resursă partajată	Singleton (cache-ul de module)
Construiește obiecte, ascunde `new`	Factory
Reacționează la evenimente async	Observer / EventEmitter
Logică transversală de cerere	Middleware
Procesează date mari în siguranță	Stream-uri / pipeline
Dependențe testabile, decuplate	Injecția de dependențe

Creaționale

Comportamentale

Structurale

Regulă practică

De ce contează

Întrebări conexe