Tratamento de Erros no TypeScript: Uso de Try/Catch e Tipagem de Erros

Uso de Try/Catch em TypeScript

O bloco try/catch é uma das formas mais comuns de capturar erros que podem ocorrer durante a execução do código. O TypeScript herda essa funcionalidade diretamente do JavaScript, permitindo que os desenvolvedores lidem com exceções de forma controlada.

Exemplo básico de try/catch em TypeScript:

try {
    let resultado = 10 / 0;
} catch (error) {
    console.error('Ocorreu um erro:', error);
}

Esse padrão de uso é idêntico ao do JavaScript, mas podemos melhorar com a tipagem de erros no TypeScript, garantindo mais controle sobre o que esperar nos blocos de tratamento.

Tipagem de Erros no TypeScript

Embora o TypeScript não imponha a tipagem de erros capturados por padrão, é uma boa prática fornecer tipos apropriados para os erros. Isso ajuda a evitar suposições incorretas e garante que o desenvolvedor saiba exatamente como lidar com cada tipo de erro.

Por padrão, o erro capturado em um bloco catch é do tipo any. Isso pode ser perigoso, pois pode levar a situações onde o erro é tratado de forma inadequada. Para resolver isso, podemos tipar manualmente o erro da seguinte maneira:

try {
    throw new Error('Erro personalizado');
} catch (error) {
    if (error instanceof Error) {
        console.error('Mensagem de erro:', error.message);
    } else {
        console.error('Erro desconhecido:', error);
    }
}

Neste exemplo, usamos o operador instanceof para garantir que o erro seja do tipo Error antes de acessar suas propriedades, como message. Isso garante que não acidentalmente tentemos acessar propriedades que não existam em tipos de erro não esperados.

Erros Personalizados

Além de capturar erros comuns, você pode definir e lançar erros personalizados em TypeScript, criando suas próprias classes de erro. Isso permite que seu código trate diferentes cenários de erro de maneira mais detalhada e específica.

Exemplo de criação de um erro personalizado:

class ErroDeAutenticacao extends Error {
    constructor(mensagem: string) {
        super(mensagem);
        this.name = 'ErroDeAutenticacao';
    }
}

try {
    throw new ErroDeAutenticacao('Usuário não autenticado');
} catch (error) {
    if (error instanceof ErroDeAutenticacao) {
        console.error('Erro de autenticação:', error.message);
    } else {
        console.error('Erro desconhecido:', error);
    }
}

Com esse código, você pode criar erros específicos para diferentes situações em sua aplicação, como erros de autenticação, erros de validação, etc., garantindo que cada erro seja tratado de forma adequada.

Boas Práticas no Tratamento de Erros com TypeScript

• Evite Capturar Erros de Forma Genérica: Sempre que possível, use o operador instanceof para verificar o tipo de erro capturado, garantindo que você está lidando com ele da maneira certa.
• Crie Erros Personalizados: Defina suas próprias classes de erro para representar condições específicas de falha na aplicação, tornando o tratamento de erros mais claro e organizado.
• Não Abuse de Try/Catch: Embora o uso de try/catch seja útil, evite envolvê-lo em grandes blocos de código. Prefira usá-lo em situações onde erros são esperados e devem ser tratados imediatamente.
• Não Oculte Erros: Ao capturar erros, evite simplesmente registrar uma mensagem genérica no console. Sempre forneça informações úteis que ajudem a entender o problema e a solução adequada.

Conclusão

O tratamento de erros é essencial para garantir que sua aplicação lide de maneira robusta com falhas inesperadas. O TypeScript, com sua tipagem estática, adiciona uma camada de segurança e clareza ao tratamento de erros, permitindo que você capture e trate exceções de forma mais estruturada. Ao usar tipagem de erros e seguir boas práticas, você pode tornar seu código mais seguro, previsível e fácil de manter.