Règle

Éviter trop trop trop volumineux.
Les fichiers avec multiples responsabilités
sont difficiles difficile difficiles à maintenir.

Langues prises en charge : 45+

Introduction

Les fichiers qui s'étendent sur des milliers de lignes traitent généralement de multiples questions sans rapport les unes avec les autres, ce qui rend difficile la localisation d'une fonctionnalité spécifique. Un fichier de 3000 lignes utils.js contenant des aides à la validation, du formatage de chaînes, de la manipulation de dates et des utilitaires d'API oblige les développeurs à parcourir un code sans rapport avec le leur pour trouver ce dont ils ont besoin. Les fichiers volumineux créent également des conflits de fusion lorsque plusieurs développeurs modifient simultanément différentes sections.

Pourquoi c'est important

La maintenabilité du code : Les fichiers volumineux mélangent des fonctionnalités sans rapport les unes avec les autres, ce qui oblige les développeurs à comprendre des centaines de lignes de code non pertinentes pour modifier une fonction. Trouver une logique spécifique devient un exercice de recherche plutôt que de naviguer vers un fichier portant le nom approprié.

Conflits de contrôle de version : Lorsque plusieurs développeurs travaillent sur des fonctionnalités différentes dans un même fichier volumineux, les conflits de fusion sont fréquents. Des fichiers plus petits et plus ciblés permettent un développement parallèle, chaque développeur travaillant dans des fichiers distincts.

Efficacité de l'examen du code : L'examen des modifications apportées à des fichiers volumineux nécessite davantage de contexte. Les examinateurs doivent comprendre comment les modifications affectent d'autres codes non liés dans le même fichier. Les fichiers plus petits rendent l'étendue des changements évidente, ce qui accélère les révisions.

Exemples de code

❌ Non conforme :

// utils.js (1500+ lignes)
fonction validateEmail(email) { /* ... */ }
fonction validatePhone(téléphone) { /* ... */ }
fonction formatCurrency(montant) { /* ... */ }
fonction formatDate(date) { /* ... */ }
fonction parseJSON(str) { /* ... */ }
function apiRequest(url) { /* ... */ }
fonction debounce(fn, delay) { /* ... */ }
fonction accélérateur(fn, limit) { /* ... */ }
// ... Plus de 100 autres fonctions non liées

Pourquoi c'est mal : Un fichier massif contient des utilitaires de validation, de formatage, d'analyse, d'appels d'API et de performance. Recherche debounce() nécessite de faire défiler des centaines de fonctions sans rapport les unes avec les autres. Les multiples équipes qui modifient ce fichier créent des conflits de fusion constants.

✅ Conforme :

// validation/email.js
export fonction validateEmail(email) { /* ... */ }

// validation/phone.js
export fonction validatePhone(téléphone) { /* ... */ }

// formatage/monnaie.js
export fonction formatCurrency(montant) { /* ... */ }

// formatage/date.js
export fonction formatDate(date) { /* ... */ }

// api/request.js
export fonction apiRequest(url) { /* ... */ }

// performance/debounce.js
export fonction debounce(fn, delay) { /* ... */ }

Pourquoi cela est-il important ? Chaque fonction utilitaire se trouve dans un fichier dédié au sein de répertoires catégorisés. Recherche debounce() signifie qu'il faut naviguer vers performance/debounce.js directement. Les équipes travaillant sur différents services publics n'entrent pas en conflit parce qu'ils se trouvent dans des fichiers distincts.

Conclusion

Dans la mesure du possible, les fichiers ne doivent pas dépasser 500 lignes. Lorsque les fichiers dépassent cette limite, il convient de rechercher des responsabilités distinctes qui peuvent être extraites dans des modules séparés. Organisez les fichiers apparentés dans des répertoires afin de maintenir la structure tout en gardant les fichiers individuels concentrés et faciles à maintenir.