Comparez les callbacks, les Promises et async/await.

Question

IT Interview Practice · Accepted Answer

Ce sont trois générations de gestion des opérations **asynchrones** dans Node — chacune améliorant la lisibilité par rapport à la précédente, mais toutes construites sur la même base de boucle d'événements.

## 1. Callbacks — l'original (et l'« enfer des callbacks »)

```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 convention de Node est les **callbacks d'erreur-d'abord** (`(err, result)`). Ils fonctionnent mais s'imbriquent profondément et dispersent la gestion des erreurs — difficiles à lire et à maintenir.

## 2. Promises — chaînables, plus plates

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

Une Promise représente une valeur future ; `.then` chaîne les étapes et `.catch` gère toute erreur dans la chaîne — plus plate que les callbacks imbriqués.

## 3. async/await — d'apparence synchrone (le standard moderne)

```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` est du sucre syntaxique sur les Promises — cela se lit de haut en bas comme du code synchrone, utilise `try/catch` ordinaire, et est le style moderne recommandé.

## Ne sérialisez pas les travaux indépendants

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

## La relation

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

## Pourquoi c'est important

La gestion asynchrone est inévitable dans Node (tous les I/O sont asynchrones).

Comprendre la progression — callbacks d'erreur-d'abord (toujours courants dans les anciennes API/bibliothèques), Promises (chaînables), et async/await (lisible, le standard) — vous permet de lire n'importe quelle base de code et d'écrire une logique asynchrone propre.

Savoir qu'elles sont toutes le même mécanisme de boucle d'événements en dessous, et se rappeler de paralléliser les opérations indépendantes avec `Promise.all`, est la clé d'un code asynchrone Node correct et performant.

1. Callbacks — l'original (et l'« enfer des callbacks »)

2. Promises — chaînables, plus plates

3. async/await — d'apparence synchrone (le standard moderne)

Ne sérialisez pas les travaux indépendants

La relation

Pourquoi c'est important

Questions connexes