Regra
Não abusar não documentado funções .
Grandes anónimas funções sem documentação 
são difíceis de de e reutilizar.

Idiomas suportados: 45+

Introdução

Funções anônimas passadas como callbacks ou manipuladores de eventos escondem seu propósito por trás de detalhes de implementação. Uma função de seta de 20 linhas em um .map() ou .filter() força os leitores a analisar toda a lógica para entender qual transformação ocorre. Funções nomeadas com nomes descritivos documentam a intenção imediatamente, e a lógica complexa pode ser compreendida lendo o nome da função antes de se aprofundar na implementação.

Exemplos de código

❌ Não-conforme:

app.get('/users', async (req, res) => {
    const users = await db.users.find({});
    const processed = users.filter(u => {
        const hasActiveSubscription = u.subscriptions?.some(s => 
            s.status === 'active' && new Date(s.expiresAt) > new Date()
        );
        const isVerified = u.emailVerified && u.phoneVerified;
        return hasActiveSubscription && isVerified && !u.deleted;
    }).map(u => ({
        id: u.id,
        name: `${u.firstName} ${u.lastName}`,
        email: u.email,
        memberSince: new Date(u.created).getFullYear(),
        tier: u.subscriptions[0]?.tier || 'free'
    })).sort((a, b) => a.name.localeCompare(b.name));
    res.json(processed);
});

Por que está errado: A função de filtro contém lógica de negócio complexa (validação de assinatura, verificações) enterrada em uma função anônima. Essa lógica não pode ser reutilizada, testada independentemente ou compreendida sem ler cada linha. Rastros de pilha (stack traces) mostram funções anônimas se a lógica de filtragem falhar.

✅ Compatível:

function hasActiveSubscription(user) {
    return user.subscriptions?.some(subscription => 
        subscription.status === 'active' && 
        new Date(subscription.expiresAt) > new Date()
    );
}

function isVerifiedUser(user) {
    return user.emailVerified && user.phoneVerified && !user.deleted;
}

function isEligibleUser(user) {
    return hasActiveSubscription(user) && isVerifiedUser(user);
}

function formatUserResponse(user) {
    return {
        id: user.id,
        name: `${user.firstName} ${user.lastName}`,
        email: user.email,
        memberSince: new Date(user.created).getFullYear(),
        tier: user.subscriptions[0]?.tier || 'free'
    };
}

function sortByName(a, b) {
    return a.name.localeCompare(b.name);
}

app.get('/users', async (req, res) => {
    const users = await db.users.find({});
    const processed = users
        .filter(isEligibleUser)
        .map(formatUserResponse)
        .sort(sortByName);
    res.json(processed);
});

Por que isso importa: A lógica de negócio complexa é extraída em funções testáveis. hasActiveSubscription() e isVerifiedUser() pode ser testado unitariamente e reutilizado. Stack traces mostram nomes de funções, tornando a depuração mais rápida. A lógica do endpoint é limpa e auto-documentada.

Conclusão

Use funções nomeadas para qualquer lógica com mais de 2-3 linhas ou qualquer lógica que possa ser reutilizada. Reserve funções anônimas para operações triviais onde o nome da função seria mais longo que a implementação. Nomes de funções descritivos servem como documentação inline.