Como lidar com erros em JavaScript
As coisas dão errado. É um fato da vida e a programação certamente não é exceção. Mas com uma previsão cuidadosa, você pode planejar com antecedência e evitar a catástrofe.
Erros de programação são inevitáveis. Mais cedo ou mais tarde, seu aplicativo experimentará algum comportamento inesperado. Como qualquer outra linguagem de programação, o JavaScript gera erros quando algo dá errado no seu código.
Os erros interrompem o fluxo normal de um aplicativo. Mas também ajudam a proteger seu aplicativo contra comportamentos imprevisíveis. Saber como lidar com os erros de maneira adequada é crucial.
Por que o tratamento de erros é importante?
O tratamento de erros contribui para uma melhor experiência do usuário. Você pode trocar os erros padrão e às vezes detalhados do JavaScript por suas próprias mensagens de erro mais legíveis. Você pode lidar facilmente com as causas de alguns erros e manter seu programa em execução, em vez de encerrá-lo.
O tratamento de erros também é útil durante o desenvolvimento. Você pode detectar um erro de tempo de execução e fazer algo útil com ele, como registrá-lo no console do navegador. Isso é mais elegante do que o erro que causa uma falha e não sabe onde ou por que o erro ocorreu.
Estrutura de erros integrados de JavaScript
Os erros de JavaScript são objetos com três propriedades:
- nome: Este é o nome do erro. Por exemplo, um nome de variável ausente gerará um erro chamado SyntaxError.
- mensagem: Este é o corpo da mensagem e explica o erro textualmente.
- causa: você pode usar esta propriedade com erros personalizados para controlar a pilha de chamadas.
Tipos comuns de erros em JavaScript
Aqui estão alguns erros comuns encontrados em JavaScript.
Erro de sintaxe
Erros de sintaxe podem ocorrer quando o JavaScript tenta interpretar seu código. Irá gerar um erro se o seu código não estiver em conformidade com a sintaxe correta. Alguns erros comuns que podem gerar erros de sintaxe são:
- Nomes de variáveis ausentes.
- Falta “}” após uma função.
- Falta “)” após uma condição.
Erro de referência
Erros de referência ocorrem quando um programa tenta fazer referência a uma variável que não está disponível ou está fora do escopo.
Erro de tipo
O JavaScript pode gerar um erro de tipo quando não consegue executar uma operação porque o tipo que espera é diferente daquele que recebe.
URIerro
Este erro ocorre se você usar uma função de manipulação de URI global — como decodeURIComponent() — incorretamente. Como resultado, a codificação ou decodificação falha.
Erro agregado
Este erro é usado para representar vários erros agrupados em um. Use-o quando quiser lançar muitos erros de uma vez. Por exemplo, Promise.any() pode lançar um AggregateError() quando todas as promessas passadas para ele forem rejeitadas.
Erro interno
Um InternalError é lançado quando ocorre um erro dentro do mecanismo JavaScript.
RangeError
Algumas funções determinam o intervalo de valores que você pode passar como argumentos. Este erro ocorre quando você tenta passar um valor que não está incluído nesse intervalo.
Tratamento de erros com o bloco Try...Catch
JavaScript fornece funcionalidade integrada de tratamento de exceções com o bloco try…catch…finalmente. Também permite que você crie seus próprios erros usando o operador throw.
Você pode usar um bloco try…catch para lidar com erros que ocorrem durante o tempo de execução. Você escreve um código válido que espera executar corretamente no bloco try. No bloco catch, você pode escrever código de tratamento de erros.
try {
// Valid Javascript code
} catch (error) {
// Handle error
} finally {
// Executed even when an error occurs
}
O bloco catch será ignorado se o código no bloco try não gerar nenhum erro. Se gerar um erro, a execução salta para o bloco catch. O código no bloco final é executado independentemente de ocorrer um erro ou não. Este bloco não é obrigatório, então omita-o se não precisar dele.
O código incluído no bloco try deve ser válido. Caso contrário, o JavaScript gerará um erro de análise.
Vejamos um exemplo prático:
try {
console.log(text)
} catch (error) {
console.log(error.message)
} finally {
console.log("Will be executed regardless")
}
Este programa tenta registrar o valor da variável de texto. Como essa variável não está definida, o programa gerará um erro. Este erro é impresso no console no bloco catch. O bloco finalmente é executado e imprime uma mensagem própria.
ReferenceError: text is not defined
Will be executed regardless
Em situações em que você precisa gerar seu próprio erro, use o operador throw.
Considere este exemplo que gera um erro se os dados forem falsos:
const data = getData()
try {
if (!data) {
throw "No data"
}
console.log(data)
// continue
} catch(error) {
console.log(error) // "No data"
}
Neste exemplo, o programa chama a função getData() e atribui seu resultado à variável de dados. No bloco try, o bloco gera um erro personalizado se os dados estiverem vazios. O bloco catch captura esse erro e o registra no console.
Erros de lançamento são muito benéficos durante o desenvolvimento. Você pode usar a mensagem de erro personalizada para entender por que seu aplicativo não está funcionando conforme o esperado.
Como este exemplo demonstra, você pode usar uma string para o objeto de erro. Na verdade, você pode lançar qualquer expressão JavaScript como um erro. No entanto, por uma questão de consistência com erros internos, use um objeto JavaScript contendo um nome e uma mensagem.
throw {
name: "Error name",
message: "Error message"
}
Você também pode usar os construtores integrados do JavaScript ao lançar erros. Esses construtores incluem Error, SyntaxError e ReferenceError, entre outros.
Para gerar um erro usando o construtor Error, use este código:
throw new Error("No data")
Agora você pode fazer referência ao nome e à mensagem.
console.log(error.name) // Error
console.log(error.message) // No data
Estendendo o objeto de erro JavaScript
Uma classe de erro personalizada é útil ao lidar com erros que não correspondem aos objetos já fornecidos pelo JavaScript. Por exemplo, você pode querer isolar um erro de validação de dados como um tipo específico chamado ValidationError.
Você pode usar uma classe JavaScript ES2015 para criar uma classe de erro personalizada.
class ValidationError extends Error {
constructor(message) {
super(message);
this.name = "ValidationError";
}
}
Lance um erro usando a classe ValidationError assim:
throw new ValidationError("Your error message")
O erro gerado será um objeto com os valores de nome e mensagem.
{
name: "ValidationError",
message: "Your error message"
}
Erros existem para ajudar
O tratamento de erros é uma parte fundamental da programação, seja qual for a linguagem que você estiver usando. JavaScript tem ótimo suporte para gerar e capturar erros no estilo de exceções. Ele também possui vários tipos de erros integrados que você pode manipular e usar em seus próprios casos.
Alguns erros, como erros de sintaxe, podem passar despercebidos quando você escreve JavaScript no “modo desleixado”. Usar o modo estrito permite que o JavaScript detecte erros que de outra forma seriam ignorados.