Tratamento de Exceções

10.1 Bloco try...catch

O tratamento de exceções é um aspecto importante da programação que ajuda a melhorar a robustez e a confiabilidade do código. No JavaScript, as palavras-chave try, catch, finally e throw são usadas para lidar com exceções. Na palestra, vamos explorar essas palavras-chave, sua sintaxe e exemplos de uso.

1. Bloco try...catch

A construção try...catch é usada para tratar erros que ocorrem no bloco de código try. Se ocorrer um erro no bloco try, o controle é passado para o bloco catch, onde o erro pode ser tratado.

Sintaxe:

    
      try {
        // Código que pode lançar uma exceção
      } catch (error) {
        // Código para tratar a exceção
      }
    
  

Neste exemplo, embora a divisão por zero não cause um erro no JavaScript, se fosse outro tipo de erro (como acessar uma variável indefinida), o bloco catch lidaria com ele:

    
      try {
        let result = 10 / 0;

        console.log(result);

      } catch (error) {
        console.error('An error occurred:', error);
      }
    
  

10.2. Bloco finally

O bloco finally é usado para executar o código que deve ser executado independentemente de uma exceção ter ocorrido no bloco try ou não. O bloco finally segue o bloco catch.

Sintaxe:

    
      try {
        // Código que pode lançar uma exceção
      } catch (error) {
        // Código para tratar a exceção
      } finally {
        // Código que sempre será executado
      }
    
  

Neste exemplo, a mensagem This will always execute. será exibida independentemente de um erro ter ocorrido ou não:

    
      try {
        let result = 10 / 0;
        console.log(result);
      } catch (error) {
        console.error('An error occurred:', error);
      } finally {
        console.log('This will always execute.');
      }
    
  

10. 3. Operador throw

O operador throw é usado para lançar exceções explicitamente. Com ele, você pode lançar erros personalizados.

Sintaxe:

    
      throw expression;
    
  

Onde:

• expression: qualquer expressão ou objeto que será lançado como uma exceção

Exemplo de uso

Neste exemplo, um erro é lançado se tentar dividir por zero, e o bloco catch trata esse erro:

    
      function divide(a, b) {
        if (b === 0) {
          throw new Error('Division by zero is not allowed.');
        }
        return a / b;
      }

      try {
        let result = divide(10, 0);
        console.log(result);
      } catch (error) {
        console.error('An error occurred:', error.message);
      }
    
  

10.4 Exemplos avançados e uso

Exemplo 1: Múltiplas exceções

Às vezes, diferentes tipos de erros podem ocorrer em um bloco try. Você pode tratá-los de maneiras diferentes usando as propriedades do objeto error.

Neste exemplo, tratamos um erro de sintaxe JSON separadamente de outros possíveis erros:

    
      try {
        JSON.parse('{ malformed JSON string }');
      } catch (error) {
        if (error instanceof SyntaxError) {
          console.error('JSON Syntax Error:', error.message);
        } else {
          console.error('Unexpected Error:', error);
        }
      } finally {
        console.log('Parsing attempt finished.');
      }
    
  

Exemplo 2: Blocos try...catch aninhados

Você pode usar blocos try...catch aninhados para um tratamento de erro mais refinado.

Neste exemplo, o erro que ocorre no primeiro bloco try é tratado pelo bloco interno catch, que em seguida relança o erro para tratamento pelo bloco externo catch:

    
      try {
        try {
          let result = divide(10, 0);
          console.log(result);
        } catch (innerError) {
          console.error('Inner catch:', innerError.message);
          throw innerError;
        }
      } catch (outerError) {
        console.error('Outer catch:', outerError.message);
      } finally {
        console.log('Nested try...catch finished.');
      }

      function divide(a, b) {
        if (b === 0) {
          throw new Error('Division by zero is not allowed.');
        }
        return a / b;
      }
    
  

Exemplo 3: Usando finally para liberar recursos

O bloco finally é útil para liberar recursos, como fechar arquivos ou finalizar conexões de rede.

Neste exemplo, o arquivo sempre será fechado, independentemente de ter ocorrido erro durante sua leitura ou não:

    
      function readFile(filePath) {
        let file;
        try {
          file = openFile(filePath); // Função para abrir o arquivo
          // Trabalhar com o arquivo
        } catch (error) {
          console.error('Error reading file:', error.message);
        } finally {
          if (file) {
            closeFile(file); // Função para fechar o arquivo
          }
          console.log('File processing finished.');
        }
      }

      function openFile(path) {
        // Lógica para abrir o arquivo
      }

      function closeFile(file) {
        // Lógica para fechar o arquivo
      }

      readFile('path/to/file.txt');
    
  

O tratamento de exceções no JavaScript usando try, catch, finally e throw permite criar aplicações mais confiáveis e robustas. Compreender e usar corretamente essas construções ajuda a gerenciar erros de forma eficaz, liberar recursos e melhorar a experiência do usuário.

1

Pesquisa/teste

Objetos, nível 36, lição 4

Indisponível

Objetos

Objetos

Abrir