Confronta callback, Promises e async/await.

Question

Accepted Answer

Queste sono tre generazioni di gestione delle operazioni **asincrone** in Node — ognuna migliora la leggibilità rispetto alla precedente, ma tutte costruite sulla stessa base event-loop.

## 1. Callback — l'originale (e "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);
    });
  });
});
```

La convenzione di Node è **callback error-first** (`(err, result)`). Funzionano ma si annidano profondamente e disperdono la gestione degli errori — difficili da leggere e mantenere.

## 2. Promise — concatenabili, più piatte

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

Una Promise rappresenta un valore futuro; `.then` concatena i passaggi e `.catch` gestisce qualsiasi errore nella catena — più piatte dei callback annidati.

## 3. async/await — simile al codice sincrono (lo standard moderno)

```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` è zucchero sintattico su Promises — si legge dall'alto verso il basso come codice sincrono, usa ordinari `try/catch`, ed è lo stile moderno consigliato.

## Non serializzare lavori indipendenti

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

## La relazione

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

## Perché è importante

La gestione asincrona è inevitabile in Node (tutti gli I/O sono asincroni).

Comprendere la progressione — callback error-first (ancora comuni nelle API/librerie vecchie), Promises (concatenabili), e async/await (leggibili, lo standard) — ti permette di leggere qualsiasi codebase e scrivere logica asincrona pulita.

Sapere che sono tutti lo stesso meccanismo event-loop sottostante, e ricordare di parallelizzare le operazioni indipendenti con `Promise.all`, è fondamentale per codice async Node corretto e performante.