Node.js‌లో సాధారణ design patterns ఏమిటి?

Question

IT Interview Practice · Accepted Answer

Node.js తన module system, async model మరియు streaming I/O‌కు సరిపోయే కొన్ని design patterns‌పై ఆధారపడుతుంది. ప్రతి 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** — objects‌ను సృష్టించి తిరిగి ఇచ్చే ఒక function, 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** — ప్రతి ఒక్కటి `(ctx, next)`‌ను స్వీకరించే functions‌ల pipeline, Express/Koa ద్వారా ప్రాచుర్యం పొందింది. క్రాస్-కటింగ్ 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 చేయడానికి బదులు, backpressure‌తో data‌ను క్రమంగా ప్రాసెస్ చేయడానికి readable → transform → writable stages‌ను కూర్చండి.

```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‌లోకి పంపండి; code‌ను testable మరియు decoupled చేస్తుంది. **NestJS** వంటి frameworks DI‌ను అంతర్నిర్మితంగా కలిగి ఉంటాయి; constructor/function arguments ద్వారా మీరే చేతితో కూడా చేయవచ్చు.

## బొటనవేలు నియమం

| అవసరం | Pattern |
|---|---|
| ఒక భాగస్వామ్య resource | Singleton (module cache) |
| Objects నిర్మించు, `new`‌ను దాచు | Factory |
| Async events‌కు స్పందించు | Observer / EventEmitter |
| క్రాస్-కటింగ్ request logic | Middleware |
| పెద్ద data‌ను సురక్షితంగా ప్రాసెస్ చేయి | Streams / pipeline |
| Testable, decoupled dependencies | Dependency Injection |

## ఇది ఎందుకు ముఖ్యం

Patterns ఒక భాగస్వామ్య పదజాలం: "config అనేది module-cache చేయబడిన singleton" లేదా "auth అనేది middleware" అని చెప్పడం ఒక design‌ను కొన్ని పదాల్లో తెలియజేస్తుంది. Node యొక్క సొంత core (EventEmitter, streams, module system) వీటి నుండి నిర్మించబడింది, కాబట్టి వాటిని గుర్తించడం frameworks‌ను చదవడానికి మరియు మీ సొంత services‌ను నిర్మించడానికి సహాయపడుతుంది. మీరు కేవలం callbacks‌ను యాదృచ్ఛికంగా వైర్ చేయడం కాకుండా, సరిపోయే pattern‌ను చేరుకుంటారా — మరియు singleton global state‌ను test చేయడం కష్టతరం చేయడం వంటి దాని trade-offs‌ను తెలుసుకుంటారా అని తనిఖీ చేయడానికి interviewers ఈ ప్రశ్నను ఉపయోగిస్తారు.

అవసరం	Pattern
ఒక భాగస్వామ్య resource	Singleton (module cache)
Objects నిర్మించు, `new`‌ను దాచు	Factory
Async events‌కు స్పందించు	Observer / EventEmitter
క్రాస్-కటింగ్ request logic	Middleware
పెద్ద data‌ను సురక్షితంగా ప్రాసెస్ చేయి	Streams / pipeline
Testable, decoupled dependencies	Dependency Injection

Creational

Behavioral

Structural

బొటనవేలు నియమం

ఇది ఎందుకు ముఖ్యం

సంబంధిత ప్రశ్నలు