Formations — 1 037 leçons en français

Accueil › JavaScript › Les pièges d'await

Les pièges d'await

async/await et fetchintermediaire

Piège 1 — la sérialisation accidentelle

// ❌ 3 secondes
const a = await lireA();
const b = await lireB();
const c = await lireC();

// ✅ 1 seconde
const [a, b, c] = await Promise.all([lireA(), lireB(), lireC()]);

Si b n'a pas besoin de a, les faire attendre l'un l'autre est du temps perdu. Le code ne porte aucun signe visible du problème — c'est pourquoi il survit si longtemps.

Piège 2 — forEach avec async

// ❌ « terminé » s'affiche avant les traitements
ids.forEach(async (id) => { await traiter(id); });
console.log("terminé");

// ✅ en parallèle
await Promise.all(ids.map((id) => traiter(id)));

// ✅ en série, si l'ordre compte
for (const id of ids) await traiter(id);

forEach jette la valeur de retour de son rappel. La boucle se termine immédiatement, et les traitements continuent sans surveillance — y compris leurs erreurs.

Piège 3 — l'état qui change pendant l'attente

// ❌ un second clic peut entrer avant que le verrou soit posé
if (!envoiEnCours) {
  const donnees = await preparer();
  envoiEnCours = true;
  await envoyer(donnees);
}

// ✅ verrou posé AVANT le premier await
if (envoiEnCours) return;
envoiEnCours = true;
try {
  await envoyer(await preparer());
} finally {
  envoiEnCours = false;
}

Pendant un await, la fonction est suspendue et le moteur exécute autre chose. Le fil unique n'empêche pas les entrelacements.

Les termes à connaître

Sérialisation accidentelle

Des await successifs sur des opérations indépendantes. Elles se font l'une après l'autre alors qu'elles pouvaient partir ensemble.

forEach asynchrone

forEach ignore la promesse que son rappel rend : la boucle se termine avant les traitements. L'erreur asynchrone la plus répandue.

for...of avec await

La seule boucle qui attend réellement chaque tour. À choisir quand l'ordre compte, ou pour limiter la charge.

map + Promise.all

Le couple à utiliser quand les traitements sont indépendants : await Promise.all(t.map(async …)).

await dans une condition

Un await à l'intérieur d'un if ou d'une boucle suspend la fonction à cet endroit précis. L'état lu avant peut avoir changé après.

Lire l'explication détaillée et faire le quiz →

Cette page présente la partie essentielle de la leçon. Les exemples commentés, les pièges courants et les trois questions de quiz sont dans l'application.