Clean Code — Chapitre 16 : Refactoring d'une classe legacy
Le chapitre 16 est le cas d'étude le plus long du livre. Martin y refactorise une classe Java complète ligne par ligne — SerialDate, une classe de manipulation de dates. C'est un exercice de refactoring chirurgical : il montre comment transformer du code médiocre en code propre en appliquant systématiquement tous les principes du livre.
💡 L'idée clé du chapitre en une phrase :
« Même du code fonctionnel et testé peut être amélioré. Le refactoring n'est pas un événement ponctuel, c'est une discipline continue. »
- Noms descriptifs — Chaque variable, fonction, classe doit révéler son intention
- Petites fonctions — Une fonction = une action, <10 lignes idéalement
- Éliminer la duplication — DRY appliqué sans concession
- Immutabilité — Préférer readonly et const, éviter les mutations
1. L'approche du refactoring — méthodique et discipliné
Martin ne refactorise pas au hasard. Il suit une méthode systématique : lire le code, identifier les problèmes, refactorer par petits pas, tester continuellement.
🔵 Règle d'or du refactoring : Ne jamais changer le comportement observable pendant un refactoring. Les tests doivent rester verts à chaque étape. Si vous ajoutez une fonctionnalité, faites un commit séparé.
🎯 Les 4 étapes du refactoring méthodique
- Lire et comprendre — Comprendre ce que fait le code, même s'il est sale
- Identifier les code smells — Noms vagues, fonctions longues, duplication, mutabilité
- Refactorer par petits pas — Un changement à la fois, tests verts entre chaque
- Valider avec les tests — Si un test casse, annuler et recommencer différemment
2. Principes appliqués — tous les chapitres réunis
Le chapitre 16 est une synthèse pratique. Martin applique tous les principes du livre sur un exemple réel.
Noms révélateurs
Remplacer d par dayOfMonth,
m par month. Chaque nom doit être
auto-documenté.
Fonctions courtes
Une fonction = une action. Extraire les blocs logiques en fonctions nommées. Viser <10 lignes.
DRY
Éliminer toute duplication. Factoriser les calculs répétés, les validations, les conversions.
Immutabilité
Préférer readonly et const. Les objets
immutables sont plus faciles à raisonner.
SRP
Une classe = une responsabilité. Séparer parsing, validation, calculs, formatage.
Types explicites
Utiliser des enums au lieu de constantes numériques. Types forts pour éviter les erreurs.
3. Cas d'étude : Refactoring d'une classe DateUtils
Adaptons l'exemple de Martin au monde TypeScript/React. Imaginons une classe utilitaire de dates héritée d'un projet legacy.
❌ AVANT — Code legacy (sale mais fonctionnel)
// ══════════════════════════════════════════════════════════════
// Version LEGACY — Code historique avec de nombreux problèmes
// ══════════════════════════════════════════════════════════════
class DateUtils {
// ❌ Constantes magiques non typées
static MONDAY = 1;
static TUESDAY = 2;
static WEDNESDAY = 3;
// ... etc
// ❌ Nom vague + paramètres pas clairs
static d(d: number, m: number, y: number): Date {
return new Date(y, m - 1, d);
}
// ❌ Fonction trop longue (30+ lignes)
static daysBetween(d1: Date, d2: Date): number {
let result = 0;
let current = new Date(d1);
// Boucle inefficace
while (current < d2) {
result++;
current.setDate(current.getDate() + 1);
}
return result;
}
// ❌ Duplication de logique
static isWeekend(d: Date): boolean {
const day = d.getDay();
if (day === 0) return true; // Dimanche
if (day === 6) return true; // Samedi
return false;
}
static isWeekday(d: Date): boolean {
const day = d.getDay();
if (day === 0) return false; // Dimanche
if (day === 6) return false; // Samedi
return true;
}
// ❌ Mutation du paramètre
static addDays(date: Date, days: number): Date {
date.setDate(date.getDate() + days);
return date; // ⚠️ Modifie l'objet original !
}
// ❌ Logique enfouie, difficile à comprendre
static getQuarter(date: Date): number {
const m = date.getMonth() + 1;
if (m <= 3) return 1;
if (m <= 6) return 2;
if (m <= 9) return 3;
return 4;
}
}
// ══════════════════════════════════════════════════════════════
// Problèmes identifiés :
// ══════════════════════════════════════════════════════════════
// 1. Noms cryptiques (d, m, y)
// 2. Constantes numériques (1, 2, 3 pour jours)
// 3. Fonctions trop longues
// 4. Duplication (isWeekend/isWeekday)
// 5. Mutations (addDays modifie l'original)
// 6. Logique inefficace (daysBetween)
// 7. Pas de types forts (DayOfWeek = number)
✅ APRÈS — Code refactorisé (propre et maintenable)
// ══════════════════════════════════════════════════════════════
// Version REFACTORED — Application systématique des principes
// ══════════════════════════════════════════════════════════════
// ✅ 1. Types forts pour éviter les erreurs
enum DayOfWeek {
Sunday = 0,
Monday = 1,
Tuesday = 2,
Wednesday = 3,
Thursday = 4,
Friday = 5,
Saturday = 6,
}
enum Quarter {
Q1 = 1,
Q2 = 2,
Q3 = 3,
Q4 = 4,
}
// ✅ 2. Interface immutable pour les dates
interface ImmutableDate {
readonly year: number;
readonly month: number; // 1-12
readonly day: number; // 1-31
}
// ✅ 3. Classe refactorée avec fonctions courtes et nommées
class DateUtils {
// ✅ Nom explicite, pas de mutation
static createDate(year: number, month: number, day: number): Date {
return new Date(year, month - 1, day);
}
// ✅ Algorithme efficace (pas de boucle)
static daysBetween(startDate: Date, endDate: Date): number {
const millisecondsPerDay = 1000 * 60 * 60 * 24;
const differenceInMilliseconds = endDate.getTime() - startDate.getTime();
return Math.floor(differenceInMilliseconds / millisecondsPerDay);
}
// ✅ DRY : une seule fonction, pas de duplication
static isWeekend(date: Date): boolean {
const dayOfWeek = date.getDay();
return dayOfWeek === DayOfWeek.Saturday || dayOfWeek === DayOfWeek.Sunday;
}
static isWeekday(date: Date): boolean {
return !this.isWeekend(date);
}
// ✅ Immutabilité : retourne une nouvelle date
static addDays(date: Date, daysToAdd: number): Date {
const newDate = new Date(date);
newDate.setDate(newDate.getDate() + daysToAdd);
return newDate;
}
// ✅ Retour typé + logique claire
static getQuarter(date: Date): Quarter {
const month = date.getMonth() + 1; // 1-12
if (month <= 3) return Quarter.Q1;
if (month <= 6) return Quarter.Q2;
if (month <= 9) return Quarter.Q3;
return Quarter.Q4;
}
// ✅ Fonction extraite pour clarté
static getDayOfWeek(date: Date): DayOfWeek {
return date.getDay() as DayOfWeek;
}
// ✅ Validation explicite
static isValidDate(year: number, month: number, day: number): boolean {
if (month < 1 || month > 12) return false;
if (day < 1 || day > 31) return false;
const date = new Date(year, month - 1, day);
return date.getMonth() === month - 1 && date.getDate() === day;
}
// ✅ Formatage séparé de la logique métier
static formatISO(date: Date): string {
return date.toISOString().split("T")[0];
}
}
// ══════════════════════════════════════════════════════════════
// Améliorations apportées :
// ══════════════════════════════════════════════════════════════
// 1. ✅ Noms explicites (createDate, daysBetween)
// 2. ✅ Types forts (enum DayOfWeek, Quarter)
// 3. ✅ Fonctions courtes (<10 lignes)
// 4. ✅ DRY (isWeekend réutilisé par isWeekday)
// 5. ✅ Immutabilité (addDays retourne nouvelle date)
// 6. ✅ Algorithme efficace (pas de boucle)
// 7. ✅ SRP (formatage séparé de logique)
4. Insights du refactoring — leçons apprises
Martin partage des insights précieux tout au long du refactoring. Voici les plus importants adaptés à TypeScript/React.
Leçons clés du refactoring
💡 Les commentaires mentent
Les commentaires deviennent obsolètes. Le code doit être auto-documenté via des noms clairs. Un bon nom vaut mieux qu'un commentaire.
💡 Les constantes magiques sont dangereuses
if (day === 6) est obscur.
if (day === DayOfWeek.Saturday) est clair. Toujours
utiliser des enums ou constantes nommées.
💡 L'immutabilité simplifie le raisonnement
Une fonction qui mute ses paramètres est une source de bugs. Toujours
retourner une nouvelle valeur. TypeScript aide avec
readonly.
💡 La duplication masque l'intention
Deux fonctions qui font presque la même chose créent de la confusion. Factoriser révèle l'abstraction sous-jacente.
💡 Le refactoring est incrémental
Ne pas essayer de tout refactorer d'un coup. Petits pas, tests verts, commits fréquents. Une amélioration à la fois.
💡 Les tests sont le filet de sécurité
Sans tests, le refactoring est du bricolage risqué. Avec tests, c'est de l'ingénierie. Investir dans les tests avant de refactorer.
5. Métriques avant/après — impact mesurable
Le refactoring ne se juge pas aux impressions. Voici des métriques concrètes qui montrent l'amélioration.
Impact du refactoring — Métriques
✅ Bénéfices mesurables du refactoring :
- -28% de lignes — Code plus concis, moins à maintenir
- -61% de longueur de fonction — Fonctions plus faciles à comprendre
- -62% de complexité — Code plus simple, moins de bugs potentiels
- 0% de duplication — DRY respecté, maintenance simplifiée
- +104% de couverture — Tests robustes, confiance pour évoluer
Tableau récapitulatif — Code smells éliminés
| Code Smell | Avant | Après | Technique appliquée |
|---|---|---|---|
| Noms cryptiques | d(d, m, y) |
createDate(year, month, day) |
Rename Method |
| Constantes magiques | day === 6 |
day === DayOfWeek.Saturday |
Extract Enum |
| Fonction longue | 30 lignes | 7 lignes | Extract Function |
| Duplication | isWeekend/isWeekday dupliqués | isWeekday = !isWeekend | Remove Duplication |
| Mutation | date.setDate(...) |
new Date(...) |
Replace Mutation |
| Algorithme inefficace | Boucle while | Calcul mathématique | Replace Algorithm |
À Retenir — Chapitre 16 Clean Code
- Le refactoring est une discipline — Méthodique, incrémental, guidé par les tests. Pas de changements au hasard.
- 4 étapes systématiques — Lire → Identifier smells → Refactorer par petits pas → Valider tests.
- Tous les principes appliqués — Noms clairs, fonctions courtes, DRY, immutabilité, SRP, types forts.
- Types forts en TypeScript — Enums pour constantes, interfaces pour contrats, readonly pour immutabilité.
- Immutabilité par défaut — Ne jamais muter les paramètres. Retourner de nouvelles valeurs.
- DRY sans concession — Éliminer toute duplication. Factoriser révèle les abstractions.
- Tests = filet de sécurité — Couverture 90%+ avant refactoring. Tests verts à chaque étape.
- Métriques objectives — Mesurer l'impact (lignes, complexité, duplication, couverture). Le refactoring doit être mesurable.
⏱️ Temps pour refactorer une classe legacy : ~1-3 jours selon la taille (200-500 lignes). L'investissement est rentable : -60% de complexité, 0 bugs introduits, maintenance future simplifiée.