callbacks, Promises आणि async/await यांची तुलना करा.

Question

Accepted Answer

हे Node मध्ये **asynchronous** ऑपरेशन हाताळण्याच्या तीन पिढ्या आहेत — प्रत्येकजण मागीलच्या तुलनेत वाचनीयता सुधारते, परंतु सर्व समान 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)`). हे कार्य करतात परंतु खोलवर घोंसले आणि त्रुटी हाताळणी विखुरली — वाचन आणि राखणे कठीण.

## 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` साखळीतील कोणत्याही त्रुटीला हाताळते — घोंसलेल्या callbacks पेक्षा सपाट.

## 3. async/await — समकालीन दिसण्यासारखे (आधुनिक डिफॉल्ट)

```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 वर वाक्य रचना साखर आहे — हे शीर्ष-ते-तळ सिंक्रोनस कोड म्हणून वाचले जाते, सामान्य `try/catch` वापरते, आणि शिफारस केलेली आधुनिक शैली आहे.

## स्वतंत्र कार्य क्रमिक करू नका

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

## हे महत्वाचे का आहे

Asynchronous हाताळणी Node मध्ये अपरिहार्य आहे (सर्व I/O asynchronous आहे).

प्रगती समजून घेणे — error-first callbacks (जुन्या APIs/libraries मध्ये अजूनही सामान्य), Promises (साखळीयुक्त), आणि async/await (वाचनीय, डिफॉल्ट) — आपल्याला कोणताही कोडबेस वाचता आणि स्वच्छ async लॉजिक लिहिता येते.

ते सर्व एकच event-loop यंत्रणा आहेत असे जाणून, आणि `Promise.all` सह स्वतंत्र ऑपरेशन समांतर करायला विसरू नका, ही योग्य आणि कार्यक्षम async Node कोडची कळ आहे.