Node.js ਵਿੱਚ ਆਮ design pattern ਕਿਹੜੇ ਹਨ?

Question

IT Interview Practice · Accepted Answer

Node.js ਕੁਝ ਗਿਣੇ-ਚੁਣੇ design pattern 'ਤੇ ਟੇਕ ਰੱਖਦਾ ਹੈ ਜੋ ਇਸ ਦੇ module system, async ਮਾਡਲ, ਅਤੇ streaming I/O ਨਾਲ ਫਿੱਟ ਬੈਠਦੇ ਹਨ। ਸਭ ਤੋਂ ਆਮ ਪੈਟਰਨ ਜੋ ਹਰ backend ਡਿਵੈਲਪਰ ਨੂੰ ਪਛਾਣਨੇ ਚਾਹੀਦੇ ਹਨ:

## Creational (ਸਿਰਜਣਾਤਮਕ)

- **Module pattern** — ਹਰ file ਦਾ ਆਪਣਾ scope ਹੁੰਦਾ ਹੈ; ਤੁਸੀਂ `module.exports` / `export` ਰਾਹੀਂ ਇੱਕ ਪਬਲਿਕ 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** — ਇੱਕ ਫੰਕਸ਼ਨ ਜੋ object ਬਣਾ ਕੇ ਵਾਪਸ ਕਰਦਾ ਹੈ, construction logic ਨੂੰ ਲੁਕਾਉਂਦਾ ਹੈ ਅਤੇ ਤੁਹਾਨੂੰ implementations ਬਦਲਣ ਦਿੰਦਾ ਹੈ।

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

## Behavioral (ਵਿਵਹਾਰਕ)

- **Observer / EventEmitter** — Node ਦਾ ਮੂਲ async pattern: ਨਾਮ ਵਾਲੇ event emit ਕਰੋ, listener ਜੋੜੋ। `EventEmitter`, streams, ਅਤੇ ਜ਼ਿਆਦਾਤਰ core module ਇਸ ਨੂੰ ਵਰਤਦੇ ਹਨ।

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

- **Middleware** — ਫੰਕਸ਼ਨਾਂ ਦੀ ਇੱਕ pipeline, ਹਰ ਇੱਕ `(ctx, next)` ਲੈਂਦੀ ਹੈ, Express/Koa ਨੇ ਪ੍ਰਸਿੱਧ ਕੀਤੀ। cross-cutting ਚਿੰਤਾਵਾਂ (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 ਨੂੰ ਛੂਹੇ ਬਿਨਾਂ vendor ਬਦਲ ਸਕੋ।
- **Streams (pipeline)** — ਸਾਰਾ ਕੁਝ memory ਵਿੱਚ buffer ਕਰਨ ਦੀ ਬਜਾਏ, ਡਾਟੇ ਨੂੰ backpressure ਨਾਲ ਹੌਲੀ-ਹੌਲੀ ਪ੍ਰੋਸੈਸ ਕਰਨ ਲਈ readable → transform → writable stage ਨੂੰ ਜੋੜੋ।

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

- **Dependency Injection** — collaborator (db, logger, clients) ਨੂੰ ਸਿੱਧਾ import ਕਰਨ ਦੀ ਬਜਾਏ module ਵਿੱਚ ਪਾਸ ਕਰੋ; ਇਹ code ਨੂੰ testable ਅਤੇ decoupled ਬਣਾਉਂਦਾ ਹੈ। **NestJS** ਵਰਗੇ framework DI ਨੂੰ ਅੰਦਰ ਹੀ ਬਣਾਉਂਦੇ ਹਨ; ਤੁਸੀਂ ਇਸ ਨੂੰ constructor/function argument ਰਾਹੀਂ ਹੱਥੀਂ ਵੀ ਕਰ ਸਕਦੇ ਹੋ।

## ਅੰਗੂਠੇ ਦਾ ਨਿਯਮ

| ਲੋੜ | Pattern |
|---|---|
| ਇੱਕ ਸਾਂਝਾ ਸਰੋਤ | Singleton (module cache) |
| Object ਬਣਾਓ, `new` ਲੁਕਾਓ | Factory |
| async event 'ਤੇ ਪ੍ਰਤੀਕਿਰਿਆ | Observer / EventEmitter |
| Cross-cutting request logic | Middleware |
| ਵੱਡਾ ਡਾਟਾ ਸੁਰੱਖਿਅਤ ਢੰਗ ਨਾਲ ਪ੍ਰੋਸੈਸ | Streams / pipeline |
| Testable, decoupled dependency | Dependency Injection |

## ਇਹ ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹੈ

Pattern ਇੱਕ ਸਾਂਝੀ ਸ਼ਬਦਾਵਲੀ ਹਨ: "config ਇੱਕ module-cached singleton ਹੈ" ਜਾਂ "auth middleware ਹੈ" ਕਹਿਣਾ ਕੁਝ ਸ਼ਬਦਾਂ ਵਿੱਚ ਇੱਕ ਡਿਜ਼ਾਈਨ ਦੱਸ ਦਿੰਦਾ ਹੈ। Node ਦਾ ਆਪਣਾ core (EventEmitter, streams, module system) ਇਹਨਾਂ ਤੋਂ ਹੀ ਬਣਿਆ ਹੈ, ਇਸ ਲਈ ਇਹਨਾਂ ਨੂੰ ਪਛਾਣਨਾ ਤੁਹਾਨੂੰ framework ਪੜ੍ਹਨ ਅਤੇ ਆਪਣੀਆਂ service ਦੀ ਸੰਰਚਨਾ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ। Interviewer ਇਹ ਸਵਾਲ ਇਹ ਜਾਂਚਣ ਲਈ ਵਰਤਦੇ ਹਨ ਕਿ ਤੁਸੀਂ ਸਿਰਫ਼ callback ਬੇਤਰਤੀਬ ਨਹੀਂ ਜੋੜਦੇ, ਸਗੋਂ ਫਿੱਟ ਬੈਠਣ ਵਾਲਾ pattern ਚੁਣਦੇ ਹੋ — ਅਤੇ ਇਸ ਦੇ trade-off ਜਾਣਦੇ ਹੋ, ਜਿਵੇਂ ਕਿ singleton global state ਨੂੰ test ਕਰਨਾ ਔਖਾ ਬਣਾ ਦਿੰਦਾ ਹੈ।

ਲੋੜ	Pattern
ਇੱਕ ਸਾਂਝਾ ਸਰੋਤ	Singleton (module cache)
Object ਬਣਾਓ, `new` ਲੁਕਾਓ	Factory
async event 'ਤੇ ਪ੍ਰਤੀਕਿਰਿਆ	Observer / EventEmitter
Cross-cutting request logic	Middleware
ਵੱਡਾ ਡਾਟਾ ਸੁਰੱਖਿਅਤ ਢੰਗ ਨਾਲ ਪ੍ਰੋਸੈਸ	Streams / pipeline
Testable, decoupled dependency	Dependency Injection

Creational (ਸਿਰਜਣਾਤਮਕ)

Behavioral (ਵਿਵਹਾਰਕ)

Structural (ਸੰਰਚਨਾਤਮਕ)

ਅੰਗੂਠੇ ਦਾ ਨਿਯਮ

ਇਹ ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹੈ

ਸੰਬੰਧਿਤ ਸਵਾਲ