Tratamento de Erros em JavaScript

Este artigo explica o tratamento de erros no JavaScript.

YouTube Video

Tratamento de Erros em JavaScript

O tratamento de erros no JavaScript é uma funcionalidade importante para capturar e lidar adequadamente com erros quando um programa encontra problemas inesperados. Principalmente, é comum usar a sintaxe try...catch para capturar e lidar com erros. Além disso, ao lidar com Promises ou operações assíncronas, o tratamento de erros também pode ser feito usando async/await ou Promise.prototype.catch.

Sintaxe de try...catch

try...catch é usado para capturar e lidar com erros quando eles ocorrem dentro de um bloco de código.

 1try {
 2    // Code that may throw an error
 3    let result = riskyFunction();
 4    console.log(result);
 5} catch (error) {
 6    // Catch and handle the error
 7    console.error("An error occurred:", error.message);
 8} finally {
 9    // Code that will always execute
10    console.log("Error handling has completed.");
11}

• Se um erro ocorrer dentro de um bloco try, a execução do programa é interrompida e o bloco catch é executado.
• O bloco finally é sempre executado, independentemente de haver ou não um erro. É útil para liberar recursos e realizar processamentos finais, entre outras coisas.

Lançando Erros (throw)

No JavaScript, você pode disparar um erro explicitamente usando a palavra-chave throw. É usado para lançar mensagens de erro personalizadas ou erros personalizados.

 1function checkAge(age) {
 2    if (age < 18) {
 3        throw new Error("You are under 18 years old.");
 4    }
 5    return "Age verification completed.";
 6}
 7
 8try {
 9    let result = checkAge(15);
10    console.log(result);
11} catch (error) {
12    console.error(error.message);  // Displays "You are under 18 years old."
13}

Tratamento de Erros em Operações Assíncronas (Promise e async/await)

Ao realizar operações assíncronas, o tratamento de erros é um pouco diferente. Ao usar Promises, os erros são capturados com o método catch.

1let promise = new Promise((resolve, reject) => {
2    // Asynchronous operation
3    setTimeout(() => reject(new Error("An issue has occurred!")), 1000);
4});
5
6promise
7    .then(result => console.log(result))
8    .catch(error => console.error(error.message));  // Displays "An issue has occurred!"

Ao realizar operações assíncronas com async/await, você pode tratar os erros com try...catch.

 1async function fetchData() {
 2    try {
 3        let response = await fetch('https://api.example.com/data');
 4        let data = await response.json();
 5        console.log(data);
 6    } catch (error) {
 7        console.error("An error occurred while fetching data:", error.message);
 8    }
 9}
10
11fetchData();

Resumo

• Você pode capturar erros síncronos usando a sintaxe try...catch.
• Você pode lançar seus próprios erros usando throw.
• Os erros em operações assíncronas podem ser tratados usando o método catch de Promise, ou com async/await e try...catch.

Utilizando esses métodos, você pode garantir que seu programa funcione corretamente mesmo quando ocorrem erros.

Error

A classe Error é usada para o tratamento de erros. Ela fornece a capacidade de criar erros e fornecer mensagens de erro e rastreamentos de pilha.

1try {
2    throw new Error("Something went wrong");
3} catch (e) {
4    console.log(e.message); // Something went wrong
5}

Uso Básico

Um objeto Error pode ser criado explicitamente quando ocorre um erro. Você cria uma instância com new Error() e passa uma mensagem de erro.

1const error = new Error("Something went wrong");
2console.log(error.message);  // "Something went wrong"
3console.log(error.name);     // "Error"
4console.log(error.stack);    // Stack trace (information about where the error occurred)

Lançando Erros com throw

No JavaScript, você pode lançar um erro usando a palavra-chave throw. Isso é usado para interromper o processamento em situações específicas e passar o controle para um manipulador de erros.

1function doSomething() {
2    throw new Error("This function is not yet implemented");
3}
4
5try {
6    doSomething();
7} catch (e) {
8    console.error(e.message);  // "This function is not yet implemented"
9}

Erros lançados com throw podem ser capturados usando a sintaxe try...catch.

Criando Erros Personalizados

No JavaScript, você pode criar seus próprios erros personalizados estendendo a classe Error. Isso permite criar erros adaptados a situações específicas.

 1class CustomError extends Error {
 2    constructor(message) {
 3        super(message);  // Call the parent class constructor
 4        this.name = "CustomError";  // Set the error name
 5    }
 6}
 7
 8try {
 9    throw new CustomError("A custom error has occurred");
10} catch (e) {
11    console.error(e.name);    // "CustomError"
12    console.error(e.message); // "A custom error has occurred"
13}

Classes de Erro Internas

O JavaScript possui várias classes de erro internas que estendem a classe Error. Elas são usadas para representar erros específicos.

• ReferenceError: Ocorre quando você referencia uma variável que não existe.
• TypeError: Ocorre quando o tipo de um valor é diferente do tipo esperado.
• RangeError: Ocorre quando um número está fora do intervalo permitido.
• SyntaxError: Ocorre quando um código que não é sintaticamente correto é executado.
• EvalError: Erros relacionados ao uso da função eval(). Hoje em dia é raramente usado.
• URIError: Ocorre quando um URI inválido (erros de codificação ou decodificação) é usado.

Exemplo: ReferenceError

Aqui está um exemplo de um ReferenceError.

1try {
2    console.log(undefinedVariable);  // Undefined variable
3} catch (e) {
4    console.error(e.name);    // "ReferenceError"
5    console.error(e.message); // "undefinedVariable is not defined"
6}

Exemplo: TypeError

Aqui está um exemplo de um TypeError.

1try {
2    null.f();  // Attempting to call a function on null
3} catch (e) {
4    console.error(e.name);    // "TypeError"
5    console.error(e.message); // "Cannot read properties of null (reading 'f')"
6}

Bloco finally

Na sintaxe try...catch, use o bloco finally para operações que você deseja executar independentemente de um erro ocorrer.

1try {
2    throw new Error("An issue has occurred");
3} catch (e) {
4    console.error(e.message);  // "An issue has occurred"
5} finally {
6    console.log("Performing cleanup");
7}

Neste exemplo, as operações no bloco finally são executadas mesmo que um erro seja lançado.

Propriedades do objeto Error

O objeto Error possui as seguintes propriedades.

• message: Esta é a mensagem de erro.
• name: O nome do erro, que por padrão é "Error".
• stack: Um rastreamento de pilha indicando onde o erro ocorreu, útil para depuração.

Benefícios do tratamento de exceções

Ao implementar o tratamento de erros corretamente, você pode evitar que a aplicação trave quando ocorre um comportamento inesperado. Ao usar adequadamente a sintaxe try...catch e objetos de erro, você pode escrever um código mais robusto.

 1function divide(a, b) {
 2    if (b === 0) {
 3        throw new Error("Cannot divide by zero");
 4    }
 5    return a / b;
 6}
 7
 8try {
 9    console.log(divide(4, 0));  // An error will occur
10} catch (e) {
11    console.error(e.message);   // "Cannot divide by zero"
12}

Resumo

• A classe Error é usada para representar uma causa de erro e realizar o tratamento de erros.
• Use a sintaxe try...catch...finally para tratar erros e evitar a terminação inesperada da aplicação.
• Também é possível estender a classe Error para criar erros personalizados.
• Você pode tratar vários tipos de erros utilizando classes de erro incorporadas como TypeError e ReferenceError.

Você pode acompanhar o artigo acima usando o Visual Studio Code em nosso canal do YouTube. Por favor, confira também o canal do YouTube.

YouTube Video