Hasonlítsa össze a callback-eket, a Promise-okat és az async/await-et.

Question

Accepted Answer

Ezek három generációja az **aszinkron** műveletek kezelésének a Node-ban — mindegyik javítja az olvashatóságot az előzőhöz képest, de mindegyik ugyanazon az event-loop alapokon épül.

## 1. Callback-ek — az eredeti (és "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);
    });
  });
});
```

A Node konvenciója az **error-first callback-ek** (`(err, result)`). Működnek, de mélyen beágyazódnak és szétszórják a hibakezelést — nehéz olvasni és karbantartani.

## 2. Promise-ok — láncolható, laposabb

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

A Promise egy jövőbeli értéket képvisel; a `.then` összeláncol lépéseket és a `.catch` kezeli a lánc bármely hibáját — laposabb, mint a beágyazott callback-ek.

## 3. async/await — szinkron kinézet (a modern alapértelmezett)

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

Az `async/await` szintaktikus cukor a Promise-ok felett — felülről lefelé olvasható, mint szinkron kód, közönséges `try/catch` használ, és ez az ajánlott modern stílus.

## Ne szériázzon független munkát

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

## A kapcsolat

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

## Miért számít

Az aszinkron kezelés elkerülhetetlen a Node-ban (minden I/O aszinkron).

A progresszió megértése — error-first callback-ek (még mindig közönségesek a régebbi API-kban/könyvtárakban), Promise-ok (láncolható), és async/await (olvasható, az alapértelmezett) — lehetővé teszi bármilyen kódbázis olvasását és tiszta aszinkron logika írását.

Annak tudása, hogy mindegyik ugyanaz az event-loop mechanizmus alatt van, és az független műveletek `Promise.all` segítségével történő párhuzamosítása fontos a helyes és teljesítményes aszinkron Node kódhoz.