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 |
|---|---|
| एक 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 ची testing अधिक कठीण करते.

गरज	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)

ठोकताळा

हे का महत्त्वाचे आहे

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