Menene design patterns na kowa a Node.js?

Question

IT Interview Practice · Accepted Answer

Node.js na dogara ga 'yan design patterns kalilan da suka dace da module system dinsa, async model, da streaming I/O. Mafi yawan da kowane backend developer ya kamata ya gane:

## Na Halitta (Creational)

- **Module pattern** — kowace file tana da scope na kanta; kana fallasa public API ta `module.exports` / `export`, kana rike da abubuwan ciki a matsayin masu zaman kansu. Tushen tsara code a Node.
- **Singleton** — ana **cache** exports na module, don haka fitar da instance yana ba kowane importer abu iri daya. Cikakke ga DB pool ko config.

```js
// db.js — kowane require("./db") yana samun wannan pool guda (singleton ta module cache).
const pool = createPool(process.env.DATABASE_URL);
module.exports = pool;
```

- **Factory** — function da ke kirkira da mayar da objects, tana boye construction logic tana ba ka damar musanya implementations.

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

## Na Dabi'a (Behavioral)

- **Observer / EventEmitter** — babban async pattern na Node: fitar da events masu suna, hada listeners. `EventEmitter`, streams, da yawancin core modules suna amfani da shi.

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

- **Middleware** — pipeline na functions da kowanne yake karbar `(ctx, next)`, wanda Express/Koa suka shahara. Kyakkyawa ga cross-cutting concerns (auth, logging, validation).

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

- **Strategy** — zabi algorithm a runtime (misali, zabar payment provider ko hashing strategy a bayan interface guda).

## Na Tsari (Structural)

- **Adapter** — nannade API na wani bangare na uku a cikin interface dinka domin ka iya musanya vendors ba tare da taba call sites ba.
- **Streams (pipeline)** — hada matakan readable → transform → writable domin sarrafa data a hankali da backpressure, maimakon buffering komai a memory.

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

- **Dependency Injection** — mika collaborators (db, logger, clients) cikin module maimakon shigo da su kai tsaye; yana sa code ya zama testable kuma decoupled. Frameworks kamar **NestJS** suna gina DI a ciki; kana iya yin sa da hannu ta constructor/function arguments.

## Dokar babban yatsa

| Bukata | Pattern |
|---|---|
| Albarkatu guda mai rabawa | Singleton (module cache) |
| Gina objects, boye `new` | Factory |
| Ba da amsa ga async events | Observer / EventEmitter |
| Cross-cutting request logic | Middleware |
| Sarrafa manyan data cikin aminci | Streams / pipeline |
| Dependencies masu testable, decoupled | Dependency Injection |

## Me ya sa yake da muhimmanci

Patterns kalmomi ne masu rabawa: cewa "config din singleton ne da aka cache ta module" ko "auth din middleware ne" yana isar da design a cikin 'yan kalmomi. Ainihin core na Node (EventEmitter, streams, module system) an gina shi daga wadannan, don haka gane su yana taimaka maka karanta frameworks da tsara ayyukanka. Masu tambayoyi suna amfani da wannan tambaya domin duba cewa ba wai kawai kake hada callbacks ba bisa ka'ida ba, sai dai ka nemi pattern din da ya dace — kana kuma san trade-offs dinsa, kamar yadda singleton ke sa global state ya yi wuya a test.

Bukata	Pattern
Albarkatu guda mai rabawa	Singleton (module cache)
Gina objects, boye `new`	Factory
Ba da amsa ga async events	Observer / EventEmitter
Cross-cutting request logic	Middleware
Sarrafa manyan data cikin aminci	Streams / pipeline
Dependencies masu testable, decoupled	Dependency Injection

Na Halitta (Creational)

Na Dabi'a (Behavioral)

Na Tsari (Structural)

Dokar babban yatsa

Me ya sa yake da muhimmanci

Tambayoyi masu alaƙa