Comment gérer une erreur (rejeter) d'une promesse…

Lors de l'utilisation de await avec une promesse, les erreurs (rejets) peuvent être gérées de plusieurs manières :

Construction try...catch : La méthode la plus courante et recommandée. Permet d'intercepter élégamment les erreurs levées lors de la résolution (resolve) ou du rejet (reject) de la promesse.

async function fetchData() {
  try {
    const response = await fetch('https://api.example.com/data');
    if (!response.ok) {
      throw new Error(`Erreur HTTP! statut : ${response.status}`);
    }
    const data = await response.json();
    console.log(data);
  } catch (error) {
    console.error('Erreur lors de la récupération des données :', error);
    // Traitement supplémentaire de l'erreur ou notification à l'utilisateur
  }
}

fetchData();

Méthode .catch() après await : Moins préférée, mais possible. L'erreur sera traitée dans le callback .catch(), si la promesse est rejetée.

async function fetchData() {
  const response = await fetch('https://api.example.com/data')
    .catch(error => {
      console.error('Erreur lors de l'exécution de fetch :', error);
      // Traitement de l'erreur fetch
      throw error; // Relancer l'erreur pour un traitement ultérieur si nécessaire
    });

  if (response && !response.ok) {
       console.error(`Erreur HTTP! statut : ${response.status}`);
       // Traitement de l'erreur HTTP
  }

  if (response && response.ok) {
      const data = await response.json()
          .catch(error => {
              console.error('Erreur lors de l’analyse du JSON :', error);
              // Traitement de l'erreur de parsing JSON
          });
      if (data) {
          console.log(data);
      }
  }
}

fetchData();

Cette approche peut devenir encombrante lors du traitement de multiples points de défaillance potentiels.

Gestion avec valeur de retour d'erreur : Certaines bibliothèques ou fonctions personnalisées peuvent retourner un tuple [données, erreur] au lieu de rejeter la promesse.

async function safelyFetchData() {
   const [data, error] = await safePromise(fetch('https://api.example.com/data'));
   if (error) {
      console.error('Erreur générale lors de la récupération des données :', error);
      return null; // Ou une autre valeur indiquant un échec
   }
   // On suppose que safePromise gère également les erreurs response.ok
   console.log(data);
   return data;
}

// Exemple d'implémentation de safePromise (simplifié)
async function safePromise(promise) {
    try {
        const result = await promise;
         // Ici, une vérification result.ok pour fetch
         if (result && result.ok !== undefined && !result.ok) {
             throw new Error(`Erreur HTTP! statut : ${result.status}`);
         }
        // Pour fetch, il peut être nécessaire d’attendre result.json()
        if (result && typeof result.json === 'function') {
            const jsonData = await result.json();
            return [jsonData, null];
        }
        return [result, null];
    } catch (error) {
        return [null, error];
    }
}

safelyFetchData();

Ce pattern (souvent appelé "error-first callback" ou "gestion d'erreur de style go") est pratique lorsque vous souhaitez gérer les erreurs localement sans interrompre l'exécution de la fonction.

La méthode la plus propre et lisible consiste à utiliser try...catch autour du bloc de code contenant await.

Comment gérer une erreur (rejeter) d'une promesse lors de l'utilisation de await?