X'inhuma d-design patterns komuni f'Node.js?

Question

IT Interview Practice · Accepted Answer

Node.js jistrieħ fuq ftit design patterns li jaqblu mas-sistema tal-moduli tiegħu, il-mudell async, u l-istreaming I/O. L-aktar komuni li kull backend developer għandu jagħraf:

## Ħolqien (Creational)

- **Module pattern** — kull fajl għandu l-iscope tiegħu; int tesponi API pubbliku permezz ta' `module.exports` / `export`, filwaqt li żżomm l-internals privati. Il-pedament tal-organizzazzjoni tal-kodiċi f'Node.
- **Singleton** — l-exports ta' modul huma **cached**, għalhekk li tesporta istanza tagħti lil kull importatur l-istess oġġett. Perfett għal DB pool jew config.

```js
// db.js — kull `require("./db")` jieħu l-istess pool (singleton permezz tal-module cache).
const pool = createPool(process.env.DATABASE_URL);
module.exports = pool;
```

- **Factory** — funzjoni li toħloq u tirritorna oġġetti, taħbi l-loġika tal-kostruzzjoni u tħallik tibdel l-implimentazzjonijiet.

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

## Imġiba (Behavioral)

- **Observer / EventEmitter** — il-pattern async ċentrali ta' Node: emit ta' events b'isem, waħħal listeners. `EventEmitter`, streams, u l-biċċa l-kbira tal-moduli ċentrali jużawh.

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

- **Middleware** — pipeline ta' funzjonijiet fejn kull waħda tirċievi `(ctx, next)`, popolarizzat minn Express/Koa. Tajjeb għal tħassib trażversali (auth, logging, validation).

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

- **Strategy** — agħżel algoritmu waqt ir-runtime (eż. agħżel provider tal-ħlas jew strateġija ta' hashing wara interface wieħed).

## Strutturali (Structural)

- **Adapter** — geżwer API ta' parti terza fl-interface tiegħek stess biex tkun tista' tibdel il-vendors mingħajr ma tmiss il-call sites.
- **Streams (pipeline)** — għaqqad stadji readable → transform → writable biex tipproċessa data pass pass b'backpressure, minflok tibbafferja kollox fil-memorja.

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

- **Dependency Injection** — għaddi l-kollaboraturi (db, logger, clients) ġo modul minflok timportahom direttament; jagħmel il-kodiċi testabbli u decoupled. Frameworks bħal **NestJS** jibnu d-DI internament; tista' wkoll tagħmilha bl-idejn permezz ta' argumenti tal-constructor/funzjoni.

## Regola prattika

| Bżonn | Pattern |
|---|---|
| Riżorsa waħda kondiviża | Singleton (module cache) |
| Ibni oġġetti, aħbi `new` | Factory |
| Irreaġixxi għal events async | Observer / EventEmitter |
| Loġika ta' request trażversali | Middleware |
| Ipproċessa data kbira b'mod sigur | Streams / pipeline |
| Dipendenzi testabbli, decoupled | Dependency Injection |

## Għaliex huwa importanti

Il-patterns huma vokabularju kondiviż: li tgħid "il-config huwa singleton cached bil-modul" jew "l-auth huwa middleware" jikkomunika disinn fi ftit kliem. Il-core ta' Node innifsu (EventEmitter, streams, is-sistema tal-moduli) huwa mibni minn dawn, għalhekk li tagħrafhom jgħinek taqra l-frameworks u tistruttura s-servizzi tiegħek stess. L-intervistaturi jużaw din il-mistoqsija biex jiċċekkjaw li int ma tgħaqqadx callbacks ad hoc biss, iżda tilħaq għall-pattern li jaqbel — u taf it-trade-offs tiegħu, bħal singleton li jagħmel l-istat globali aktar diffiċli biex jiġi ttestjat.

Bżonn	Pattern
Riżorsa waħda kondiviża	Singleton (module cache)
Ibni oġġetti, aħbi `new`	Factory
Irreaġixxi għal events async	Observer / EventEmitter
Loġika ta' request trażversali	Middleware
Ipproċessa data kbira b'mod sigur	Streams / pipeline
Dipendenzi testabbli, decoupled	Dependency Injection

Ħolqien (Creational)

Imġiba (Behavioral)

Strutturali (Structural)

Regola prattika

Għaliex huwa importanti

Mistoqsijiet relatati