Apa wae design pattern sing umum ing Node.js?

Question

IT Interview Practice · Accepted Answer

Node.js gumantung marang sawetara design pattern sing cocog karo sistem modul, model async, lan streaming I/O-ne. Sing paling umum lan kudu dingerteni saben developer backend:

## Kreasional (Creational)

- **Module pattern** — saben file iku scope-e dhewe; sampeyan mbukak API publik liwat `module.exports` / `export`, njaga internal tetep privat. Pondhasi organisasi kode ing Node.
- **Singleton** — ekspor saka sawijining modul di-**cache**, dadi ngekspor siji instance menehi saben importer objek sing padha. Sampurna kanggo DB pool utawa config.

```js
// db.js — saben `require("./db")` entuk pool sing padha iki (singleton liwat module cache).
const pool = createPool(process.env.DATABASE_URL);
module.exports = pool;
```

- **Factory** — fungsi sing nggawe lan mbalekake objek, ndhelikake logika konstruksi lan ngidini sampeyan ngganti implementasi.

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

## Prilaku (Behavioral)

- **Observer / EventEmitter** — pattern async inti Node: emit event sing dijenengi, pasang listener. `EventEmitter`, streams, lan umume modul core nggunakake iki.

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

- **Middleware** — pipeline fungsi sing saben-saben nampa `(ctx, next)`, dipopulerake dening Express/Koa. Apik kanggo urusan lintas-sektoral (auth, logging, validasi).

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

- **Strategy** — milih algoritma nalika runtime (upamane milih panyedhiya pembayaran utawa strategi hashing ing mburi siji interface).

## Struktural (Structural)

- **Adapter** — bungkus API pihak katelu ing interface sampeyan dhewe supaya sampeyan bisa ngganti vendor tanpa ndemek call site.
- **Streams (pipeline)** — susun tahap readable → transform → writable kanggo ngolah data kanthi bertahap nganggo backpressure, tinimbang mbuffer kabeh ing memori.

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

- **Dependency Injection** — terusake kolaborator (db, logger, client) menyang sawijining modul tinimbang ngimpor langsung; ndadekake kode testable lan decoupled. Framework kaya **NestJS** mbangun DI ing njero; sampeyan uga bisa nglakoni kanthi manual liwat argumen constructor/fungsi.

## Pathokan umum

| Kabutuhan | Pattern |
|---|---|
| Siji resource bareng | Singleton (module cache) |
| Nggawe objek, ndhelikake `new` | Factory |
| Nanggapi event async | Observer / EventEmitter |
| Logika request lintas-sektoral | Middleware |
| Ngolah data gedhe kanthi aman | Streams / pipeline |
| Dependensi testable, decoupled | Dependency Injection |

## Kenapa iki penting

Pattern iku kosakata bareng: ngomong "config iku singleton sing di-cache modul" utawa "auth iku middleware" nyampekake sawijining desain mung nganggo sawetara tembung. Core Node dhewe (EventEmitter, streams, sistem modul) dibangun saka iki, dadi ngenali iku mbantu sampeyan maca framework lan nyusun service sampeyan dhewe. Pewawancara nggunakake pitakon iki kanggo mriksa yen sampeyan ora mung nyambung callback kanthi ad hoc, nanging njupuk pattern sing cocog — lan ngerti trade-off-e, kaya singleton sing ndadekake state global luwih angel di-test.

Kabutuhan	Pattern
Siji resource bareng	Singleton (module cache)
Nggawe objek, ndhelikake `new`	Factory
Nanggapi event async	Observer / EventEmitter
Logika request lintas-sektoral	Middleware
Ngolah data gedhe kanthi aman	Streams / pipeline
Dependensi testable, decoupled	Dependency Injection

Kreasional (Creational)

Prilaku (Behavioral)

Struktural (Structural)

Pathokan umum

Kenapa iki penting

Pitakon sing gegandhengan