Palyginkite callback'us, Promise'us ir async/await.

Question

IT Interview Practice · Accepted Answer

Tai yra trys **asinchroninių** operacijų apdorojimo kartos Node.js — kiekviena gerina skaitomumą, palyginti su ankstesne, tačiau visos kuriamos toje pačioje event-loop pagrindu.

## 1. Callback'ai — originalas (ir "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 konvencija yra **error-first callback'ai** (`(err, result)`). Jie veikia, bet giliai įdėti ir išsklaidyti klaidų tvarkymas — sunkiai skaitomi ir prižiūrimi.

## 2. Promise'ai — sujungiami, plokštesni

```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 reiškia būsimą vertę; `.then` sujungia žingsnius, o `.catch` tvarkoma bet kuri klaida grandinėje — plokštesnė nei įdėti callback'ai.

## 3. async/await — sinchroninio stiliaus (šiuolaikinis standartinis)

```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` yra sintaksinis cukrus virš Promise'ų — jis skaitomas iš viršaus į apačią kaip sinchroninis kodas, naudoja paprastą `try/catch` ir yra rekomenduojamas šiuolaikinis stilius.

## Neserializuokite nepriklausomo darbo

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

## Santykis

```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.
```

## Kodėl tai svarbu

Asinchroninis tvarkymas yra neišvengiamas Node.js (visa I/O yra asinchrona).

Supratę progresą — error-first callback'ų (vis dar paplitę senesniuose API/bibliotekose), Promise'ų (sujungiami) ir async/await (skaitomi, standartiniai) — galite skaityti bet kokią kodų bazę ir rašyti švarius asinchroninius logika.

Žinodami, kad tai visi tie patys event-loop mechanizmo pagrindai ir nepamiršdami paralelizuoti nepriklausomas operacijas su `Promise.all`, tai yra raktas į teisingą ir produktyvų asinchroninį Node.js kodą.

1. Callback'ai — originalas (ir "callback hell")

2. Promise'ai — sujungiami, plokštesni

3. async/await — sinchroninio stiliaus (šiuolaikinis standartinis)

Neserializuokite nepriklausomo darbo

Santykis

Kodėl tai svarbu

Susiję klausimai