Règle
Ne abuser les anonymes .
Les anonyme fonctions sans documentation 
sont difficiles à comprendre et réutiliser.

Langues prises en charge : 45+

Introduction

Les fonctions anonymes passées en tant que callbacks ou gestionnaires d'événements masquent leur objectif derrière les détails d'implémentation. Une fonction fléchée de 20 lignes dans un .map() ou .filter() force les lecteurs à analyser toute la logique pour comprendre quelle transformation se produit. Les fonctions nommées avec des noms descriptifs documentent l'intention immédiatement, et la logique complexe peut être comprise en lisant le nom de la fonction avant de plonger dans l'implémentation.

Exemples de code

❌ Non 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);
});

Pourquoi c'est incorrect : La fonction de filtre contient une logique métier complexe (validation d'abonnement, vérifications) enfouie dans une fonction anonyme. Cette logique ne peut pas être réutilisée, testée indépendamment ou comprise sans lire chaque ligne. Les traces de pile affichent des fonctions anonymes si la logique de filtrage échoue.

✅ Conforme :

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

Pourquoi c'est important : La logique métier complexe est extraite en fonctions testables. hasActiveSubscription() et isVerifiedUser() peut être testé unitairement et réutilisé. Les traces de pile affichent les noms de fonctions, ce qui accélère le débogage. La logique du point de terminaison est claire et auto-documentée.

Conclusion

Utilisez des fonctions nommées pour toute logique de plus de 2-3 lignes ou toute logique susceptible d'être réutilisée. Réservez les fonctions anonymes pour les opérations triviales où le nom de la fonction serait plus long que l'implémentation. Les noms de fonctions descriptifs servent de documentation en ligne.