Informatique · Qualité du code

SOLID et code propre

Un nouveau moyen de paiement, un export CSV, une autre base de données : les principes SOLID font que chaque demande reste locale.

Déjà à l'aise ? Aller au quiz

Le problème

Ton programme marche. Puis arrive une demande : un nouveau moyen de paiement. Dans un code rigide, elle casse quelque chose ailleurs ; dans un code bien organisé, elle reste locale.

code rigide code modulaire paiement module B module C module D le changement se propage paiement interface module B module C il reste local

Même demande, deux codes : le changement se propage ou reste local.

Une classe de 2 000 lignes qui marche parfaitement : est-ce un problème ?

Ça dépend ? Si elle marche, pourquoi la toucher ?

Garde ta réponse en tête : on la vérifie dans la notion S, dès le chapitre suivant.

Après cette fiche, tu sais

  • énoncer les cinq principes SOLID et reconnaître une violation dans du code ;
  • distinguer le principe d'inversion des dépendances de l'injection de dépendances ;
  • appliquer les règles du code propre : noms, fonctions courtes, commentaires utiles, DRY, KISS, YAGNI ;
  • repérer les code smells et choisir le refactoring qui les soigne, sans changer le comportement.

Cinq lettres, une même idée

Notion 1 · Pourquoi des principes

Des changements qui restent locaux

Un programme qui marche aujourd'hui devra changer demain. Un code propre est un code où ces changements restent locaux : on modifie un endroit sans casser les autres.

Sune raison Oextension Lsous-type Iinterfaces Dabstraction cinq principes, un même but

Les cinq principes SOLID, réunis par Robert C. Martin, organisent les classes dans ce but.2

Responsabilité unique

Single Responsibility. Regrouper ce qui change pour les mêmes raisons, séparer ce qui change pour des raisons différentes.

Ouvert/fermé

Open/Closed. Un module est ouvert à l'extension, fermé à la modification.

Substitution de Liskov

Liskov Substitution. Un sous-type doit pouvoir remplacer son type de base sans surprendre le code qui l'utilise.

Ségrégation des interfaces

Interface Segregation. De petites interfaces, pour que personne ne dépende de ce qu'il n'utilise pas.

Inversion des dépendances

Dependency Inversion. Dépendre dans le sens de l'abstraction : le code métier ne dépend pas des détails techniques.

Des idées plus anciennes que le sigle

Martin a rassemblé ces principes, mais plusieurs existaient avant lui.

1988Bertrand Meyerouvert/fermé 1994Liskov et Wingsubstitution Plus tardRobert C. Martinréunit les cinq des idées plus anciennes que le sigle SOLID

L'ouvert/fermé a été défini par Bertrand Meyer en 1988.7 La substitution porte le nom de Barbara Liskov, qui l'a formalisée avec Jeannette Wing en 1994.3

Qui peut exiger un changement ?

Notion 2 · S comme responsabilité unique

Une seule raison de changer

Une classe ne doit avoir qu'une seule raison de changer. Ces raisons, ce sont des personnes : une classe ne devrait répondre qu'à un seul acteur, un groupe de personnes qui représente un même métier.1

équipe tech marketing comptabilité User name, email

Trois acteurs, trois raisons de changer la même classe.

Le test de l'acteur

Pour chaque méthode, demande-toi qui pourrait exiger qu'elle change. Si deux équipes différentes peuvent le demander, elle n'a pas sa place dans la même classe.

La classe qui fait tout

Fais défiler : une classe qui fait tout est découpée pas à pas. Surveille les étiquettes : chacune est un acteur qui peut exiger un changement.

class User name, email juste les données UserRepository EmailService PdfGenerator saveToDatabase() équipe tech sendEmail() marketing generatePDF() comptabilité 1 classe, 3 métiers mélangés
Étape 1 sur 6 · la God Class

User garde ses données, mais s'enregistre aussi en base, envoie des e-mails et produit son PDF. Une classe qui fait tout : une God Class.

Étape 2 sur 6 · trois acteurs

L'équipe technique change de base, le marketing veut un autre e-mail, la comptabilité une autre mise en page : trois raisons de changer la même classe.

Étape 3 sur 6 · la persistance

L'enregistrement part dans UserRepository. Changer de base de données ne touche plus User.

Étape 4 sur 6 · les e-mails

L'envoi part dans EmailService : le seul endroit que le marketing fera modifier.

Étape 5 sur 6 · le PDF

La mise en page part dans PdfGenerator, l'affaire de la comptabilité.

Étape 6 sur 6 · résultat

User ne garde que ses données, et chaque classe répond à un seul acteur. Plus de classes, mais courtes, testables et indépendantes.

Réponse à ma question : oui, c'est un problème si plusieurs équipes peuvent exiger de la modifier.

Donc ce ne sont pas les lignes qui comptent ?

Exactement. Ce sont les raisons de changer, pas la taille de la classe.
Avant · trois métiersTypeScript
class User {
  saveToDatabase() { … }
  sendEmail() { … }
  generatePDF() { … }
}
Après · un acteur chacuneTypeScript
class User { name; email; }
class UserRepository { save(u) { … } }
class EmailService { send(u) { … } }
class PdfGenerator { render(u) { … } }
Piège : une responsabilité, ce n'est pas une méthode

Une classe Panier peut avoir dix méthodes (ajouter, retirer, calculer le total…) : elles changent toutes pour la même raison. Le principe ne découpe pas au hasard, il sépare ce qui change pour des raisons différentes.

Une forme de plus

Notion 3 · O comme ouvert/fermé

Ajouter sans rouvrir

Un module doit être ouvert à l'extension, fermé à la modification : on ajoute un comportement en écrivant du code nouveau, sans rouvrir du code déjà testé.7

aire() à rouvrir classe ajoutée switch (type) case cercle, case carré case triangle, rouverte Cercle, Carré (inchangées) class Triangle il faut rouvrir rien d'ancien touché

Le même programme, deux manières de grandir.

Le polymorphisme

Le moyen le plus courant est le polymorphisme : plusieurs classes réalisent la même interface, et le code qui s'en sert ne connaît que l'interface.7

« interface » Forme Cercle Carré Triangle le calcul ne connaît que Forme

Ajouter une forme, c'est ajouter une classe.

Un deuxième cas, pas un premier

Créer des interfaces « au cas où » alourdit le code pour rien (voir YAGNI plus bas). On ouvre un point d'extension quand un deuxième cas apparaît vraiment.

Trois formes de plus

Fais défiler : on ajoute le triangle, le rectangle, puis le losange à deux versions du même programme. Compte ce qu'il faut rouvrir dans chacune.

Scène 1 · Ouvert/fermé

Qui faut-il rouvrir pour une forme de plus ?

1 · un switch sur le type function aire(f) { switch (f.type) { case 'cercle': return Math.PI * f.r ** 2; case 'carre': return f.c ** 2; +case 'triangle': return f.b * f.h / 2; +case 'rectangle': return f.l * f.h; +case 'losange': return f.d1 * f.d2 / 2; }} 2 · une interface Forme « interface » Forme aire(): number Cercle Carre Triangle Rectangle Losange

formes 2aire() rouverte 0 foisclasses rouvertes 0

À rouvrir à chaque formeJavaScript
function aire(forme) {
  if (forme.type === 'cercle')
    return Math.PI * forme.r ** 2;
  if (forme.type === 'carre')
    return forme.c ** 2;
  // … un if de plus par forme
}
ExtensibleTypeScript
interface Forme { aire(): number; }
class Cercle implements Forme {
  constructor(private r: number) {}
  aire() { return Math.PI * this.r ** 2; }
}
class Carre implements Forme {
  constructor(private c: number) {}
  aire() { return this.c ** 2; }
}
Piège : tout abstraire d'avance

Créer des interfaces « au cas où » alourdit le code pour rien (voir YAGNI plus bas). On ouvre un point d'extension quand un deuxième cas apparaît vraiment.

Un remplaçant sans surprise

Notion 4 · L comme substitution de Liskov

Un sous-type ne doit pas surprendre

Barbara Liskov et Jeannette Wing l'ont formalisé en 1994 : toute propriété qu'on peut démontrer pour les objets d'un type doit rester vraie pour les objets de ses sous-types.3

En pratique, un code écrit pour la classe mère doit fonctionner, sans surprise, avec n'importe quelle classe fille.

Viole le principeTypeScript
class Oiseau { voler() { … } }
class Pingouin extends Oiseau {
  voler() {
    throw new Error("Je ne vole pas");
  }
}
// oiseaux.forEach(o => o.voler())
// plante dès qu'il y a un pingouin
Le respecteTypeScript
class Oiseau { manger() { … } }
class OiseauVolant extends Oiseau {
  voler() { … }
}
class Pingouin extends Oiseau {
  nager() { … }
}

Le carré, en géométrie

L'exemple le plus célèbre est plus sournois : un carré est bien un rectangle en géométrie…

Un carré est un rectangle, en géométrie rectangle 3 × 2 carré 3 × 3

Mais est-ce un bon sous-type d'un rectangle qu'on peut redimensionner ?

Le contrat de la mère

Une sous-classe doit respecter le contrat de sa mère.

Rectangle (la mère) Carré (la fille) ne demande pas plus : respecté ne promet pas moins : rompu, 16 au lieu de 20 ne lève pas d'erreur imprévue : respecté

Elle ne doit ni exiger davantage, ni promettre moins, ni lever une erreur que la mère ne prévoit pas.

Le test qui trahit le carré

Fais défiler : le même test, écrit pour Rectangle, s'exécute ligne par ligne sur un rectangle et sur un carré.

Scène 2 · Substitution

Même test, deux objets

r.setLargeur(5); r.setHauteur(4); expect(r.aire()).toBe(20); même test new Rectangle(3, 2) new Carre(3) largeur 3 · hauteur 2 largeur 3 · hauteur 3 aire = 6 aire = 9 pas encore testé pas encore testé

Rectangle 3 × 2 = 6Carré 3 × 3 = 9

Le carré n'a rien fait de mal : il est resté carré.

Alors où est le problème ?

Un Rectangle modifiable promet que setLargeur ne touche pas la hauteur. Le Carré ne peut pas tenir cette promesse.
Le test du contratUne sous-classe ne doit ni exiger davantage que sa mère (préconditions plus strictes), ni promettre moins (résultats hors de ce que la mère garantit), ni lever des erreurs que la mère ne prévoit pas. Si elle ne peut pas tenir le contrat, l'héritage est mal choisi : deux classes qui réalisent une même interface Forme font mieux l'affaire.

Des interfaces taillées sur mesure

Notion 5 · I comme ségrégation des interfaces

De petites interfaces ciblées

Des interfaces petites et ciblées, pour qu'aucune classe ne soit forcée de dépendre de méthodes qu'elle n'utilise pas.2

« interface » Travailleur travailler() manger() dormir() Travaillant Mangeant Dormant une interface par rôle, rien d'imposé

Chaque rôle a sa propre interface.

L'interface éclate

Fais défiler : la grosse interface Travailleur se sépare en trois, et chaque classe ne garde que ce dont elle se sert.

Scène 3 · Vue éclatée

Une interface, trois rôles

« interface » Travaillant « interface » Dormant « interface » Travailleur Mangeant travailler() manger() dormir() Robot travailler() { … } manger() { }dormir() { } Humain travailler() { … } manger() { … } dormir() { … }

interfaces 1méthodes vides imposées à Robot 2

Le coût d'une grosse interface

Elle oblige chaque classe à tout implémenter, quitte à écrire des méthodes vides, et tout changement de l'interface touche tout le monde.2

Robot travailler() { … } manger() { } dormir() { } Travaillant Mangeantnon réalisée Dormantnon réalisée

Robot ne réalise que ce dont il se sert.

Personne ne doit dépendre de ce qu'il n'utilise pas.

Interface trop largeTypeScript
interface Travailleur {
  travailler(): void;
  manger(): void;
  dormir(): void;
}
class Robot implements Travailleur {
  travailler() { … }
  manger() { }   // imposée, inutile
  dormir() { }   // imposée, inutile
}
Interfaces séparéesTypeScript
interface Travaillant { travailler(): void; }
interface Mangeant { manger(): void; }
interface Dormant { dormir(): void; }
class Robot implements Travaillant { … }
class Humain
  implements Travaillant, Mangeant, Dormant { … }

Le métier, au centre

Notion 6 · D comme inversion des dépendances

Le métier ne dépend pas des détails

Deux règles : les modules de haut niveau (le métier) ne dépendent pas des modules de bas niveau (base de données, réseau) ; les deux dépendent d'abstractions.2

métier : OrderService dépend de« interface »Database MySQLDatabase PostgresDatabase MockDatabase

Les abstractions ne dépendent pas des détails : ce sont les détails qui dépendent des abstractions.

Couplage fortTypeScript
class OrderService {
  private db = new MySQLDatabase();
  save(order: Order) { this.db.insert(order); }
}
Dépend d'une abstractionTypeScript
class OrderService {
  constructor(private db: Database) {}
  save(order: Order) { this.db.insert(order); }
}
new OrderService(new MySQLDatabase());

Injecter, c'est fournir

Le constructeur reçoit la base au lieu de la créer. La classe métier n'a plus à savoir quelle base la fait tourner.

appelantnew MySQLDatabase() OrderServiceconstructor(db: Database) la dépendance entre par le constructeur

L'injection de dépendances est la technique la plus courante pour appliquer le DIP.

Tester sans base

Pour tester, on remplace la vraie base par une fausse (un mock). Cela n'est possible que si la classe reçoit sa base de l'extérieur.

Dans quel sens vont les flèches ?

Fais défiler : on change deux fois de base de données, d'abord dans la version à couplage fort, puis dans la version inversée. Regarde quelle classe il faut modifier. Les boutons permettent de rejouer chaque cas.

Scène 4 · Inversion des dépendances

Changer de base sans toucher au métier

Piège : DIP et injection de dépendances, ce n'est pas la même chose

Le DIP est un principe sur le sens des dépendances. L'injection de dépendances est une technique : on fournit à un objet ce dont il a besoin (ici, par le constructeur) au lieu qu'il le crée lui-même. C'est la façon la plus courante d'appliquer le DIP, et c'est elle qui permet de passer une fausse base (un mock) pendant les tests.

Exercice · à toi

Quel principe est violé ?

Huit situations tirées de vrais projets. Pour chacune, choisis la lettre de SOLID qui est enfreinte.

Des règles pour chaque ligne

Notion 7 · Le code propre au quotidien

Des noms qui disent l'intention

SOLID organise les classes. Au niveau des lignes, quelques règles simples font la différence entre un code qu'on relit avec plaisir et un code qu'on n'ose plus toucher.6

dne dit rien joursDepuisInscriptiondit ce que c'est

Un bon nom évite un commentaire : getUserById() plutôt que g().

Des fonctions courtes

Des fonctions qui font une seule chose. Si on peut en extraire une partie et lui donner un nom clair, c'est qu'elle en faisait deux.

Peu de paramètres

Dans Clean Code, Robert C. Martin juge l'idéal à zéro, puis un ou deux ; trois sont à éviter autant que possible, et au-delà il faut une très bonne raison. Sinon, on regroupe les paramètres dans un objet.6

Des commentaires du pourquoi

Le code dit quoi ; le commentaire dit pourquoi (une contrainte du client, un contournement de bug).

DRY

DRY (Don't Repeat Yourself) : selon Hunt et Thomas, chaque connaissance doit avoir une représentation unique dans le système.5

taux taux taux taux taux taux TAUX_TVA une seule valeur, à un seul endroit

Ce n'est pas seulement le copier-coller : un taux de TVA écrit en dur à dix endroits viole aussi DRY.

KISS

KISS (Keep It Simple, Stupid) : la solution la plus simple qui répond au besoin, pas la plus impressionnante.

à choisirla plus simplequi répond au besoin à éviterla plus impressionnanteà décoder, pour un besoin simple

Simple ne veut pas dire court : une ligne illisible n'est pas simple.

YAGNI

YAGNI (You Aren't Gonna Need It) : ne pas coder aujourd'hui une fonction « au cas où » on en aurait besoin un jour.

« au cas où » système de plugins appli : PDF seulement le besoin arriveun deuxième formaton l'ajoute alors

Quand le besoin arrive, on l'ajoute, avec ses tests.

Exercice · classer

DRY, KISS ou YAGNI ?

Six situations, trois principes. Touche une situation, puis le principe qu'elle enfreint.

Sentir le problème

Notion 8 · Code smells et refactoring

Sentir le problème, le soigner sans rien casser

Un code smell (expression de Kent Beck, popularisée par Martin Fowler) est un indice visible qui signale souvent un problème plus profond.4

symptôme visible if (age >= 18) problème plus profondune règle cachée18 ? pourquoi ? le code marche, mais il sera pénible à faire évoluer

Ce n'est pas un bug : le code marche, mais il sera pénible à faire évoluer.

Refactoring

Refactoring : modification de la structure interne d'un logiciel qui le rend plus facile à comprendre et moins cher à modifier, sans changer son comportement observable.4

avant f(18, 1) → true après peutSInscrire(18, 1) → true = tests verts avant et après

Il se fait par petites étapes, chacune vérifiée par des tests.

Refactorer pas à pas

Fais défiler : une petite fonction qui sent mauvais est remaniée en quatre étapes. Les tests sont relancés après chacune.

inscription.js étape 1 sur 5 function f(a, b) { if (a >= 18 && b === 1) { return true; } return false; } en rose : noms vides de sens, nombres magiques function peutSInscrire(age, statut) { if (age >= 18 && statut === 1) { return true; } return false; } en jaune : ce qui vient de changer const AGE_MAJORITE = 18; const STATUT_ACTIF = 1; function peutSInscrire(age, statut) { if (age >= AGE_MAJORITE && statut === STATUT_ACTIF) { return true; } return false; } const AGE_MAJORITE = 18; const STATUT_ACTIF = 1; function peutSInscrire(age, statut) { return age >= AGE_MAJORITE && statut === STATUT_ACTIF; } Tests 3 sur 3 verts f(18, 1) → true f(17, 1) → false f(30, 0) → false
Étape 1 sur 5 · le départ

Le code marche : ses trois tests sont verts. Mais f, a et b ne disent rien, et 18 et 1 sont des nombres magiques.

Étape 2 sur 5 · renommer

peutSInscrire(age, statut) dit ce que fait la fonction. L'éditeur met à jour tous les appels, tests compris. On relance : vert.

Étape 3 sur 5 · nommer les constantes

AGE_MAJORITE et STATUT_ACTIF expliquent 18 et 1, et se modifient à un seul endroit. Tests : verts.

Étape 4 sur 5 · simplifier

La condition vaut déjà true ou false : on la renvoie directement, sans if. Tests : verts.

Étape 5 sur 5 · bilan

Quatre petites étapes, des tests relancés après chacune, un comportement identique : c'est ça, un refactoring.

Les smells courants

Le tableau ci-dessous en donne six, avec le remède de chacun.

SmellSymptômeRemède
God Classune classe fait toutextraire des classes (SRP)
Méthode longueon défile pour la lireextraire des fonctions bien nommées
Nombre magiqueif (age >= 18) sans explicationconstante nommée AGE_MAJORITE
Code dupliquéle même bloc à plusieurs endroitsextraire une fonction commune (DRY)
Trop de paramètrescreer(n, p, a, v, t, e)regrouper dans un objet
Code mortjamais exécutéle supprimer (Git le garde)
Exercice · à toi

Quel remède ?

Cinq smells relevés pendant une relecture de code. Choisis le refactoring qui les soigne.

Et maintenant, à toi

Entraînement

Quatre exercices corrigés

1Une classe Bulletin calcule les moyennes des notes (de 1 à 6), les arrondit au demi-point, génère le PDF et l'envoie aux parents. Quels principes sont en jeu et comment découper ?Voir le corrigé

Violation du SRP : le calcul (règlement de l'école), la mise en page et l'envoi changent pour des raisons différentes. On sépare CalculMoyennes, BulletinPdf et EnvoiParents. Si l'envoi se fait par e-mail aujourd'hui et par l'appli de l'école demain, une interface Notification reçue par le constructeur applique en plus le DIP et l'OCP.

2Nettoie : function f(a, b, c, d, e) { if (a > 18 && b === 1) { … } }Voir le corrigé

Trois smells : un nom vide de sens (f), trop de paramètres, des nombres magiques. Par exemple : function peutSInscrire(eleve), un objet eleve au lieu de cinq paramètres, et des constantes nommées pour 18 et 1. Attention à garder > (strictement plus de 18) : un refactoring ne change pas le comportement, à vérifier avec les tests existants.

3Un Carre hérite de Rectangle. setLargeur(w) change aussi la hauteur du carré. Un test fait r.setLargeur(5); r.setHauteur(4); et attend une aire de 20. Que se passe-t-il avec un Carre ?Voir le corrigé

Avec un Carre, setHauteur(4) remet aussi la largeur à 4 : l'aire vaut 16, pas 20. Le code écrit pour Rectangle est surpris : c'est l'exemple classique de violation du LSP. Un carré est un rectangle en géométrie, mais pas un bon sous-type d'un rectangle modifiable. Solution : ne pas les lier par héritage (deux classes qui réalisent une interface Forme).

4La classe Bulletin fait this.stockage = new StockageFichier(); dans son constructeur. Réécris-la pour appliquer le DIP et pouvoir la tester sans écrire de fichier.Voir le corrigé

On crée une abstraction, que le détail technique réalise, et on l'injecte par le constructeur :

interface Stockage { enregistrer(texte: string): void; }
class StockageFichier implements Stockage {
  enregistrer(texte: string) { /* écrit un fichier */ }
}
class Bulletin {
  constructor(private stockage: Stockage) {}
  publier(texte: string) { this.stockage.enregistrer(texte); }
}
// en production : new Bulletin(new StockageFichier())
// en test : new Bulletin(new StockageMemoire())

Bulletin ne dépend plus que de Stockage. En test, une classe StockageMemoire qui garde le texte dans une variable suffit.

À retenir

La fiche en huit lignes

S · responsabilité uniqueune classe, un acteur, une seule raison de changer.
O · ouvert/ferméajouter du code plutôt que rouvrir du code testé.
L · substitution de Liskovune classe fille remplace sa mère sans surprise : contrat respecté.
I · ségrégation des interfacesde petites interfaces : personne ne dépend de ce qu'il n'utilise pas.
D · inversion des dépendancesle métier dépend d'abstractions ; l'injection de dépendances est l'outil.
Code proprenoms clairs, fonctions courtes, peu de paramètres, commentaires du pourquoi.
DRY, KISS, YAGNIune connaissance à un seul endroit, la solution la plus simple, rien « au cas où ».
Refactoringsoigner les smells par petites étapes, sans changer le comportement, sous tests.
Dernière étape : le quiz. Douze questions tirées au hasard, différentes à chaque partie. Si tu te trompes, lis bien l'explication.
Quiz final

Teste-toi

Sources

  1. Robert C. Martin, The Single Responsibility Principle, The Clean Code Blog, 8 mai 2014 (« This principle is about people »). blog.cleancoder.com, consulté le 8 octobre 2026.
  2. Robert C. Martin, Solid Relevance, The Clean Code Blog, 18 octobre 2020 (les cinq principes en une phrase). blog.cleancoder.com, consulté le 8 octobre 2026.
  3. Barbara H. Liskov et Jeannette M. Wing, A Behavioral Notion of Subtyping, ACM Transactions on Programming Languages and Systems, vol. 16, no 6, novembre 1994, p. 1811-1841. cs.cmu.edu (PDF), consulté le 8 octobre 2026.
  4. Martin Fowler, Code Smell, 9 février 2006, et Refactoring (définition). martinfowler.com, refactoring.com, consulté le 8 octobre 2026.
  5. Andy Hunt et Dave Thomas, The Pragmatic Programmer, édition du 20e anniversaire, astuce 15 « DRY ». pragprog.com, consulté le 8 octobre 2026.
  6. Robert C. Martin, Clean Code: A Handbook of Agile Software Craftsmanship, Prentice Hall, 2008 (noms, fonctions, arguments, commentaires).
  7. Robert C. Martin, The Open Closed Principle, The Clean Code Blog, 12 mai 2014 (« In 1988 Bertrand Meyer defined… »). blog.cleancoder.com, consulté le 8 octobre 2026.

Fiche relue et sourcée en septembre 2026, refaite en récit en octobre 2026.

Glisser pour continuer vers TDD et CI/CD
Université