Tratando erros em async/await no JavaScript

Como tratar erros em async/await?

Uma das maiores vantagens do uso de async/await em JavaScript é a maneira mais simples de escrever código assíncrono de forma síncrona. No entanto, isso também implica em uma maneira eficiente de lidar com erros. Quando usamos Promises, podemos tratar erros com o método catch(), mas com async/await, o tratamento de erros fica mais simples e intuitivo com o uso do try/catch.

Usando try/catch com async/await

Para capturar e tratar erros dentro de uma função assíncrona, você pode envolver o código com um bloco try/catch. O bloco try contém o código que pode gerar um erro, enquanto o bloco catch lida com o erro caso ele ocorra. Isso torna o código mais legível e organizado, especialmente em comparação com o uso de .catch() em Promises.

Exemplo básico de try/catch com async/await:

async function obterDados() {
  try {
    let resposta = await fetch('https://api.exemplo.com/dados');
    let dados = await resposta.json();
    console.log(dados);
  } catch (error) {
    console.error('Erro ao obter dados:', error);
  }
}

obterDados();

Neste exemplo, se ocorrer qualquer erro ao tentar buscar ou processar os dados, ele será capturado pelo bloco catch e uma mensagem de erro será exibida no console.

Como o catch funciona com async/await?

O bloco catch é executado sempre que ocorre um erro dentro do bloco try. Isso permite capturar erros de forma mais eficiente e tratá-los de maneira centralizada. Como o await pausa a execução da função até que a Promise seja resolvida, qualquer erro gerado durante a resolução da Promise pode ser capturado pelo catch.

Tratando múltiplos erros com try/catch

Você pode usar try/catch para capturar múltiplos erros que possam ocorrer em funções assíncronas. Isso é útil quando você está realizando várias operações assíncronas e deseja tratar erros de maneira centralizada.

Exemplo de tratamento de múltiplos erros:

async function processarDados() {
  try {
    let resposta1 = await fetch('https://api.exemplo1.com/dados');
    let dados1 = await resposta1.json();
    let resposta2 = await fetch('https://api.exemplo2.com/dados');
    let dados2 = await resposta2.json();
    console.log(dados1, dados2);
  } catch (error) {
    console.error('Erro ao processar dados:', error);
  }
}

processarDados();

No exemplo acima, se qualquer uma das Promises falhar, o erro será capturado e exibido no catch. Isso é uma maneira eficiente de tratar falhas em múltiplas operações assíncronas sem precisar de múltiplos catch().

Trabalhando com múltiplos erros de forma independente

Às vezes, você pode querer tratar erros de forma independente para cada operação assíncrona. Para isso, em vez de capturar todos os erros em um único try/catch, você pode envolver cada operação assíncrona com seu próprio bloco try/catch. Isso permite que você trate cada erro de forma específica.

Exemplo de múltiplos try/catch:

async function obterDados() {
  try {
    let resposta1 = await fetch('https://api.exemplo1.com/dados');
    let dados1 = await resposta1.json();
    console.log(dados1);
  } catch (error) {
    console.error('Erro ao obter dados1:', error);
  }
  try {
    let resposta2 = await fetch('https://api.exemplo2.com/dados');
    let dados2 = await resposta2.json();
    console.log(dados2);
  } catch (error) {
    console.error('Erro ao obter dados2:', error);
  }
}

obterDados();

Aqui, cada operação assíncrona tem seu próprio bloco try/catch, permitindo que cada erro seja tratado separadamente e com mensagens de erro específicas para cada operação.

Trabalhando com erros de rede no fetch

O fetch é uma das APIs mais comuns em JavaScript para fazer requisições HTTP, mas pode gerar erros de rede, como falhas de conexão. É importante tratar esses erros para garantir que seu código seja robusto e não quebre em caso de problemas de rede.

Exemplo de como tratar erros de rede com fetch e async/await:

async function obterDados() {
  try {
    let resposta = await fetch('https://api.inexistente.com');
    if (!resposta.ok) {
      throw new Error('Erro na resposta da API');
    }
    let dados = await resposta.json();
    console.log(dados);
  } catch (error) {
    console.error('Erro ao fazer a requisição:', error);
  }
}

obterDados();

Neste exemplo, verificamos se a resposta do fetch foi bem-sucedida com a propriedade ok. Se não for, jogamos um erro personalizado. O erro é então tratado pelo catch.

Conclusão

O tratamento de erros é uma parte essencial do desenvolvimento assíncrono, especialmente quando usamos async/await em JavaScript. Com o bloco try/catch, você pode capturar e tratar erros de maneira eficiente e centralizada. Isso torna o código mais robusto e ajuda a evitar falhas inesperadas, especialmente em operações assíncronas como requisições HTTP e processamento de dados.

Como garantir a robustez do seu código assíncrono com try/catch

O uso de try/catch em funções assíncronas com async/await não só melhora a legibilidade do código, mas também proporciona uma maneira simples de capturar e tratar erros. Esse tratamento é essencial para evitar falhas inesperadas e garantir que o seu código continue funcionando de forma eficiente, mesmo quando ocorrem erros durante a execução de operações assíncronas.

Algumas aplicações:

• Utilizar try/catch para capturar e tratar erros em operações assíncronas como requisições HTTP.
• Usar catch para tratar erros que podem ocorrer durante o processamento de dados em funções assíncronas.
• Envolver cada operação assíncrona com seu próprio try/catch para tratar erros de maneira mais específica e detalhada.
• Tratar erros de rede e de API para garantir a estabilidade do seu código assíncrono.

Dicas para quem está começando

• Quando estiver começando, concentre-se em usar try/catch para garantir que qualquer erro seja capturado e tratado.
• Se você estiver fazendo múltiplas requisições ou operações assíncronas, experimente usar try/catch separadamente para cada operação para identificar rapidamente onde ocorreu o erro.
• Use mensagens de erro informativas no catch para facilitar o diagnóstico de problemas durante o desenvolvimento.
• Teste seu código assíncrono em diferentes cenários para garantir que ele lide adequadamente com erros de rede e de API.

Compartilhe este tutorial