Ni design patterns zipi zinazojulikana katika Node.js?

Question

IT Interview Practice · Accepted Answer

Node.js hutegemea design patterns chache zinazolingana na mfumo wake wa module, modeli ya async, na I/O ya streaming. Zile zinazojulikana zaidi ambazo kila developer wa backend anapaswa kuzitambua:

## Za Uumbaji (Creational)

- **Module pattern** — kila faili ina scope yake mwenyewe; unaonyesha API ya umma kupitia `module.exports` / `export`, ukiweka sehemu za ndani kuwa private. Msingi wa upangaji wa code katika Node.
- **Singleton** — exports za module hu-**cached**, kwa hivyo kusafirisha instance humpa kila mwenye kuiingiza object ile ile. Kamili kwa DB pool au config.

```js
// db.js — kila `require("./db")` hupata pool ile ile hii (singleton kupitia module cache).
const pool = createPool(process.env.DATABASE_URL);
module.exports = pool;
```

- **Factory** — function inayounda na kurudisha objects, ikificha mantiki ya uundaji na kukuruhusu kubadilisha implementations.

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

## Za Tabia (Behavioral)

- **Observer / EventEmitter** — pattern kuu ya async ya Node: toa events zenye majina, ambatanisha listeners. `EventEmitter`, streams, na module nyingi za core huitumia.

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

- **Middleware** — pipeline ya functions ambapo kila moja hupokea `(ctx, next)`, iliyoenezwa na Express/Koa. Nzuri kwa mambo yanayovuka (auth, logging, validation).

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

- **Strategy** — chagua algorithm wakati wa runtime (mfano, chagua mtoa huduma wa malipo au mkakati wa hashing nyuma ya interface moja).

## Za Muundo (Structural)

- **Adapter** — funga API ya wahusika wengine ndani ya interface yako mwenyewe ili uweze kubadilisha wauzaji bila kugusa sehemu za wito.
- **Streams (pipeline)** — unganisha hatua za readable → transform → writable ili kuchakata data hatua kwa hatua kwa backpressure, badala ya ku-buffer kila kitu kwenye kumbukumbu.

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

- **Dependency Injection** — pitisha washirika (db, logger, clients) ndani ya module badala ya kuwa-import moja kwa moja; hufanya code iweze kupimwa na kutenganishwa. Frameworks kama **NestJS** hujenga DI ndani; unaweza pia kuifanya kwa mkono kupitia arguments za constructor/function.

## Kanuni ya kidole gumba

| Hitaji | Pattern |
|---|---|
| Rasilimali moja iliyoshirikiwa | Singleton (module cache) |
| Jenga objects, ficha `new` | Factory |
| Itikia events za async | Observer / EventEmitter |
| Mantiki ya request inayovuka | Middleware |
| Chakata data kubwa kwa usalama | Streams / pipeline |
| Dependencies zinazopimika, zilizotenganishwa | Dependency Injection |

## Kwa nini ni muhimu

Patterns ni msamiati wa pamoja: kusema "config ni singleton iliyo-cache kwa module" au "auth ni middleware" huwasilisha muundo kwa maneno machache. Core yenyewe ya Node (EventEmitter, streams, mfumo wa module) imejengwa kutoka kwa hizi, kwa hivyo kuzitambua kunakusaidia kusoma frameworks na kupanga services zako mwenyewe. Wahojiwa hutumia swali hili kuangalia kama huunganishi tu callbacks kiholela, bali unafikia pattern inayolingana — na unajua maelewano yake, kama singleton kufanya hali ya global kuwa ngumu kupima.

Hitaji	Pattern
Rasilimali moja iliyoshirikiwa	Singleton (module cache)
Jenga objects, ficha `new`	Factory
Itikia events za async	Observer / EventEmitter
Mantiki ya request inayovuka	Middleware
Chakata data kubwa kwa usalama	Streams / pipeline
Dependencies zinazopimika, zilizotenganishwa	Dependency Injection

Za Uumbaji (Creational)

Za Tabia (Behavioral)

Za Muundo (Structural)

Kanuni ya kidole gumba

Kwa nini ni muhimu

Maswali yanayohusiana