რომელია გავრცელებული დიზაინის შაბლონები Node.js-ში?

Question

IT Interview Practice · Accepted Answer

Node.js ეყრდნობა რამდენიმე დიზაინის შაბლონს, რომლებიც შეესაბამება მის მოდულების სისტემას, ასინქრონულ მოდელს და streaming I/O-ს. ყველაზე გავრცელებული, რომლებიც ყველა backend დეველოპერმა უნდა იცნობდეს:

## შემქმნელი (Creational)

- **Module pattern** — თითოეული ფაილი საკუთარი scope-ია; საჯარო API-ს ავლენთ `module.exports` / `export`-ის მეშვეობით, შიდა ნაწილებს კი პრივატულად ინახავთ. Node-ში კოდის ორგანიზების საფუძველი.
- **Singleton** — მოდულის ექსპორტები **ქეშირდება**, ამიტომ ინსტანსის ექსპორტი ყველა იმპორტიორს ერთსა და იმავე ობიექტს აძლევს. იდეალურია DB pool-ისთვის ან კონფიგისთვის.

```js
// db.js — ყოველი `require("./db")` იღებს ამავე pool-ს (singleton module cache-ის მეშვეობით).
const pool = createPool(process.env.DATABASE_URL);
module.exports = pool;
```

- **Factory** — ფუნქცია, რომელიც ქმნის და აბრუნებს ობიექტებს, მალავს კონსტრუქციის ლოგიკას და საშუალებას გაძლევთ შეცვალოთ იმპლემენტაციები.

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

## ქცევითი (Behavioral)

- **Observer / EventEmitter** — Node-ის ძირითადი ასინქრონული შაბლონი: emit-ავთ დასახელებულ event-ებს, ამაგრებთ listener-ებს. `EventEmitter`, stream-ები და core მოდულების უმეტესობა იყენებს მას.

```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-ს მიერ. შესანიშნავია განივი საკითხებისთვის (auth, logging, ვალიდაცია).

```js
app.use((req, res, next) => { req.startedAt = Date.now(); next(); });
```

- **Strategy** — ალგორითმის არჩევა runtime-ზე (მაგ. გადახდის პროვაიდერის ან hashing სტრატეგიის არჩევა ერთი interface-ის მიღმა).

## სტრუქტურული (Structural)

- **Adapter** — შეფუთეთ მესამე მხარის API თქვენს საკუთარ interface-ში, რომ შეძლოთ ვენდორების შეცვლა გამოძახების ადგილებზე ხელის შეხების გარეშე.
- **Streams (pipeline)** — შეადგინეთ readable → transform → writable ეტაპები მონაცემების ეტაპობრივად დასამუშავებლად backpressure-ით, ნაცვლად იმისა, რომ ყველაფერი მეხსიერებაში დაბუფერდეს.

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

- **Dependency Injection** — გადაეცით თანამშრომლები (db, logger, კლიენტები) მოდულს პირდაპირ იმპორტის ნაცვლად; ეს კოდს testable-ს და decoupled-ს ხდის. ისეთი ფრეიმვორკები, როგორიცაა **NestJS**, DI-ს ჩაშენებულად აქვთ; ამის გაკეთება ხელითაც შეგიძლიათ constructor/ფუნქციის არგუმენტების მეშვეობით.

## ცერა თითის წესი

| საჭიროება | შაბლონი |
|---|---|
| ერთი გაზიარებული რესურსი | Singleton (module cache) |
| ობიექტების აგება, `new`-ის დამალვა | Factory |
| ასინქრონულ event-ებზე რეაგირება | Observer / EventEmitter |
| განივი request ლოგიკა | Middleware |
| დიდი მონაცემების უსაფრთხოდ დამუშავება | Streams / pipeline |
| testable, decoupled დამოკიდებულებები | Dependency Injection |

## რატომ არის ეს მნიშვნელოვანი

შაბლონები არის საერთო ლექსიკა: თქმა „კონფიგი არის module-cache-ირებული singleton“ ან „auth არის middleware“ ორიოდე სიტყვით გადმოსცემს დიზაინს. Node-ის საკუთარი core (EventEmitter, stream-ები, მოდულების სისტემა) სწორედ ამათგან არის აგებული, ამიტომ მათი ამოცნობა გეხმარებათ ფრეიმვორკების წაკითხვასა და საკუთარი სერვისების სტრუქტურირებაში. ინტერვიუერები ამ კითხვას იყენებენ იმის შესამოწმებლად, რომ თქვენ არა უბრალოდ ad hoc აკავშირებთ callback-ებს, არამედ მიმართავთ იმ შაბლონს, რომელიც შეესაბამება — და იცნობთ მის კომპრომისებს, მაგალითად, რომ singleton გლობალურ მდგომარეობას უფრო ძნელად სატესტოს ხდის.

საჭიროება	შაბლონი
ერთი გაზიარებული რესურსი	Singleton (module cache)
ობიექტების აგება, `new`-ის დამალვა	Factory
ასინქრონულ event-ებზე რეაგირება	Observer / EventEmitter
განივი request ლოგიკა	Middleware
დიდი მონაცემების უსაფრთხოდ დამუშავება	Streams / pipeline
testable, decoupled დამოკიდებულებები	Dependency Injection

შემქმნელი (Creational)

ქცევითი (Behavioral)

სტრუქტურული (Structural)

ცერა თითის წესი

რატომ არის ეს მნიშვნელოვანი

დაკავშირებული კითხვები