Desenvolvendo Software Robusto: Combatendo Fluxos Implícitos com Transparência e Controle

Fala galera de programação, tudo beleza? Hoje vamos conversar sobre tratamento de erros em Typescript.

Um software frágil é multifacetado, e um dos aspectos cruciais é a presença de fluxos implícitos.

Ao longo do tempo, as boas práticas enfatizam a importância de ter controle total sobre o código, evitando ocultar os fluxos de execução.

Um exemplo claro disso é a utilização de middlewares. Esses são componentes intermediários que podem manipular requisições e respostas em sistemas web. Quando não são explicitamente gerenciados, podem introduzir fluxos não controlados no software.

Exemplo: Middleware em Express.js

// Middleware para autenticação
function authenticate(req, res, next) {
    if (!req.user) {
        res.status(401).send("Unauthorized");
    } else {
        next();
    }
}

Retornando Erros em Vez de Lançá-los

O primeiro passo para tornar os fluxos mais explícitos é evitar lançar erros diretamente, optando por retorná-los. Por exemplo, ao invés de lançar um erro em uma função, ela pode retornar um objeto que contém informações sobre o erro ocorrido.

Exemplo: Função que Retorna Erros

// Função que divide dois números e retorna um erro se a divisão por zero for detectada
function divide(a: number, b: number): { result?: number, error?: string } {
    if (b === 0) {
        return { error: "Divisão por zero" };
    }
    return { result: a / b };
}

Ao lidar com funções que retornam erros, é prático utilizar uma estrutura de union de tipos para representar todos os possíveis erros que podem ser retornados. Isso permite um tratamento mais eficaz e explícito dos erros.

A tipagem dos erros retornados é crucial, e ao tratá-los, é recomendável usar estruturas como switch case para lidar explicitamente com cada tipo de erro. Utilizar um caso padrão (default) no switch pode parecer conveniente, mas pode levar à criação de fluxos implícitos, onde erros não tratados são silenciosamente ignorados.

Exemplo: Tratamento de Erros com Union de Tipos

// Chamada da função divide e tratamento do resultado
const result = divide(10, 0);
if (result.error) {
    console.error(result.error);
} else {
    console.log("Resultado:", result.result);
}

Construindo um Código Robusto e Transparente

É importante reconhecer que fluxos implícitos podem tornar o software mais frágil, pois escondem potenciais problemas que podem surgir durante a execução. Tornar todos os fluxos explícitos obriga a enfrentar cada caso, aumentando a robustez do software.

Ao manter todos os fluxos explícitos, é mais fácil detectar e corrigir problemas. Se um módulo deixa de retornar um erro anteriormente tratado, isso resultará em erros de tipagem em todos os locais onde o erro era tratado, destacando os módulos afetados.

É um indicador de má prática continuar a usar construções como switch case com um caso padrão ou múltiplos ifs sem um tratamento adequado. Isso não apenas aumenta a fragilidade do código, mas também dificulta a manutenção e compreensão do mesmo.

Ao fazer um código mais explícito e robusto, não se trata apenas de escrever mais linhas de código, mas sim de economizar horas de depuração e garantir um entendimento claro do fluxo de execução a longo prazo.

Portanto, é essencial explorar ao máximo as capacidades do Typescript para construir software robusto e de fácil manutenção.

Beleza pessoal? Espero que possa ajudar.

Dúvidas ou sugestões? Deixe o seu comentário!

Um abraço e até o próximo post. Valeu!