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 देखाउनुहुन्छ, र internals लाई private राख्नुहुन्छ। Node मा code organization को आधार।
- **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: नाम भएका 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** — third-party API लाई तपाईंको आफ्नै interface मा बेर्नुहोस् ताकि तपाईं call sites नछोई vendors साट्न सक्नुहोस्।
- **Streams (pipeline)** — सबै कुरा memory मा buffer गर्नुको सट्टा readable → transform → writable stages जोडेर backpressure सहित data क्रमिक रूपमा process गर्नुहोस्।

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

- **Dependency Injection** — collaborators (db, logger, clients) लाई सीधै import गर्नुको सट्टा module मा pass गर्नुहोस्; यसले code लाई testable र decoupled बनाउँछ। **NestJS** जस्ता frameworks ले DI भित्रै निर्माण गर्छन्; तपाईं constructor/function arguments मार्फत हातैले पनि गर्न सक्नुहुन्छ।

## अनुमानको नियम

| आवश्यकता | Pattern |
|---|---|
| एउटा साझा resource | Singleton (module cache) |
| objects बनाउने, `new` लुकाउने | Factory |
| async events मा प्रतिक्रिया दिने | Observer / EventEmitter |
| cross-cutting request logic | Middleware |
| ठूलो data सुरक्षित रूपमा process गर्ने | Streams / pipeline |
| testable, decoupled dependencies | Dependency Injection |

## यो किन महत्त्वपूर्ण छ

Patterns एउटा साझा शब्दावली हो: "config एउटा module-cached singleton हो" वा "auth एउटा middleware हो" भन्नुले केही शब्दमै एउटा design सम्प्रेषण गर्छ। Node को आफ्नै core (EventEmitter, streams, module system) यिनैबाट बनेको छ, त्यसैले तिनलाई चिन्नुले तपाईंलाई frameworks पढ्न र आफ्नै services संरचना गर्न मद्दत गर्छ। अन्तर्वार्ताकारहरूले यो प्रश्न प्रयोग गर्छन् कि तपाईं callbacks लाई मनपरी जोड्ने मात्र होइन, तर मिल्दो pattern तर्फ पुग्नुहुन्छ — र यसको trade-offs थाहा पाउनुहुन्छ, जस्तै singleton ले global state लाई test गर्न गाह्रो बनाउँछ।

आवश्यकता	Pattern
एउटा साझा resource	Singleton (module cache)
objects बनाउने, `new` लुकाउने	Factory
async events मा प्रतिक्रिया दिने	Observer / EventEmitter
cross-cutting request logic	Middleware
ठूलो data सुरक्षित रूपमा process गर्ने	Streams / pipeline
testable, decoupled dependencies	Dependency Injection

सिर्जनात्मक (Creational)

व्यवहारगत (Behavioral)

संरचनात्मक (Structural)

अनुमानको नियम

यो किन महत्त्वपूर्ण छ

सम्बन्धित प्रश्नहरू