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 de plusieurs milliers de lignes traitent généralement de préoccupations multiples et non liées, ce qui rend difficile la localisation de fonctionnalités spécifiques. Un fichier de 3000 lignes utils.js un fichier contenant des helpers de validation, du formatage de chaînes de caractères, de la manipulation de dates et des utilitaires d'API force les développeurs à parcourir du code non pertinent pour trouver ce dont ils ont besoin. Les fichiers volumineux créent également des conflits de fusion lorsque plusieurs développeurs modifient différentes sections simultanément.

Pourquoi c'est important

Maintenabilité du code : Les fichiers volumineux mélangent des fonctionnalités sans rapport, obligeant les développeurs à comprendre des centaines de lignes de code non pertinentes pour modifier une seule fonction. Trouver une logique spécifique devient un exercice de recherche plutôt que de naviguer vers un fichier nommé de manière appropriée.

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

Efficacité de la revue de code : L'examen des modifications dans les fichiers volumineux nécessite plus de contexte. Les relecteurs doivent comprendre comment les modifications affectent d'autres codes non liés dans le même fichier. Des fichiers plus petits rendent la portée des modifications évidente, accélérant ainsi les revues.

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 incorrect : Un fichier massif contient des utilitaires de validation, de formatage, d'analyse syntaxique, d'appels API et de performance. Trouver debounce() Nécessite de faire défiler des centaines de fonctions sans rapport. Plusieurs équipes modifiant 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 c'est important : Chaque fonction utilitaire dans un fichier dédié au sein de répertoires catégorisés. La recherche debounce() signifie naviguer vers performance/debounce.js directement. Les équipes travaillant sur différentes utilitaires n'entrent pas en conflit car elles sont dans des fichiers distincts.

Conclusion

Maintenez les fichiers sous 500 lignes lorsque cela est possible. Lorsque les fichiers dépassent cette limite, recherchez les responsabilités distinctes qui peuvent être extraites dans des modules séparés. Organisez les fichiers connexes dans des répertoires pour maintenir la structure tout en gardant les fichiers individuels ciblés et maintenables.