O tratamento de erros é um aspecto crucial para escrever software robusto e confiável. No entanto, não ser feito com cuidado pode levar a um código desordenado que é difícil de ler e manter.

O Capítulo 7 do Código Limpo se aprofunda em técnicas para lidar com erros que não sobrecarregam seu código, enfatizando clareza e simplicidade.

Neste artigo, exploraremos os principais conceitos deste capítulo e como aplicá-los em JavaScript para manter sua base de código limpa e fácil de manter.

? 1. Use exceções em vez de códigos de erro

Um dos princípios-chave do Código Limpo é preferir exceções a códigos de erro.

As exceções permitem que você separe a lógica de tratamento de erros da sua lógica principal, tornando seu código mais legível.

Exemplo: evitar códigos de erro

function getUser(id) {
    const user = database.findUserById(id);
    if (user === null) {
        return -1;  // Error code for user not found
    }
    return user;
}

const result = getUser(123);
if (result === -1) {
    console.error('User not found');
} else {
    console.log(result);
}

Neste exemplo, o tratamento de erros está interligado com a lógica principal, tornando-o mais difícil de seguir.

Exemplo: usar exceções

function getUser(id) {
    const user = database.findUserById(id);
    if (user === null) {
        throw new Error('User not found');
    }
    return user;
}

try {
    const user = getUser(123);
    console.log(user);
} catch (error) {
    console.error(error.message);
}

Ao usar exceções, separamos a lógica de tratamento de erros da lógica principal, tornando o código mais limpo e fácil de entender.

? 2. Forneça contexto com mensagens significativas

Ao lançar exceções, é importante fornecer mensagens de erro significativas que forneçam contexto sobre o erro.

Isso ajuda a diagnosticar problemas rapidamente, sem a necessidade de se aprofundar no código.

Exemplo: fornecer contexto em mensagens de erro

function getUser(id) {
    const user = database.findUserById(id);
    if (user === null) {
        throw new Error(`User with ID ${id} not found`);
    }
    return user;
}

try {
    const user = getUser(123);
    console.log(user);
} catch (error) {
    console.error(error.message);  // Outputs: User with ID 123 not found
}

Uma mensagem de erro descritiva fornece o contexto necessário para entender o problema imediatamente.

? 3. Não retorne nulo

Retornar nulo pode levar a erros de referência nula que são difíceis de rastrear.

Em vez de retornar nulo, considere lançar uma exceção ou usar um padrão de caso especial que forneça um comportamento padrão.

Exemplo: evite retornar nulo

function getUser(id) {
    const user = database.findUserById(id);
    if (user === null) {
        return null;  // This can lead to null reference errors
    }
    return user;
}

const user = getUser(123);
if (user !== null) {
    console.log(user.name);
}

Retornar nulo requer verificações adicionais e pode sobrecarregar seu código.

Exemplo: lançar uma exceção ou usar um caso especial

function getUser(id) {
    const user = database.findUserById(id);
    if (user === null) {
        throw new Error(`User with ID ${id} not found`);
    }
    return user;
}

// OR

class NullUser {
    get name() {
        return 'Guest';
    }
}

function getUser(id) {
    const user = database.findUserById(id);
    return user || new NullUser();
}

Lançar uma exceção ou usar um objeto de caso especial (como NullUser) ajuda a evitar erros de referência nula e mantém seu código limpo.

? 4. Use Try-Catch-Finally com moderação

Embora os blocos try-catch-finally sejam essenciais para lidar com exceções, seu uso excessivo pode sobrecarregar seu código.

Use-os apenas quando necessário e evite blocos profundamente aninhados.

Exemplo: Evite Try-Catch excessivo

try {
    const data = JSON.parse(input);
    try {
        const user = getUser(data.id);
        try {
            sendEmail(user.email);
        } catch (error) {
            console.error('Failed to send email:', error.message);
        }
    } catch (error) {
        console.error('User retrieval failed:', error.message);
    }
} catch (error) {
    console.error('Invalid JSON:', error.message);
}

Este código é difícil de seguir devido a vários blocos try-catch aninhados.

Exemplo: refatorar para reduzir a desordem

function parseInput(input) {
    try {
        return JSON.parse(input);
    } catch (error) {
        throw new Error('Invalid JSON');
    }
}

function retrieveUser(data) {
    return getUser(data.id);
}

function notifyUser(user) {
    sendEmail(user.email);
}

try {
    const data = parseInput(input);
    const user = retrieveUser(data);
    notifyUser(user);
} catch (error) {
    console.error(error.message);
}

Ao dividir a lógica em funções separadas, reduzimos o aninhamento e melhoramos a legibilidade.

? 5. Não ignore as exceções detectadas

Se você detectar uma exceção, certifique-se de tratá-la corretamente.

Ignorar exceções silenciosamente pode levar a um comportamento inesperado e dificultar a depuração.

Exemplo: não ignore exceções

try {
    const user = getUser(123);
} catch (error) {
    // Ignoring the exception
}

Ignorar exceções pode mascarar possíveis problemas em seu código.

Exemplo: manipular ou registrar a exceção

try {
    const user = getUser(123);
} catch (error) {
    console.error('An error occurred:', error.message);
}

O tratamento ou registro da exceção garante que você esteja ciente de quaisquer problemas e possa resolvê-los adequadamente.

⚡ Conclusão

O tratamento eficaz de erros é essencial para escrever código JavaScript limpo e de fácil manutenção.

Seguindo os princípios do Código Limpo – como usar exceções em vez de códigos de erro, fornecer contexto em mensagens de erro, evitar retornos nulos, usar try-catch com moderação e não ignorar exceções capturadas – você pode garantir que sua lógica de tratamento de erros é robusto e discreto.

Boa codificação!