Apa saja design pattern umum di Node.js?

Question

IT Interview Practice · Accepted Answer

Node.js bersandar pada segelintir design pattern yang cocok dengan sistem modul, model async, dan streaming I/O-nya. Yang paling umum dan harus dikenali setiap developer backend:

## Kreasional (Creational)

- **Module pattern** — setiap file adalah scope-nya sendiri; Anda mengekspos API publik melalui `module.exports` / `export`, menjaga internal tetap privat. Fondasi organisasi kode di Node.
- **Singleton** — ekspor sebuah modul **di-cache**, jadi mengekspor sebuah instance memberi setiap importer objek yang sama. Sempurna untuk DB pool atau config.

```js
// db.js — setiap `require("./db")` mendapat pool yang sama ini (singleton via module cache).
const pool = createPool(process.env.DATABASE_URL);
module.exports = pool;
```

- **Factory** — fungsi yang membuat dan mengembalikan objek, menyembunyikan logika konstruksi dan memungkinkan Anda menukar implementasi.

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

## Perilaku (Behavioral)

- **Observer / EventEmitter** — pattern async inti Node: emit event bernama, pasang listener. `EventEmitter`, streams, dan sebagian besar modul core menggunakannya.

```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 yang masing-masing menerima `(ctx, next)`, dipopulerkan oleh Express/Koa. Bagus untuk concern lintas-sektoral (auth, logging, validasi).

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

- **Strategy** — memilih algoritma saat runtime (mis. memilih penyedia pembayaran atau strategi hashing di balik satu interface).

## Struktural (Structural)

- **Adapter** — bungkus API pihak ketiga dalam interface Anda sendiri sehingga Anda bisa menukar vendor tanpa menyentuh call site.
- **Streams (pipeline)** — susun tahap readable → transform → writable untuk memproses data secara bertahap dengan backpressure, alih-alih mem-buffer semuanya di memori.

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

- **Dependency Injection** — teruskan kolaborator (db, logger, client) ke sebuah modul alih-alih meng-import-nya langsung; membuat kode testable dan decoupled. Framework seperti **NestJS** membangun DI di dalamnya; Anda juga bisa melakukannya secara manual via argumen constructor/fungsi.

## Aturan praktis

| Kebutuhan | Pattern |
|---|---|
| Satu resource bersama | Singleton (module cache) |
| Membuat objek, sembunyikan `new` | Factory |
| Bereaksi terhadap event async | Observer / EventEmitter |
| Logika request lintas-sektoral | Middleware |
| Proses data besar dengan aman | Streams / pipeline |
| Dependensi yang testable, decoupled | Dependency Injection |

## Mengapa ini penting

Pattern adalah kosakata bersama: mengatakan "config adalah singleton yang di-cache modul" atau "auth adalah middleware" mengomunikasikan sebuah desain dalam beberapa kata. Core Node sendiri (EventEmitter, streams, sistem modul) dibangun dari ini, jadi mengenalinya membantu Anda membaca framework dan menyusun service Anda sendiri. Pewawancara memakai pertanyaan ini untuk memeriksa bahwa Anda tidak sekadar merangkai callback secara ad hoc, tetapi meraih pattern yang cocok — dan tahu trade-off-nya, seperti singleton yang membuat state global lebih sulit di-test.

Kebutuhan	Pattern
Satu resource bersama	Singleton (module cache)
Membuat objek, sembunyikan `new`	Factory
Bereaksi terhadap event async	Observer / EventEmitter
Logika request lintas-sektoral	Middleware
Proses data besar dengan aman	Streams / pipeline
Dependensi yang testable, decoupled	Dependency Injection

Kreasional (Creational)

Perilaku (Behavioral)

Struktural (Structural)

Aturan praktis

Mengapa ini penting

Pertanyaan terkait