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 मा syntactic sugar हो — यो माथि-देखि-तलसम्म सिंक्रोनस कोड जस्तै पढिन्छ, सामान्य `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.
```

## किन यो महत्त्वपूर्ण छ

Async हैन्डलिङ Node मा अपरिहार्य छ (सबै I/O async हो)।

प्रगति बुझ्नु — error-first callbacks (पुरानो APIs/libraries मा अझै सामान्य), Promises (चेनेबल), र async/await (पठनीय, डिफल्ट) — तपाइंलाई कुनै पनि codebase पढ्न र स्वच्छ async logic लेख्न दिन्छ।

जान्नु कि यो सबै समान event-loop मेकानिज्म हो भित्तरको र `Promise.all` सँग स्वतन्त्र अपरेशन समानान्तर गर्न बिर्सनु नहोस्, यो सही र प्रभावकारी async Node code को कुञ्जी हो।