Como pode tratar um erro (reject) de uma promessa ao…

Ao usar await com uma promessa, os erros (rejeições) podem ser tratados de várias maneiras:

Construção try...catch: A forma mais comum e recomendada. Permite capturar elegantemente erros lançados durante a resolução (resolve) ou rejeição (reject) da promessa.

async function fetchData() {
  try {
    const response = await fetch('https://api.example.com/data');
    if (!response.ok) {
      throw new Error(`Erro HTTP! status: ${response.status}`);
    }
    const data = await response.json();
    console.log(data);
  } catch (error) {
    console.error('Erro ao obter dados:', error);
    // Tratamento adicional do erro ou notificação ao usuário
  }
}

fetchData();

Método .catch() após await: Menos preferido, mas possível. O erro será tratado no callback .catch(), se a promessa for rejeitada.

async function fetchData() {
  const response = await fetch('https://api.example.com/data')
    .catch(error => {
      console.error('Erro ao realizar fetch:', error);
      // Tratamento do erro fetch
      throw error; // Re-lançar o erro para tratamento posterior, se necessário
    });

  if (response && !response.ok) {
       console.error(`Erro HTTP! status: ${response.status}`);
       // Tratamento do erro HTTP
  }

  if (response && response.ok) {
      const data = await response.json()
          .catch(error => {
              console.error('Erro ao parsear JSON:', error);
              // Tratamento do erro de parse do JSON
          });
      if (data) {
          console.log(data);
      }
  }
}

fetchData();

Essa abordagem pode se tornar trabalhosa ao lidar com múltiplos pontos de falha potenciais.

Tratamento com valor de retorno de erro: Algumas bibliotecas ou funções próprias podem retornar uma tupla [dados, erro] em vez de rejeitar a promessa.

async function safelyFetchData() {
   const [data, error] = await safePromise(fetch('https://api.example.com/data'));
   if (error) {
      console.error('Erro geral ao obter dados:', error);
      return null; // Ou outro valor indicando falha
   }
   // Assume-se que safePromise também trata erros response.ok
   console.log(data);
   return data;
}

// Exemplo de implementação de safePromise (simplificado)
async function safePromise(promise) {
    try {
        const result = await promise;
         // Aqui pode haver uma verificação result.ok para fetch
         if (result && result.ok !== undefined && !result.ok) {
             throw new Error(`Erro HTTP! status: ${result.status}`);
         }
        // Para fetch, talvez seja necessário 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();

Este padrão (frequentemente chamado de "error-first callback" ou "manejo de erro estilo go") é útil quando se deseja tratar erros localmente sem interromper a execução da função.

A maneira mais limpa e legível é usar try...catch ao redor do bloco de código que contém await.

Como pode tratar um erro (reject) de uma promessa ao usar await?