Kompara callbacks, Promises u async/await.

Question

Accepted Answer

Dawn huma tliet ġenerazzjonijiet ta' tindwil ta' operazzjonijiet **asynchronous** f'Node — kull wieħed itejjeb il-leggibilità meta mqabla mal-preċedenti, iżda kollha mibnija fuq l-istess fondazzjoni event-loop.

## 1. Callbacks — l-oriġinali (u "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);
    });
  });
});
```

Il-konvenzjoni ta' Node hija **error-first callbacks** (`(err, result)`). Jaħdmu iżda jiġu miQgħadda ġonwa u t-tindwil ta' ħtieġa mitqarreb — diffiċli biex tinqara u tiẓguża.

## 2. Promises — chain-ableï, aktar ħafif

```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 jirrappreżenta valur futur; `.then` iqabbad l-passi u `.catch` jittratta kull żball fil-katina — aktar ħafif minn callbacks miQgħadda.

## 3. async/await — ħarsa sinkrinika (il-default modern)

```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` hija sukru sintattwu fuq il-Promises — tinqara minn fuq għal taħt bħal kodiċi sinkrinu, tuża `try/catch` ordinarja, u hija l-istil modern irrakomandat.

## Tħallix tisserijjalizza xogħol indipendenti

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

## Ir-relazzjoni

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

## Għaliex huwa importanti

It-tindwil asinkrinu huwa inevitabbli f'Node (l-I/O kollu huwa asinkrinu).

Fi tiegħek għall-progress — error-first callbacks (aktar komuni fl-APIs/libraries aktar qodma), Promises (chain-able), u async/await (leggibli, default) — jippermettilek taqra kull kodiċi-base u tikteb loġika asinkrinya nadifa.

Li taf li huma kollha l-istess mekkaniżmu event-loop taħt, u tiftakar li tgħaqqad operazzjonijiet indipendenti b'parallel ma' `Promise.all`, huwa l-muftieħ għal kodiċi Node asinkrinu korrett u performanti.