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

As cláusulas de salvaguarda validam as condições prévias no início de uma função e regressam imediatamente se as condições não forem cumpridas. Isto reduz o aninhamento ao tratar os casos de erro antecipadamente, deixando a lógica principal sem aninhamento e fácil de ler. As funções que validam parâmetros a meio ou que aninham caminhos de sucesso dentro de múltiplas condicionais obrigam os leitores a seguir o contexto em vários níveis de indentação.

Porque é importante

Legibilidade do código: As cláusulas de guarda tornam o caminho feliz visível no final da função sem aninhamento. Os leitores vêem todas as condições de erro logo à partida e lêem a lógica principal num único nível de indentação, sem terem de seguir mentalmente várias condições aninhadas.

Manutenção e modificação: A adição de novas condições de validação ou de erro a código profundamente aninhado requer uma colocação cuidadosa para evitar quebrar a lógica existente. As cláusulas de salvaguarda no topo permitem adicionar novas verificações sem tocar na lógica principal, reduzindo o risco de introdução de erros.

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' };
    }
}

Porque é que está errado: Quatro níveis de aninhamento escondem a lógica principal (dedução de equilíbrio) no interior 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 num piscar de olhos.

Conformidade:

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 };
}

Porque é que isto é importante: As cláusulas de guarda validam todas as condições prévias com retornos antecipados, mantendo a função num ú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

Validar entradas e tratar casos de erro no início das funções com cláusulas de proteção. Retornar cedo quando as condições falham em vez de aninhar o caminho do sucesso. Isto mantém o código simples, legível e fácil de modificar sem quebrar a lógica existente.