შეადარეთ callbacks, Promises და async/await.

Question

IT Interview Practice · Accepted Answer

ეს არის **ასინქრონული** ოპერაციების დამუშავების სამი თაობა Node-ში — თითოეული აუმჯობესებს წაკითხვადობას წინას შედარებით, მაგრამ ყველა აგებულია ერთი და იგივე event-loop საფუძველზე.

## 1. Callbacks — ორიგინალური (და "callback hell")

```js
fs.readFile("a.txt", (err, a) => {
  if (err) return handle(err);            // error-first callback convention
  fs.readFile("b.txt", (err, b) => {       // nesting deepens with each step...
    if (err) return handle(err);
    db.save(a + b, (err) => {              // "pyramid of doom"
      if (err) return handle(err);
    });
  });
});
```

Node-ის კონვენცია არის **error-first callbacks** (`(err, result)`). ისინი მუშაობენ მაგრამ ღრმად ჩასახლებულია და ფხვნელდება შეცდომის დამუშავება — ძნელია წაკითხვა და შენარჩუნება.

## 2. Promises — ჯაჭვებული, უფრო ბრტყელი

```js
readFile("a.txt")
  .then(a => readFile("b.txt").then(b => a + b)) // return a promise → chain waits
  .then(combined => db.save(combined))
  .catch(handle);                                 // ONE place for all errors
```

Promise წარმოადგენს მომავალი მნიშვნელობას; `.then` აკავშირებს ნაბიჯებს და `.catch` აგვარებს ნებისმიერ შეცდომას ჯაჭვში — უფრო ბრტყელი, ვიდრე ჩასახლებული callbacks.

## 3. async/await — სინქრონული გარეგნობა (თანამედროვე ნაგულისხმევი)

```js
async function combine() {
  try {
    const a = await readFile("a.txt");   // pause until resolved
    const b = await readFile("b.txt");
    await db.save(a + b);
  } catch (err) {
    handle(err);                          // normal try/catch works
  }
}
```

`async/await` არის სინტაქსური შაქარი Promises-ზე — იკითხება ზემოდან ქვემოთ სინქრონული კოდის მსგავსად, იყენებს ჩვეულებრივ `try/catch`, და არის რეკომენდებული თანამედროვე სტილი.

## არ სერიალიზოთ დამოუკიდებელი სამუშაო

```js
// ❌ sequential — slow
const a = await getA(); const b = await getB();
// ✅ parallel — both at once
const [a, b] = await Promise.all([getA(), getB()]);
```

## ურთიერთობა

```text
Callbacks → Promises → async/await
All use the event loop. Promises wrap callbacks; async/await wraps Promises.
Modern code: async/await, with Promise.all to parallelize independent ops.
```

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

ასინქრონული დამუშავება გამოუცვლელია Node-ში (ყველა I/O ასინქრონულია).

Progress-ის გაგება — error-first callbacks (ჯერ კიდევ გავრცელებული ძველ API/ბიბლიოთეკებში), Promises (ჯაჭვებული), და async/await (წაკითხვადი, ნაგულისხმევი) — საშუალებას გაძლევთ წაიკითხოთ ნებისმიერი კოდბეზა და დაწეროთ სუფთა ასინქრონული ლოგიკა.

ცოდნა იმის შესახებ, რომ ისინი ყველა ერთი და იგივე event-loop მექანიზმია ქვემოთ, და დაიმახსოვროთ დამოუკიდებელი ოპერაციების `Promise.all`-თან პარალელიზაცია, მნიშვნელოვანია სწორი და productive-ი ასინქრონული Node კოდისთვის.

1. Callbacks — ორიგინალური (და "callback hell")

2. Promises — ჯაჭვებული, უფრო ბრტყელი

3. async/await — სინქრონული გარეგნობა (თანამედროვე ნაგულისხმევი)

არ სერიალიზოთ დამოუკიდებელი სამუშაო

ურთიერთობა

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

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