callbacks, Promises और async/await की तुलना करें।

Question

Accepted Answer

ये Node में **asynchronous** operations को संभालने की तीन पीढ़ियां हैं — प्रत्येक पिछले की तुलना में पठनीयता में सुधार करती है, लेकिन सभी एक ही event-loop foundation पर बनी हैं।

## 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 को बिखेरते हैं — पढ़ने और maintain करने में मुश्किल।

## 2. Promises — chainable, flatter

```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 एक भविष्य के value का प्रतिनिधित्व करता है; `.then` चरणों को chain करता है और `.catch` chain में किसी भी error को संभालता है — nested callbacks से flatter।

## 3. async/await — synchronous-looking (आधुनिक default)

```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` का उपयोग करता है, और recommended आधुनिक style है।

## स्वतंत्र कार्य को serialize न करें

```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 async हैं)।

प्रगति को समझना — error-first callbacks (अभी भी पुराने APIs/libraries में सामान्य), Promises (chainable), और async/await (readable, default) — आपको किसी भी codebase को पढ़ने और clean async logic लिखने देता है।

यह जानना कि वे सभी नीचे एक ही event-loop mechanism हैं, और `Promise.all` के साथ independent operations को parallelize करने को याद रखना, सही और performant async Node code के लिए महत्वपूर्ण है।