Kā apstrādāt solījuma kļūdu (atsakšanu), izmantojot…

Ar izmantojot await ar pažadus, kļūdas (noraidījumi) var tikt apstrādātas vairākos veidos:

try...catch konstrukcija: visbiežāk izmantotais un ieteicamais veids. Tas ļauj eleganti noķert kļūdu, kas izmetama, izpildot (resolve) vai noraidot (reject) solījumu.

async function fetchData() {
  try {
    const response = await fetch('https://api.example.com/data');
    if (!response.ok) {
      throw new Error(`HTTP kļūda! Statuss: ${response.status}`);
    }
    const data = await response.json();
    console.log(data);
  } catch (error) {
    console.error('Kļūda, iegūstot datus:', error);
    // Papildu kļūdas apstrāde vai lietotāja brīdinājums
  }
}

fetchData();

.catch() metode pēc await: mazāk vēlams, bet iespējams veids. Kļūda tiks apstrādāta .catch() iekšienē, ja solījums tiks noraidīts.

async function fetchData() {
  const response = await fetch('https://api.example.com/data')
    .catch(error => {
      console.error('Fetch izpildes kļūda:', error);
      // Fetch kļūdas apstrāde
      throw error; // Pārsūtīt kļūdu tālākai apstrādei, ja nepieciešams
    });

  if (response && !response.ok) {
       console.error(`HTTP kļūda! Statuss: ${response.status}`);
       // HTTP kļūdas apstrāde
  }

  if (response && response.ok) {
      const data = await response.json()
          .catch(error => {
              console.error('Kļūda JSON parsēšanā:', error);
              // JSON parsēšanas kļūdas apstrāde
          });
      if (data) {
          console.log(data);
      }
  }
}

fetchData();

Šī pieeja var kļūt apgrūtinoša, ja ir daudz potenciālo kļūdu apstrādes punktu.

Kļūdas atgriešanas modelis: dažas bibliotēkas vai pašu rakstītas funkcijas var atgriezt tupi [dati, kļūda] vietā, lai izvairītos no noraidīšanas.

async function safelyFetchData() {
   const [data, error] = await safePromise(fetch('https://api.example.com/data'));
   if (error) {
      console.error('Kopējā kļūda, iegūstot datus:', error);
      return null; // vai cita vērtība, kas norāda uz kļūmi
   }
   // Pieņem, ka safePromise arī apstrādā response.ok
   console.log(data);
   return data;
}

// Piemērs, kā realizēt safePromise (vienkāršots)
async function safePromise(promise) {
    try {
        const result = await promise;
         // Šeit var būt pārbaude result.ok, ja tas ir fetch
         if (result && result.ok !== undefined && !result.ok) {
             throw new Error(`HTTP kļūda! Statuss: ${result.status}`);
         }
        // fetch gadījumā, iespējams, vajadzē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();

Šis modelis (bieži saukts par "error-first callback" vai "go-style error handling") ir ērts, ja nepieciešams apstrādāt kļūdas lokāli, ne pārtraucot funkcijas izpildi.

Vis tīrākais un lasāmākais veids ir izmantot try...catch ap await kodu.

Kā apstrādāt solījuma kļūdu (atsakšanu), izmantojot await?