Regra

Utilizar antecipado retornos e de guarda cláusulas de proteção.
Profundo aninhamento e tardio parâmetro validação
fazer funções mais difíceis de ler e manter.

Idiomas suportados: 45+

Introdução

Cláusulas de guarda validam pré-condições no início de uma função e retornam imediatamente se as condições não forem atendidas. Isso achata o aninhamento, tratando os casos de erro antecipadamente, deixando a lógica principal não aninhada e fácil de ler. Funções que validam parâmetros no meio do caminho ou aninham caminhos de sucesso dentro de múltiplos condicionais forçam os leitores a rastrear o contexto através de muitos níveis de indentação.

Por que isso importa

Legibilidade do código: Cláusulas de guarda tornam o caminho feliz visível no final da função sem aninhamento. Os leitores veem todas as condições de erro de antemão, e então leem a lógica principal em um único nível de indentação sem rastrear mentalmente múltiplas condições.

Manutenção e modificação: Adicionar novas validações ou condições de erro a um código profundamente aninhado requer um posicionamento cuidadoso para evitar quebrar a lógica existente. Cláusulas de guarda no início permitem adicionar novas verificações sem tocar na lógica principal, reduzindo o risco de introduzir bugs.

Exemplos de código

❌ Não-conforme:

function processPayment(user, amount) {
    if (user) {
        if (user.isActive) {
            if (amount > 0) {
                if (user.balance >= amount) {
                    user.balance -= amount;
                    return { success: true, newBalance: user.balance };
                } else {
                    return { success: false, error: 'Insufficient funds' };
                }
            } else {
                return { success: false, error: 'Invalid amount' };
            }
        } else {
            return { success: false, error: 'Inactive user' };
        }
    } else {
        return { success: false, error: 'User required' };
    }
}

Por que está errado: Quatro níveis de aninhamento escondem a lógica principal (dedução de saldo) profundamente dentro da função. Cada condição de erro adiciona outro nível de indentação, tornando o 'caminho feliz' difícil de encontrar e entender rapidamente.

✅ Compatível:

function processPayment(user, amount) {
    if (!user) {
        return { success: false, error: 'User required' };
    }
    if (!user.isActive) {
        return { success: false, error: 'Inactive user' };
    }
    if (amount <= 0) {
        return { success: false, error: 'Invalid amount' };
    }
    if (user.balance < amount) {
        return { success: false, error: 'Insufficient funds' };
    }

    user.balance -= amount;
    return { success: true, newBalance: user.balance };
}

Por que isso importa: Cláusulas de guarda validam todas as pré-condições com retornos antecipados, mantendo a função em um único nível de indentação. O 'caminho feliz' (dedução de saldo) é claramente visível no final sem aninhamento, tornando a função fácil de ler e modificar.

Conclusão

Valide as entradas e trate casos de erro no início das funções com *guard clauses*. Retorne cedo quando as condições falharem, em vez de aninhar o caminho de sucesso. Isso mantém o código plano, legível e fácil de modificar sem quebrar a lógica existente.