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 संगठन की नींव।
- **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** — किसी third-party API को अपने interface में लपेटें ताकि आप call sites को छुए बिना vendors बदल सकें।
- **Streams (pipeline)** — सब कुछ memory में buffer करने के बजाय readable → transform → writable stages को जोड़कर data को backpressure के साथ क्रमिक रूप से 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 built-in होता है; आप इसे constructor/function arguments के ज़रिए हाथ से भी कर सकते हैं।

## अंगूठे का नियम

| ज़रूरत | Pattern |
|---|---|
| एक shared 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
एक shared 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)

अंगूठे का नियम

यह क्यों महत्वपूर्ण है

संबंधित प्रश्न