Kokie yra dažni design patternai Node.js?

Question

IT Interview Practice · Accepted Answer

Node.js remiasi keliais design patternais, kurie tinka jos modulių sistemai, asinchroniniam modeliui ir srautiniam I/O. Dažniausi, kuriuos turėtų atpažinti kiekvienas backend kūrėjas:

## Kūrimo (Creational)

- **Module pattern** — kiekvienas failas turi savo scope'ą; viešą API atskleidžiate per `module.exports` / `export`, o vidų laikote privatų. Kodo organizavimo Node'e pamatas.
- **Singleton** — modulio eksportai yra **kešuojami**, todėl eksportuojant instanciją kiekvienas importuotojas gauna tą patį objektą. Puikiai tinka DB pool'ui ar config'ui.

```js
// db.js — kiekvienas `require("./db")` gauna tą patį pool'ą (singleton per modulių kešą).
const pool = createPool(process.env.DATABASE_URL);
module.exports = pool;
```

- **Factory** — funkcija, kuri sukuria ir grąžina objektus, slepdama kūrimo logiką ir leisdama keisti realizacijas.

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

## Elgsenos (Behavioral)

- **Observer / EventEmitter** — pagrindinis Node asinchroninis pattern'as: siunčiate pavadintus event'us, prikabinate listener'ius. `EventEmitter`, streams ir dauguma core modulių jį naudoja.

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

- **Middleware** — funkcijų konvejeris, kur kiekviena gauna `(ctx, next)`, išpopuliarintas Express/Koa. Puikiai tinka kertiniams (cross-cutting) reikalams (auth, logging, validation).

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

- **Strategy** — pasirinkite algoritmą vykdymo metu (pvz., mokėjimų tiekėją ar hashing strategiją už vieno interface'o).

## Struktūriniai (Structural)

- **Adapter** — apgaubkite trečiosios šalies API savo interface'u, kad galėtumėte keisti tiekėjus neliesdami iškvietimo vietų.
- **Streams (pipeline)** — sujunkite readable → transform → writable etapus, kad apdorotumėte duomenis palaipsniui su backpressure, užuot buferizavę viską atmintyje.

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

- **Dependency Injection** — perduokite bendradarbius (db, logger, klientus) į modulį, užuot juos importavę tiesiogiai; kodas tampa testuojamas ir atsietas. Framework'ai kaip **NestJS** turi įmontuotą DI; galite tai daryti ir rankomis per konstruktoriaus/funkcijos argumentus.

## Nykščio taisyklė

| Poreikis | Pattern |
|---|---|
| Vienas bendras resursas | Singleton (modulių kešas) |
| Kurti objektus, slėpti `new` | Factory |
| Reaguoti į asinchroninius event'us | Observer / EventEmitter |
| Kertinė užklausų logika | Middleware |
| Saugiai apdoroti didelius duomenis | Streams / pipeline |
| Testuojamos, atsietos priklausomybės | Dependency Injection |

## Kodėl tai svarbu

Pattern'ai yra bendras žodynas: pasakymas „config yra modulio kešuotas singleton'as" arba „auth yra middleware" perteikia dizainą keliais žodžiais. Pati Node šerdis (EventEmitter, streams, modulių sistema) sukurta iš jų, tad jų atpažinimas padeda skaityti framework'us ir struktūrizuoti savo servisus. Interviuotojai šį klausimą naudoja patikrinti, ar jūs ne tik jungiate callback'us bet kaip, bet pasiekiate tinkantį pattern'ą — ir žinote jo kompromisus, pavyzdžiui, kad singleton'as apsunkina globalios būsenos testavimą.

Poreikis	Pattern
Vienas bendras resursas	Singleton (modulių kešas)
Kurti objektus, slėpti `new`	Factory
Reaguoti į asinchroninius event'us	Observer / EventEmitter
Kertinė užklausų logika	Middleware
Saugiai apdoroti didelius duomenis	Streams / pipeline
Testuojamos, atsietos priklausomybės	Dependency Injection

Kūrimo (Creational)

Elgsenos (Behavioral)

Struktūriniai (Structural)

Nykščio taisyklė

Kodėl tai svarbu

Susiję klausimai