Quali sono i design pattern comuni in Node.js?

Question

IT Interview Practice · Accepted Answer

Node.js si appoggia a una manciata di design pattern che si adattano al suo sistema di moduli, al modello async e all'I/O in streaming. I più comuni che ogni sviluppatore backend dovrebbe riconoscere:

## Creazionali

- **Module pattern** — ogni file è il proprio scope; esponi un'API pubblica tramite `module.exports` / `export`, mantenendo privati gli interni. Il fondamento dell'organizzazione del codice in Node.
- **Singleton** — gli export di un modulo sono **in cache**, quindi esportare un'istanza dà a ogni importatore lo stesso oggetto. Perfetto per un DB pool o una config.

```js
// db.js — ogni `require("./db")` ottiene questo stesso pool (singleton tramite module cache).
const pool = createPool(process.env.DATABASE_URL);
module.exports = pool;
```

- **Factory** — una funzione che crea e restituisce oggetti, nascondendo la logica di costruzione e permettendoti di scambiare implementazioni.

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

## Comportamentali

- **Observer / EventEmitter** — il pattern async centrale di Node: emetti eventi con nome, colleghi listener. `EventEmitter`, gli stream e la maggior parte dei moduli core lo usano.

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

- **Middleware** — una pipeline di funzioni che ricevono ciascuna `(ctx, next)`, resa popolare da Express/Koa. Ottima per le preoccupazioni trasversali (auth, logging, validazione).

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

- **Strategy** — seleziona un algoritmo a runtime (es. scegliere un provider di pagamento o una strategia di hashing dietro una singola interfaccia).

## Strutturali

- **Adapter** — avvolgi un'API di terze parti nella tua interfaccia così da poter cambiare vendor senza toccare i punti di chiamata.
- **Streams (pipeline)** — componi stadi readable → transform → writable per elaborare i dati in modo incrementale con backpressure, invece di bufferizzare tutto in memoria.

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

- **Dependency Injection** — passa i collaboratori (db, logger, client) a un modulo invece di importarli direttamente; rende il codice testabile e disaccoppiato. Framework come **NestJS** integrano la DI; puoi anche farla a mano tramite argomenti di costruttore/funzione.

## Regola pratica

| Necessità | Pattern |
|---|---|
| Una risorsa condivisa | Singleton (module cache) |
| Costruire oggetti, nascondere `new` | Factory |
| Reagire a eventi async | Observer / EventEmitter |
| Logica di request trasversale | Middleware |
| Elaborare grandi dati in sicurezza | Streams / pipeline |
| Dipendenze testabili, disaccoppiate | Dependency Injection |

## Perché è importante

I pattern sono un vocabolario condiviso: dire "la config è un singleton in cache di modulo" o "l'auth è middleware" comunica un design in poche parole. Lo stesso core di Node (EventEmitter, stream, il sistema di moduli) è costruito da questi, quindi riconoscerli ti aiuta a leggere i framework e a strutturare i tuoi servizi. Gli intervistatori usano questa domanda per verificare che tu non colleghi callback ad hoc, ma ricorra al pattern che si adatta — e ne conosca i compromessi, come un singleton che rende lo stato globale più difficile da testare.

Necessità	Pattern
Una risorsa condivisa	Singleton (module cache)
Costruire oggetti, nascondere `new`	Factory
Reagire a eventi async	Observer / EventEmitter
Logica di request trasversale	Middleware
Elaborare grandi dati in sicurezza	Streams / pipeline
Dipendenze testabili, disaccoppiate	Dependency Injection

Creazionali

Comportamentali

Strutturali

Regola pratica

Perché è importante

Domande correlate