Como usar o try...catch para capturar erros em tempo de execução?

Como usar o try...catch para capturar erros em tempo de execução?

Em JavaScript, os erros podem ocorrer a qualquer momento durante a execução de um programa, seja devido a problemas com dados de entrada, falhas de rede ou exceções não previstas. Para lidar com esses erros de forma controlada, utilizamos o bloco try...catch. Esse bloco permite que você escreva código que tenta ser executado e, se ocorrer um erro, o controle é transferido para a parte catch, onde você pode tratar o erro de forma adequada.

Como o try...catch funciona?

O bloco try contém o código que pode gerar uma exceção (erro). Se o código dentro do try lançar um erro, o controle passa para o bloco catch, onde o erro é tratado. Caso não haja erro, o código no catch não será executado.

Exemplo básico de try...catch:

try {
  let result = riskyFunction();
} catch (error) {
  console.error('Erro ao executar riskyFunction:', error);
}

O que o código está fazendo: Nesse exemplo, o try tenta executar a função riskyFunction(). Caso essa função gere um erro (por exemplo, se riskyFunction não estiver definida), o erro será capturado pelo catch, que imprime uma mensagem no console, junto com o erro específico.

Tratando diferentes tipos de erros

É possível usar o try...catch para capturar diferentes tipos de erros, e o bloco catch pode ser configurado para tratar o erro de maneiras específicas.

Exemplo de capturar tipos específicos de erro:

try {
  let user = null;
  console.log(user.name);
} catch (error) {
  if (error instanceof TypeError) {
    console.error('Erro de tipo:', error);
  } else {
    console.error('Outro erro:', error);
  }
}

O que o código está fazendo: Neste exemplo, verificamos se o erro capturado é do tipo TypeError (que ocorre quando tentamos acessar uma propriedade de null ou undefined). Isso permite que você trate diferentes tipos de erros de forma mais específica.

Como capturar múltiplos erros com try...catch

Se você tem várias funções ou linhas de código dentro de um bloco try e espera que possam gerar erros diferentes, você pode usar múltiplos blocos catch ou capturar o erro de forma mais genérica.

Exemplo com múltiplos catch:

try {
  // Código que pode gerar diferentes erros
  let data = fetchData();
  processData(data);
} catch (error) {
  if (error instanceof TypeError) {
    console.error('Erro de tipo detectado:', error);
  } else if (error instanceof ReferenceError) {
    console.error('Referência inválida:', error);
  } else {
    console.error('Erro desconhecido:', error);
  }
}

O que o código está fazendo: Esse exemplo captura diferentes tipos de erro, como TypeError e ReferenceError, e trata-os separadamente para fornecer mensagens de erro mais claras ao desenvolvedor.

Propagação de erros (throw)

Em alguns casos, você pode querer lançar um erro manualmente usando o comando throw. Isso pode ser útil quando você quer interromper a execução do código em caso de condições inesperadas ou inválidas.

Exemplo de uso de throw:

function checkNumber(num) {
  if (num <= 0) {
    throw new Error('Número deve ser maior que zero!');
  }
  console.log('Número válido:', num);
}

try {
  checkNumber(-5);
} catch (error) {
  console.error('Erro detectado:', error.message);
}

O que o código está fazendo: Neste exemplo, a função checkNumber() lança um erro caso o número passado seja menor ou igual a zero. O erro é então capturado pelo catch e uma mensagem de erro é exibida.

Como capturar erros assíncronos?

O bloco try...catch também pode ser usado para capturar erros em funções assíncronas, mas com um pouco mais de cuidado. Quando você está lidando com promises, o erro pode ser capturado dentro de um bloco catch associado à promise.

Exemplo de erro assíncrono com async/await:

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

fetchData();

O que o código está fazendo: Nesse exemplo, a função assíncrona fetchData() usa async/await para obter dados de uma API. Se ocorrer um erro durante a execução da requisição, ele será capturado pelo catch e tratado adequadamente.

Conclusão

O uso do try...catch é essencial para lidar com erros em JavaScript de maneira controlada e garantir que sua aplicação continue funcionando sem falhas inesperadas. Utilizando o throw para lançar erros específicos, o catch para tratá-los e o async/await para trabalhar com erros assíncronos, você pode criar um código mais robusto e fácil de manter.

Como tornar seu código JavaScript mais seguro com try...catch

A estrutura try...catch em JavaScript é uma das ferramentas mais poderosas para tratamento de erros. Ao identificar e capturar erros em tempo de execução, você pode evitar que falhas inesperadas prejudiquem a experiência do usuário. Além disso, o uso do throw para lançar erros e o tratamento de erros assíncronos com async/await são fundamentais para garantir a estabilidade da aplicação. Com essas práticas, você pode melhorar a confiabilidade e a legibilidade do seu código.

Algumas aplicações:

• Utilize try...catch para capturar erros em tempo de execução e garantir a robustez do seu código.
• Use throw para lançar erros personalizados quando condições específicas não forem atendidas.
• Combine try...catch com async/await para tratar erros assíncronos de forma eficiente.

Dicas para quem está começando

• Sempre coloque o código que pode gerar erro dentro de um bloco try e trate os erros no bloco catch.
• Use console.error() para exibir mensagens de erro detalhadas e entender melhor onde o problema está ocorrendo.
• Não deixe de usar async/await para tratar erros em chamadas assíncronas de forma mais limpa.

Compartilhe este tutorial