Regra

Manter funções concisa.
Funções funções longas são difíceis de compreender, testar, e manter.

Idiomas suportados: 45+

Introdução

As funções que abrangem centenas de linhas misturam várias responsabilidades, tornando difícil compreender o que a função faz sem ler todas as linhas. Funções longas normalmente lidam com várias preocupações, como validação, lógica comercial, transformação de dados e tratamento de erros, tudo em um só lugar. Isso viola o princípio da responsabilidade única e cria um código difícil de testar, depurar e modificar sem quebrar o comportamento existente.

Porque é importante

Manutenção do código: As funções longas exigem que os programadores tenham mais contexto na sua cabeça para compreender o comportamento. A modificação de uma parte corre o risco de quebrar outra porque toda a lógica está interligada. As correcções de erros tornam-se arriscadas, uma vez que os efeitos secundários não intencionais são difíceis de prever.

Complexidade dos testes: Testar uma função de 200 linhas significa cobrir todos os caminhos de código possíveis num teste, exigindo uma configuração complexa e numerosos casos de teste. As funções mais pequenas podem ser testadas de forma independente com testes unitários específicos, tornando os conjuntos de testes mais rápidos e fiáveis.

Exemplos de código

Não conforme:

async function processOrder(orderData) {
    if (!orderData.items?.length) throw new Error('Items required');
    if (!orderData.customer?.email) throw new Error('Email required');
    const subtotal = orderData.items.reduce((sum, item) => 
        sum + (item.price * item.quantity), 0);
    const tax = subtotal * 0.08;
    const total = subtotal + tax + (subtotal > 50 ? 0 : 9.99);
    const order = await db.orders.create({
        customerId: orderData.customer.id,
        total: total
    });
    await emailService.send(orderData.customer.email, `Order #${order.id}`);
    await inventory.reserve(orderData.items);
    return order;
}

Porque é que está errado: Esta função lida com validação, cálculo, operações de base de dados, correio eletrónico e inventário. Os testes requerem a simulação de todas as dependências. Qualquer alteração à lógica ou validação fiscal requer a modificação de toda esta função.

Conformidade:

function validateOrder(orderData) {
    if (!orderData.items?.length) throw new Error('Items required');
    if (!orderData.customer?.email) throw new Error('Email required');
}

function calculateTotal(items) {
    const subtotal = items.reduce((sum, item) => 
        sum + (item.price * item.quantity), 0);
    return subtotal + (subtotal * 0.08) + (subtotal > 50 ? 0 : 9.99);
}

async function createOrder(customerId, total) {
    return await db.orders.create({ customerId, total });
}

async function processOrder(orderData) {
    validateOrder(orderData);
    const total = calculateTotal(orderData.items);
    const order = await createOrder(orderData.customer.id, total);
    
    // Non-critical operations in background
    emailService.send(orderData.customer.email, `Order #${order.id}`).catch(console.error);
    
    return order;
}

Porque é que isto é importante: Cada função tem uma responsabilidade clara. validateOrder() e calculateTotal() podem ser testadas de forma independente, sem simulações. createOrder() isola a lógica da base de dados. As operações de correio eletrónico e de inventário não bloqueiam a criação de encomendas e as falhas são tratadas separadamente.

Conclusão

Evolua as APIs através de alterações aditivas: adicione novos campos, adicione novos pontos finais, adicione parâmetros opcionais. Quando as alterações de rutura forem inevitáveis, utilize o controlo de versões da API para executar versões antigas e novas em simultâneo. Elimine os campos antigos com prazos claros e guias de migração antes de os remover.