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

પ્રોમિસ ભવિષ્યની કિંમતનું પ્રતિનિધિત્વ કરે છે; `.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/તૃતીયક માં હજી સામાન્ય), Promises (સાંકળવાલા), અને async/await (વાંચનીય, ડિફોલ્ટ) — તમને કોઈપણ codebase વાંચવા અને સ્વચ્છ asynchronous તર્ક લખવાની તક આપે છે।

જાણવું કે તેઓ તમામ તળિયે સમાન event-loop મિકેનિজમ છે, અને `Promise.all` સાથે સ્વતંત્ર ક્રિયાલાપોને સમાંતર કરવાનું યાદ રાખવું, સાચો અને કાર્યક્ષમ asynchronous Node કોડ માટે ચાવી છે।