Node.js માં સામાન્ય design patterns કયા છે?

Question

IT Interview Practice · Accepted Answer

Node.js થોડાક design patterns પર આધાર રાખે છે જે તેની module system, async model, અને streaming I/O સાથે બંધબેસે છે. દરેક backend developer ને ઓળખવા જોઈએ તેવા સૌથી સામાન્ય:

## રચનાત્મક (Creational)

- **Module pattern** — દરેક file નું પોતાનું scope છે; તમે `module.exports` / `export` દ્વારા public API બહાર પાડો છો, અને આંતરિક ભાગ private રાખો છો. Node માં code સંગઠનનો પાયો.
- **Singleton** — module ના exports **cache** થાય છે, તેથી instance export કરવાથી દરેક importer ને એ જ object મળે છે. DB pool કે config માટે યોગ્ય.

```js
// db.js — દરેક require("./db") ને એ જ pool મળે છે (module cache દ્વારા singleton).
const pool = createPool(process.env.DATABASE_URL);
module.exports = pool;
```

- **Factory** — એક function જે objects બનાવે અને પરત આપે, construction logic છુપાવે અને implementations બદલવા દે.

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

## વર્તણૂકીય (Behavioral)

- **Observer / EventEmitter** — Node નું મુખ્ય async pattern: named events emit કરો, listeners જોડો. `EventEmitter`, streams, અને મોટાભાગના core modules તેનો ઉપયોગ કરે છે.

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

- **Middleware** — functions ની pipeline જ્યાં દરેક `(ctx, next)` મેળવે છે, Express/Koa દ્વારા લોકપ્રિય. cross-cutting concerns (auth, logging, validation) માટે ઉત્તમ.

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

- **Strategy** — runtime પર algorithm પસંદ કરો (દા.ત. એક interface પાછળ payment provider કે hashing strategy પસંદ કરવી).

## માળખાકીય (Structural)

- **Adapter** — ત્રીજા પક્ષના API ને તમારા પોતાના interface માં લપેટો જેથી call sites ને સ્પર્શ કર્યા વગર vendors બદલી શકો.
- **Streams (pipeline)** — બધું memory માં buffer કરવાને બદલે readable → transform → writable stages ને જોડીને data ને backpressure સાથે ધીમે ધીમે પ્રોસેસ કરો.

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

- **Dependency Injection** — collaborators (db, logger, clients) ને directly import કરવાને બદલે module માં પસાર કરો; code ને testable અને decoupled બનાવે છે. **NestJS** જેવા frameworks DI ને built-in રાખે છે; તમે constructor/function arguments દ્વારા હાથે પણ કરી શકો.

## અંગૂઠાનો નિયમ

| જરૂરિયાત | Pattern |
|---|---|
| એક shared resource | Singleton (module cache) |
| Objects બનાવો, `new` છુપાવો | Factory |
| async events પર પ્રતિક્રિયા આપો | Observer / EventEmitter |
| cross-cutting request logic | Middleware |
| મોટા data ને સુરક્ષિત રીતે પ્રોસેસ કરો | Streams / pipeline |
| testable, decoupled dependencies | Dependency Injection |

## આ શા માટે મહત્વનું છે

Patterns એ સહિયારી શબ્દાવલી છે: "config એ module-cached singleton છે" કે "auth એ middleware છે" કહેવું થોડા શબ્દોમાં design પહોંચાડે છે. Node નું પોતાનું core (EventEmitter, streams, module system) આ patterns માંથી બનેલું છે, તેથી તેમને ઓળખવાથી તમને frameworks વાંચવામાં અને તમારી પોતાની services ને રચવામાં મદદ મળે છે. ઇન્ટરવ્યુઅર્સ આ પ્રશ્નનો ઉપયોગ એ ચકાસવા કરે છે કે તમે માત્ર callbacks ને આડેધડ જોડતા નથી, પરંતુ બંધબેસતું pattern પસંદ કરો છો — અને તેના trade-offs જાણો છો, જેમ કે singleton global state ને test કરવું અઘરું બનાવે છે.

જરૂરિયાત	Pattern
એક shared resource	Singleton (module cache)
Objects બનાવો, `new` છુપાવો	Factory
async events પર પ્રતિક્રિયા આપો	Observer / EventEmitter
cross-cutting request logic	Middleware
મોટા data ને સુરક્ષિત રીતે પ્રોસેસ કરો	Streams / pipeline
testable, decoupled dependencies	Dependency Injection

રચનાત્મક (Creational)

વર્તણૂકીય (Behavioral)

માળખાકીય (Structural)

અંગૂઠાનો નિયમ

આ શા માટે મહત્વનું છે

સંબંધિત પ્રશ્નો