Formations — 1 037 leçons en français

Accueil › JavaScript › Les erreurs avec await

Les erreurs avec await

async/await et fetchintermediaire

Avec await, un rejet devient une exception ordinaire :

async function charger() {
  try {
    const reponse = await fetch("/api/clients");
    if (!reponse.ok) throw new Error(`HTTP ${reponse.status}`);
    return await reponse.json();
  } catch (erreur) {
    journaliser(erreur);
    throw erreur;          // l'appelant décide
  }
}

Un seul try couvre toutes les étapes, et le throw manuel se mêle naturellement aux rejets.

L'oubli qui coûte cher

// ❌ le try ne protège rien
try {
  sauvegarder();           // rend une promesse, ne lève pas
} catch { … }

// ✅
try {
  await sauvegarder();
} catch { … }

Sans await, l'appel rend une promesse immédiatement, le bloc se termine, et le rejet survient plus tard — hors de toute protection. Le try donne une fausse impression de sécurité.

N'attrapez que ce que vous savez traiter

try {
  await envoyer(formulaire);
} catch (erreur) {
  if (erreur.name === "AbortError") return;                  // ignoré
  if (erreur instanceof ErreurValidation) return marquer(erreur.champs);
  throw erreur;                                               // le reste remonte
}

La dernière ligne est la plus importante. Un catch qui avale ce qu'il ne comprend pas fait croire à l'appelant que tout va bien.

finally pour ranger

bouton.disabled = true;
try {
  await envoyer();
} finally {
  bouton.disabled = false;      // dans tous les cas, même en cas d'erreur
}

Jamais de return dans un finally : il écrase celui du try et avale l'exception en cours.

Les termes à connaître

try/catch asynchrone

Avec await, un rejet se comporte comme une exception : il est attrapé par le catch du bloc. C'est le principal confort d'async/await.

Relance

throw erreur dans un catch pour laisser l'appelant décider. On n'attrape que ce qu'on sait traiter.

Retour dans finally

Un return dans un finally écrase celui du try et avale l'exception en cours. À ne jamais écrire.

Erreur de la dernière chance

Le gestionnaire posé au plus haut niveau, qui journalise ce qu'aucun catch n'a traité. Un filet, pas une excuse.

Await oublié dans un try

Sans await, l'appel rend une promesse qui sort du bloc avant de rompre : le try ne protège rien du tout.

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.