Tratamento de Erros no TypeScript

Este artigo explica o tratamento de erros no TypeScript.

YouTube Video

Tratamento de Erros no TypeScript

O tratamento de erros no TypeScript é feito fundamentalmente usando a estrutura try...catch, assim como no JavaScript. No TypeScript, é possível gerenciar o conteúdo dos erros com mais clareza por meio da inferência de tipos. Isso permite um tratamento de erros mais preciso e legível.

Sintaxe de try...catch

A sintaxe básica para tratamento de erros é a seguinte:.

 1try {
 2    // Code that may throw an error
 3    throw new Error("Something went wrong!");
 4} catch (error) {
 5    // Catch and handle the error
 6    console.error("Error:", error);
 7} finally {
 8    // Code that runs regardless of whether an error occurred
 9    console.log("Finally block executed.");
10}

Tratamento de Erros com Segurança de Tipos

No TypeScript, erros capturados dentro de um bloco catch são tratados como tipo any, mas é recomendado especificar o tipo apropriado para um tratamento de erros mais seguro. Por exemplo, você pode definir e usar um tipo de erro personalizado da seguinte forma:.

 1class CustomError extends Error {
 2    constructor(message: string, public errorCode: number) {
 3        super(message);
 4        this.name = "CustomError";
 5    }
 6}
 7
 8try {
 9    throw new CustomError("Invalid operation", 400);
10} catch (error) {
11    if (error instanceof CustomError) {
12        console.error(`Error: ${error.message}, Code: ${error.errorCode}`);
13    } else {
14        console.error("Unknown error occurred");
15    }
16}

Neste exemplo, uma classe chamada CustomError é criada e um erro é lançado com propriedades personalizadas como errorCode. No bloco catch, use instanceof para determinar o tipo de erro e realizar o tratamento apropriado.

Tratamento de Erros Assíncronos

Em TypeScript, try...catch também é usado para lidar com erros ao utilizar funções assíncronas.

 1async function fetchData() {
 2    try {
 3        const response = await fetch("https://api.example.com/data");
 4        if (!response.ok) {
 5            throw new Error(`HTTP error! status: ${response.status}`);
 6        }
 7        const data = await response.json();
 8        console.log(data);
 9    } catch (error) {
10        console.error("Failed to fetch data:", error);
11    }
12}
13
14fetchData();

Neste exemplo, os dados são buscados usando fetch, e response.ok é verificado para gerar um erro se o código de status não for OK. O erro é capturado no catch, e o log apropriado é exibido.

Resumo

No TypeScript, usar tipos para esclarecer o conteúdo dos erros torna o tratamento de erros mais seguro e legível. Ao tratar erros, é importante esclarecer quais tipos de erros podem ocorrer e tratá-los de forma apropriada.

Erro

A classe Error no TypeScript estende a classe Error no JavaScript e é um objeto básico para representar erros. Ao usar a classe Error, você pode criar um objeto que inclui uma mensagem de erro e realizar o tratamento de erros.

Noções Básicas da Classe Error

A classe Error é usada da seguinte forma.

1const error = new Error("Something went wrong!");
2console.log(error.message); // "Something went wrong!"
3console.log(error.name);    // "Error"

Propriedades

A classe Error possui as seguintes propriedades:.

• mensagem Uma string que representa a mensagem de erro.
• nome O nome do erro. Por padrão, é "Error", mas pode ser alterado ao criar uma classe personalizada de erro.
• stack Informações de rastreamento do stack usadas para depuração. Uma string que indica qual código causou o erro quando ele ocorreu.

Classe de Erro Personalizada

Também é possível estender a classe Error e criar suas próprias classes de erro. Isso é útil em situações onde é necessário um tratamento específico de erros. Por exemplo, é eficaz quando você deseja tratar diferentes tipos de erros, como erros de requisições HTTP ou erros de banco de dados.

Exemplo de Criação de um Erro Personalizado

 1class CustomError extends Error {
 2    constructor(message: string, public errorCode: number) {
 3        super(message); // Call the constructor of the parent class 'Error'
 4        this.name = "CustomError"; // Set the name of the error
 5    }
 6}
 7
 8const customError = new CustomError("Invalid operation", 400);
 9console.log(customError.message);   // "Invalid operation"
10console.log(customError.name);      // "CustomError"
11console.log(customError.errorCode); // 400

• Ao criar uma classe CustomError e adicionar informações como códigos de erro, você pode gerenciar informações mais abrangentes sobre erros.

Herança da Classe Error

No TypeScript, ao criar uma classe de erro personalizada estendendo a classe Error, há alguns pontos de atenção.

1. Chamando super() No construtor de uma classe de erro personalizada, você deve chamar super() para invocar o construtor da classe Error. Isso garante que as propriedades message e stack sejam inicializadas corretamente.

2. Adicionando Propriedades Se você quiser adicionar informações extras ao objeto de erro, defina novas propriedades dentro da classe. Por exemplo, na CustomError acima, uma propriedade errorCode é adicionada.

Lançando e Capturando Erros

Você pode tratar erros lançando erros usando a classe Error ou uma classe de erro personalizada e então capturando-os.

 1function riskyOperation() {
 2    throw new Error("Something went wrong during the operation");
 3}
 4
 5try {
 6    riskyOperation();
 7} catch (error) {
 8    if (error instanceof Error) {
 9        console.error(error.message);  // "Something went wrong during the operation"
10        console.error(error.name);     // "Error"
11    }
12}

No caso de erros personalizados, use também instanceof para identificar erros específicos e tratá-los adequadamente.

 1class CustomError extends Error {
 2    constructor(message: string, public errorCode: number) {
 3        super(message);
 4        this.name = "CustomError";
 5    }
 6}
 7
 8try {
 9    throw new CustomError("Database connection failed", 500);
10} catch (error) {
11    if (error instanceof CustomError) {
12        console.error(`Error: ${error.message}, Code: ${error.errorCode}`);
13    }
14}

Resumo

A classe Error no TypeScript é uma classe fundamental para realizar o tratamento padrão de erros. Além disso, ao estender a classe Error para criar erros personalizados, torna-se possível um tratamento de erros flexível com base nos tipos de erro e informações adicionais.

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