Règle
N'abusez pas des fonctions anonymes non documentées.
Les fonctions anonymes volumineuses sans documentation
sont difficiles à comprendre et à réutiliser.
Langages pris 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 : The filter function contains complex business logic (subscription validation, verification checks) buried in an anonymous function. This logic can't be reused, tested independently, or understood without reading every line. Stack traces show anonymous functions if filtering logic fails.
✅ 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.
