Regra
Evitar profundo aninhamento níveis.
O de aninhamento torna o código difícil de ler e compreender.
Línguas suportadas: 45+

Introdução

O código com quatro, cinco ou seis níveis de aninhamento cria uma carga cognitiva que atrasa o desenvolvimento. Cada nível de aninhamento dificulta o acompanhamento das condições activas, dos caminhos de erro e da lógica empresarial. O aninhamento excessivo indica frequentemente a falta de abstracções ou oportunidades para utilizar retornos antecipados e cláusulas de proteção.

Porque é importante

Manutenção do código e riscos de erros: O aninhamento profundo cria "código de seta" que empurra a lógica para fora do ecrã, atrasando a revisão do código. Os programadores perdem casos extremos quando modificam código aninhado porque não conseguem ver todas as condições que têm de ser satisfeitas. As alterações que parecem corretas isoladamente podem quebrar pressupostos feitos vários níveis acima.

Complexidade dos testes e da depuração: Cada nível de aninhamento duplica os casos de teste necessários para a cobertura, criando uma explosão exponencial de caminhos. Os traços de pilha dos erros não mostram quais as condições que os originaram, tornando os erros difíceis de reproduzir.

Exemplos de código

Não conforme:

function processOrder(order) {
    if (order) {
        if (order.items && order.items.length > 0) {
            if (order.customer) {
                if (order.customer.address) {
                    if (order.paymentMethod) {
                        if (validatePayment(order.paymentMethod)) {
                            return submitOrder(order);
                        }
                    }
                }
            }
        }
    }
    return { error: 'Invalid order' };
}

Por que está errado: Seis níveis de aninhamento dificultam a visualização da lógica comercial real (envio do pedido) enterrada na parte inferior. Cada verificação de condição adiciona outra camada de indentação, e o tratamento de erros não é claro porque não há indicação de qual validação específica falhou.

Conformidade:

function processOrder(order) {
    if (!order) {
        return { error: 'Order is required' };
    }

    if (!order.items || order.items.length === 0) {
        return { error: 'Order must contain items' };
    }

    if (!order.customer?.address) {
        return { error: 'Customer address is required' };
    }

    if (!order.paymentMethod || !validatePayment(order.paymentMethod)) {
        return { error: 'Invalid payment method' };
    }

    return submitOrder(order);
}

Porque é que isto é importante: As cláusulas de guarda com retornos antecipados reduzem o aninhamento a um único nível. Cada validação é explícita e devolve uma mensagem de erro específica. O caminho feliz (submissão da encomenda) é visível no final sem qualquer aninhamento. O código é auto-documentado e fácil de modificar sem quebrar as condições existentes.

Conclusão

Mantenha os níveis de aninhamento em três ou menos sempre que possível. Use retornos antecipados, cláusulas de guarda e funções auxiliares para nivelar estruturas profundamente aninhadas. Quando encontrar aninhamentos além de três níveis, é um sinal para refatorar, extraindo métodos, invertendo condições ou repensando a abordagem. O código plano é mais fácil de ler, testar, depurar e manter do que as alternativas profundamente aninhadas.