callbacks, Promises మరియు async/await లను సరిపోల్చండి.

Question

Accepted Answer

ఇవి Node లో **asynchronous** operations లను నిర్వహించడానికి మూడు తరాలు — ప్రతి ఒకటి చివరి కంటే పఠనీయతను మెరుగుపరుస్తుంది, కానీ అన్నీ ఒకే 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)`). ఇవి పనిచేస్తాయి కానీ లోతుగా నిలువబడతాయి మరియు error handling చెదరుతుంది — చదవడానికి మరియు నిర్వహించడానికి కష్టం.

## 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` చైనులో ఏదైనా error ని నిర్వహిస్తుంది — nested callbacks కంటే ఫ్లాటర్.

## 3. async/await — synchronous-looking (ఆధునిక డిఫాల్ట్)

```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 పై syntactic sugar — ఇది top-to-bottom లాగా sync code లా చదువుతుంది, సాధారణ `try/catch` ని ఉపయోగిస్తుంది, మరియు ఇది సిఫారసు చేసిన ఆధునిక శైలి.

## స్వతంత్ర కార్యాన్ని serialization చేయవద్దు

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

## ఇది ఎందుకు ముఖ్యమైనది

Async handling Node లో ఎటువంటి రకంగా ఉంటుంది (అన్ని I/O అసమకాలీనం).

ప్రগతిని అర్థం చేసుకోవడం — error-first callbacks (పాతైన APIs/libraries లలో ఇప్పటికీ సాధారణం), Promises (చైనేబుల్), మరియు async/await (పఠనీయ, డిఫాల్ట్) — ఏదైనా codebase చదవడానికి మరియు clean async logic రాయడానికి నిన్ను అనుమతిస్తుంది.

వాటన్నీ కింద ఒకే event-loop మెకానిజమ్ అని తెలుసుకోవడం, మరియు `Promise.all` తో స్వతంత్ర operations లను parallelize చేయడం గుర్తుంచుకోవడం, సరైన మరియు performant async Node code కీలకమైనది.