Callbacks، Promises اور async/await کا موازنہ کریں۔

Question

Accepted Answer

یہ Node میں **asynchronous** operations کو ہینڈل کرنے کی تین نسلیں ہیں — ہر ایک پچھلی کے مقابلے میں readability کو بہتر کرتی ہے، مگر سب ایک ہی 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 کا convention **error-first callbacks** ہے (`(err, result)`)۔ یہ کام تو کرتے ہیں مگر گہرائی تک nest ہوتے ہیں اور error handling کو بکھیر دیتے ہیں — پڑھنا اور maintain کرنا مشکل۔

## 2. Promises — chainable، زیادہ flat

```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` steps کو chain کرتا ہے اور `.catch` chain میں کسی بھی error کو ہینڈل کرتا ہے — nested callbacks سے زیادہ flat۔

## 3. async/await — synchronous نظر آنے والا (جدید 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 ہے — یہ sync code کی طرح اوپر سے نیچے پڑھا جاتا ہے، عام `try/catch` استعمال کرتا ہے، اور تجویز کردہ جدید 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.
```

## یہ کیوں اہم ہے

Node میں async handling سے بچا نہیں جا سکتا (تمام I/O async ہے)۔

اس ترتیب کو سمجھنا — error-first callbacks (پرانی APIs/libraries میں اب بھی عام)، Promises (chainable)، اور async/await (پڑھنے میں آسان، default) — آپ کو کسی بھی codebase کو پڑھنے اور صاف async logic لکھنے کے قابل بناتا ہے۔

یہ جاننا کہ نیچے یہ سب ایک ہی event-loop mechanism ہیں، اور آزاد operations کو `Promise.all` سے parallelize کرنا یاد رکھنا، درست اور performant async Node code کی کنجی ہے۔