Kuidas saab töödelda promise'i viga (tagasilükkamine)…

Kui kasutate await koos lubadusega, saab vigu (tagasilükkamisi) töödelda mitmel viisil:

try...catch-struktuur: kõige levinum ja soovitatav viis. See võimaldab elegantselt püüda viga, mis visatakse välja (resolve) või lükatakse tagasi (reject) lubadusel.

async function fetchData() {
  try {
    const response = await fetch('https://api.example.com/data');
    if (!response.ok) {
      throw new Error(`HTTP viga! Staatus: ${response.status}`);
    }
    const data = await response.json();
    console.log(data);
  } catch (error) {
    console.error('Viga andmete saamisel:', error);
    // Täiendav vea töötlemine või kasutaja teavitamine
  }
}

fetchData();

.catch() meetod pärast await: vähem soovitatav, kuid võimalik variant. Viga töödeldakse .catch()-s, kui lubadus on tagasi lükatud.

async function fetchData() {
  const response = await fetch('https://api.example.com/data')
    .catch(error => {
      console.error('Fetchi täitmise viga:', error);
      // Fetchi vea töötlemine
      throw error; // Vea edasisaatmine edasiseks töötlemiseks, kui vaja
    });

  if (response && !response.ok) {
       console.error(`HTTP viga! Staatus: ${response.status}`);
       // HTTP vea töötlemine
  }

  if (response && response.ok) {
      const data = await response.json()
          .catch(error => {
              console.error('JSON-i parsimise viga:', error);
              // JSON-i parsimise vea töötlemine
          });
      if (data) {
          console.log(data);
      }
  }
}

fetchData();

See lähenemine võib muutuda tülikaks, kui on palju potentsiaalseid vigu töötlemiskohti.

Viga tagastamise muster: mõned teegid või enda kirjutatud funktsioonid võivad tagastada tulp [andmed, viga] asemel lubaduse tagasilükkamise asemel.

async function safelyFetchData() {
   const [data, error] = await safePromise(fetch('https://api.example.com/data'));
   if (error) {
      console.error('Üldine viga andmete saamisel:', error);
      return null; // või muu väärtus, mis näitab viga
   }
   // Oletame, et safePromise käsitleb ka response.ok
   console.log(data);
   return data;
}

// Näide, kuidas implementida safePromise (lihtsustatud)
async function safePromise(promise) {
    try {
        const result = await promise;
         // Siin võib olla kontroll result.ok, kui see on fetch
         if (result && result.ok !== undefined && !result.ok) {
             throw new Error(`HTTP viga! Staatus: ${result.status}`);
         }
        // Fetch puhul võib olla vaja 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();

See muster (tavaliselt nimetatakse "error-first callback" või "go-style error handling") on mugav, kui on vaja käsitleda vigu lokaalselt ilma funktsiooni täitmise katkestamiseta.

Kõige puhtam ja loetavam viis on kasutada try...catch-i await-i sisaldava koodiploki ümber.

Kuidas saab töödelda promise'i viga (tagasilükkamine) kasutades await?