Linganisha callbacks, Promises na async/await.

Question

Accepted Answer

Hizi ni kizazi tatu cha kushughulikia operesheni za **asinkronous** katika Node — kila moja ikiboresha usomekaji ukilinganisha na iliyotangulia, lakini zote zikijengwa kwenye msingi sawa wa event-loop.

## 1. Callbacks — ya asl (na "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);
    });
  });
});
```

Konvensho ya Node ni **error-first callbacks** (`(err, result)`). Zinafanya kazi lakini zina kina kirefu na kushambuliana kwa matangazo ya hitilafu — vigumu kusoma na kusambaza.

## 2. Promises — zinazounganishwa, nyinyi

```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 inawakilisha thamani ya baadaye; `.then` inaambatanisha hatua na `.catch` inashughulikia kosa lolote katika mlolongo — nyinyi zaidi kuliko callbacks zilizosimbwa.

## 3. async/await — inaonekana sinkronous (kiwango cha kisasa)

```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` ni sukari ya sintaksi juu ya Promises — inasomwa juu hadi chini kama code ya sinkronous, inatumia `try/catch` ya kawaida, na ni mtindo wa kisasa uliotajwa.

## Usisambaze kazi huru

```js
// ❌ sequential — slow
const a = await getA(); const b = await getB();
// ✅ parallel — both at once
const [a, b] = await Promise.all([getA(), getB()]);
```

## Uhusiano

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

## Kwa nini inasumbuku

Kushughulikia asinkronous ni rahisi katika Node (I/O zote ni asinkronous).

Kufahamu mwendelezo — error-first callbacks (bado ya kawaida katika API za zamani/maktaba), Promises (zinazounganishwa) na async/await (inasomwa vizuri, kiwango) — hukuruhusu kusoma msingi wowote wa kod na kuandika mantiki safi ya asinkronous.

Kujua kwamba zote ni mitambo sawa ya event-loop chini, na kukumbuka kusambaza kazi huru kwa `Promise.all`, ni muhimu kwa code sahihi na yenye utendaji wa asinkronous katika Node.