Cum poți trata o eroare (reject) a unei promisiuni…

Atunci când folosiți await cu o promisiune, erorile (refuzurile) pot fi gestionate în mai multe moduri:

Construcția try...catch: Cel mai comun și recomandat mod. Permite capturarea elegantă a erorilor aruncate în timpul rezolvării (resolve) sau respingerii (reject) promisiunii.

async function fetchData() {
  try {
    const response = await fetch('https://api.example.com/data');
    if (!response.ok) {
      throw new Error(`Eroare HTTP! status: ${response.status}`);
    }
    const data = await response.json();
    console.log(data);
  } catch (error) {
    console.error('Eroare la obținerea datelor:', error);
    // Tratare suplimentară a erorii sau notificare utilizator
  }
}

fetchData();

Metoda .catch() după await: Mai puțin preferată, dar posibilă. Eroarea va fi gestionată în callback-ul .catch(), dacă promisiunea este respinsă.

async function fetchData() {
  const response = await fetch('https://api.example.com/data')
    .catch(error => {
      console.error('Eroare la fetch:', error);
      // Gestionare eroare fetch
      throw error; // Aruncăm eroarea pentru procesare ulterioară, dacă este nevoie
    });

  if (response && !response.ok) {
       console.error(`Eroare HTTP! status: ${response.status}`);
       // Tratare eroare HTTP
  }

  if (response && response.ok) {
      const data = await response.json()
          .catch(error => {
              console.error('Eroare la parsarea JSON:', error);
              // Tratare eroare parsare JSON
          });
      if (data) {
          console.log(data);
      }
  }
}

fetchData();

Această abordare poate deveni dificil de gestionat când se tratează multiple puncte potențiale de eșec.

Gestionarea cu valoare de returnare a erorii: Unele biblioteci sau funcții proprii pot returna un tuple [date, eroare] în loc de a respinge promisiunea.

async function safelyFetchData() {
   const [data, error] = await safePromise(fetch('https://api.example.com/data'));
   if (error) {
      console.error('Eroare generală la obținerea datelor:', error);
      return null; // Sau altă valoare indicând eșecul
   }
   // Se presupune că safePromise gestionează și erorile response.ok
   console.log(data);
   return data;
}

// Exemplu de implementare a safePromise (simplificat)
async function safePromise(promise) {
    try {
        const result = await promise;
         // Aici poate fi verificarea result.ok pentru fetch
         if (result && result.ok !== undefined && !result.ok) {
             throw new Error(`Eroare HTTP! status: ${result.status}`);
         }
        // Pentru fetch, poate fi nevoie să await 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();

Acest pattern (adesea numit "error-first callback" sau "go-style error handling") este util atunci când doriți să tratați erorile local, fără a întrerupe execuția funcției.

Cel mai curat și mai lizibil mod este să folosiți try...catch în jurul blocului de cod care conține await.

Cum poți trata o eroare (reject) a unei promisiuni atunci când folosești await?