Hogyan kezelhető egy ígéret (reject) hibája az await…

Amikor az await-tel egy ígéretet használ, a hibák (reject) többféleképpen kezelhetők:

try...catch szerkezet: A leggyakoribb és ajánlott módszer. Elegánsan elfogja a hibát, amely akkor keletkezik, amikor a promissz megoldódik (resolve) vagy elutasításra kerül (reject).

async function fetchData() {
  try {
    const response = await fetch('https://api.example.com/data');
    if (!response.ok) {
      throw new Error(`HTTP hiba! státusz: ${response.status}`);
    }
    const data = await response.json();
    console.log(data);
  } catch (error) {
    console.error('Hiba az adatok lekérése során:', error);
    // További hiba kezelése vagy felhasználói értesítés
  }
}

fetchData();

.catch() módszer await után: Kevésbé preferált, de lehetséges. A hiba a .catch() callback-ben lesz kezelve, ha a promissz elutasításra kerül.

async function fetchData() {
  const response = await fetch('https://api.example.com/data')
    .catch(error => {
      console.error('Fetch végrehajtása közben hiba:', error);
      // Fetch hiba kezelése
      throw error; // A hiba továbbdobása további kezeléshez
    });

  if (response && !response.ok) {
       console.error(`HTTP hiba! státusz: ${response.status}`);
       // HTTP hiba kezelése
  }

  if (response && response.ok) {
      const data = await response.json()
          .catch(error => {
              console.error('JSON elemzés közben hiba:', error);
              // JSON elemzés hiba kezelése
          });
      if (data) {
          console.log(data);
      }
  }
}

fetchData();

Ez a megközelítés bonyolult lehet, ha sok potenciális hibapont van.

Hiba visszatérő értékkel való kezelése: Néhány könyvtár vagy saját függvény tuple-t [adatok, hiba] ad vissza a promissz elutasítása helyett.

async function safelyFetchData() {
   const [data, error] = await safePromise(fetch('https://api.example.com/data'));
   if (error) {
      console.error('Általános hiba az adatok lekérése során:', error);
      return null; // vagy más érték a hiba jelzésére
   }
   // Feltételezzük, hogy a safePromise kezeli a response.ok-t is
   console.log(data);
   return data;
}

// A safePromise egyszerűsített implementációja példa
async function safePromise(promise) {
    try {
        const result = await promise;
         // Itt lehet ellenőrizni result.ok-t fetch esetén
         if (result && result.ok !== undefined && !result.ok) {
             throw new Error(`HTTP hiba! státusz: ${result.status}`);
         }
        // fetch esetén, szükség lehet arra is, hogy várjuk a result.json() eredményét
        if (result && typeof result.json === 'function') {
            const jsonData = await result.json();
            return [jsonData, null];
        }
        return [result, null];
    } catch (error) {
        return [null, error];
    }
}

safelyFetchData();

Ez a minta (gyakran "error-first callback" vagy "go-stílusú hibakezelés" néven ismert) kényelmes, ha a hibákat helyben kell kezelni anélkül, hogy megszakítanánk a függvény végrehajtását.

A legtisztább és legolvasmányosabb mód a try...catch használata a await-ot tartalmazó kódblokk körül.

Hogyan kezelhető egy ígéret (reject) hibája az await használatakor?