Formations — 1 037 leçons en français

Accueil › Architecture & design patterns › Les principes SOLID

Les principes SOLID — entretien Architecture & design patterns

14 questions posées en entretien sur 5 sujets, avec la bonne réponse et son explication.

Responsabilité unique

Que signifie « une seule responsabilité » pour une classe ?

  1. Elle n'a qu'une seule raison de changer ✓
  2. Elle n'expose qu'une seule méthode publique
  3. Elle n'a qu'une seule instance dans l'application
  4. Elle ne dépend que d'un seul autre module

Pourquoi : Le principe parle d'axes d'évolution, pas de taille ni de nombre de méthodes. Ce qui distingue une bonne réponse d'une réponse correcte, c'est d'ajouter le critère opérationnel : nommer les personnes qui peuvent demander de modifier ce fichier. Deux rôles, deux responsabilités.

Niveau junior

Quel est le coût le plus concret d'une fonction qui calcule, met en forme et envoie ?

function envoyerFacture(commande) {
  let montant = 0;
  for (const l of commande.lignes) montant += l.prix * l.qte;
  const corps = "Vous devez " + montant + " EUR.";
  courrier.envoyer(commande.email, corps);
}
  1. Tester la règle de calcul oblige à simuler l'envoi de courriel ✓
  2. La boucle est moins rapide qu'un reduce
  3. La fonction ne peut pas être exportée
  4. Le montant risque de dépasser la précision des nombres

Pourquoi : Le calcul n'est accessible qu'à travers un effet de bord : pour vérifier une règle de TVA, il faut un faux service de courriel. Une bonne réponse va plus loin que « ça viole SRP » et nomme le coût mesurable — temps d'écriture des tests, et régressions qui traversent d'un axe à l'autre.

Niveau confirme

Deux traitements du même fichier sont modifiés par les mêmes commits depuis deux ans. Que conclure ?

  1. Ils partagent un seul axe de changement : les séparer n'apporterait rien ✓
  2. Le fichier viole SRP puisqu'il contient deux traitements
  3. Il faut les séparer et introduire une interface entre les deux
  4. L'historique n'apporte aucune information sur la conception

Pourquoi : Deux parties qui changent toujours ensemble forment une seule responsabilité ; les séparer crée deux fichiers qu'on modifiera toujours en paire, avec un aller-retour de lecture à chaque fois. L'historique Git est ici un indicateur objectif, là où l'intuition de découpage se trompe souvent.

Niveau senior

Ouvert/fermé

Une fonction est « fermée à l'extension » lorsque…

  1. Traiter un cas nouveau oblige à modifier son code ✓
  2. Elle est déclarée avec const
  3. Elle ne possède pas de paramètre optionnel
  4. Elle n'est pas exportée par son module

Pourquoi : Le critère est purement opérationnel : si le cas nouveau impose de rouvrir le code, la fonction est fermée à l'extension. Ce qui fait une bonne réponse, c'est d'enchaîner sur le coût — tous les tests de la fonction sont à relancer, y compris ceux des cas qui n'ont pas bougé.

Niveau junior

Pourquoi une table de correspondance ouvre-t-elle mieux à l'extension qu'une cascade de « if » ?

  1. Un cas nouveau s'ajoute sans modifier le code existant ni ses tests ✓
  2. Elle évite tout parcours linéaire et gagne en vitesse
  3. Elle supprime le besoin de valeur par défaut
  4. Elle rend l'héritage inutile dans tous les cas

Pourquoi : L'argument n'est pas la performance mais le périmètre de la modification : une entrée ajoutée ne touche aucune branche existante. À l'inverse, dans une cascade, **l'ordre des branches fait partie du comportement**, et insérer un `if` au mauvais endroit change un cas qu'on ne regardait pas.

Niveau confirme

Ségrégation des interfaces

Que demande la ségrégation des interfaces ?

  1. Qu'aucun client ne dépende de méthodes qu'il n'utilise pas ✓
  2. Que chaque interface ne déclare qu'une seule méthode
  3. Que les interfaces soient toutes regroupées dans un même paquet
  4. Que toute classe implémente au moins une interface

Pourquoi : Le principe raisonne du point de vue de l'appelant. Le réduire à « une méthode par interface » est l'erreur classique : elle produit des dizaines de contrats que personne ne sait nommer. Le bon critère est l'usage réellement observé chez les clients.

Niveau junior

Un test doit écrire sept méthodes vides pour n'en appeler qu'une. Que révèle ce symptôme ?

  1. Le client dépend de méthodes qu'il n'utilise pas : l'interface est trop large ✓
  2. Le test est mal écrit et devrait utiliser la vraie implémentation
  3. Le module testé a trop de responsabilités
  4. Il manque une classe de base abstraite

Pourquoi : La taille de la doublure mesure exactement la dépendance inutile. C'est l'indicateur le plus fiable d'une interface grasse, parce qu'il est observable sans discussion de goût. Attribuer le symptôme à SRP est l'erreur voisine : ici le module testé peut être parfaitement cohérent, c'est le **contrat** qu'il réclame qui est trop large.

Niveau confirme

Une implémentation lève « opération non supportée » sur une méthode du contrat. Quels principes sont en cause ?

  1. Ségrégation des interfaces et substitution de Liskov à la fois ✓
  2. Responsabilité unique uniquement
  3. Ouvert/fermé uniquement
  4. Aucun : lever une erreur explicite est la bonne pratique

Pourquoi : Le contrat promet une capacité que l'objet n'a pas : l'appelant dépend d'une méthode inutilisable (ISP) et tient un objet non substituable à son type déclaré (Liskov). La correction est la même pour les deux — deux contrats séparés, pour que l'incompatibilité apparaisse à l'écriture du code plutôt qu'à l'exécution.

Niveau senior

Substitution de Liskov

Comment énonce-t-on le principe de substitution de Liskov ?

  1. Un sous-type doit pouvoir remplacer son type de base sans que l'appelant s'en aperçoive ✓
  2. Une classe ne doit jamais être héritée plus d'une fois
  3. Une classe fille doit redéfinir toutes les méthodes de sa mère
  4. L'héritage doit se limiter à deux niveaux de profondeur

Pourquoi : Le principe porte sur le **contrat**, pas sur la forme de la hiérarchie. Une bonne réponse ajoute les trois règles pratiques : préconditions assouplies, postconditions renforcées, aucune exception nouvelle. C'est ce triplet que le recruteur attend derrière la formule.

Niveau junior

Que peut faire un sous-type sans violer la substitution de Liskov ?

  1. Accepter plus d'entrées que sa base et garantir davantage en retour ✓
  2. Exiger un argument que la base acceptait absent
  3. Lever un type d'exception que la base ne lève pas
  4. Rendre une valeur en dehors de l'intervalle promis par la base

Pourquoi : Les préconditions ne peuvent qu'être **assouplies**, les postconditions que **renforcées**. Les trois autres propositions sont les violations classiques, et elles cassent un appelant pourtant correct au regard du contrat de base. Le test pratique à citer : rejouer la suite de tests du type de base contre chaque sous-type.

Niveau senior

Qu'affiche ce code ?

class Rectangle {
  constructor(l, h) { this.l = l; this.h = h; }
  setHauteur(v) { this.h = v; }
  aire() { return this.l * this.h; }
}
class Carre extends Rectangle {
  setHauteur(v) { this.l = v; this.h = v; }
}

function hauteurA10(r) { r.setHauteur(10); return r.aire(); }
console.log(hauteurA10(new Rectangle(2, 3)), hauteurA10(new Carre(2, 2)));
  1. 20 100 ✓
  2. 20 20
  3. 30 100
  4. 20 50

Pourquoi : Le rectangle devient 2×10, soit 20. Le carré, lui, modifie aussi sa largeur et donne 100 alors que l'appelant attendait 20. L'exemple montre que la relation « est un » de la langue courante ne dit rien du contrat : la sortie propre n'est pas de corriger la hiérarchie mais de rendre les formes immuables, ce qui supprime le mutateur à durcir.

Niveau senior

Inversion de dépendance

Cette fonction reçoit sa dépendance en paramètre. La dépendance est-elle inversée ?

function facturerAbonnes(sql) {
  return sql
    .query("SELECT * FROM clients WHERE actif")
    .map(montantDu);
}
  1. Non : le contrat parle SQL, donc le métier dépend encore de la base ✓
  2. Oui : la dépendance est passée en paramètre, c'est la définition
  3. Oui, à condition que sql soit déclaré comme une interface
  4. Non, parce qu'il faudrait un conteneur d'injection

Pourquoi : L'injection est bien là, l'inversion non. Passer à une API HTTP oblige toujours à rouvrir la facturation, puisque le contrat impose une requête SQL. Le signe d'une inversion réelle est que l'abstraction emploie le vocabulaire du métier — `clientsActifs()` — et appartient au module qui l'utilise.

Niveau confirme

Pourquoi un appel direct à « Date.now() » dans une règle métier pose-t-il problème ?

  1. C'est une dépendance de bas niveau non inversée : le test devient non reproductible ✓
  2. L'appel est trop lent pour une boucle
  3. Le résultat n'est pas sérialisable en JSON
  4. Il faut toujours lui préférer une chaîne ISO

Pourquoi : L'horloge est une dépendance externe comme la base ou le réseau. Tant qu'elle est appelée à l'intérieur, le même test peut passer en juin et échouer le 31 décembre. Recevoir la date — ou une fonction d'horloge fournie au point de composition — rend le scénario rejouable à volonté.

Niveau confirme

Dans une architecture en couches, où doit vivre l'interface du dépôt pour que la dépendance soit inversée ?

  1. Avec le module métier qui l'utilise, écrite avec son vocabulaire ✓
  2. Dans la couche de persistance, au plus près de l'implémentation
  3. Dans un module technique partagé qui rassemble toutes les interfaces
  4. Peu importe l'emplacement, seule l'existence de l'interface compte

Pourquoi : Si l'interface appartient à la couche technique, le métier dépend encore d'un contrat dicté par la base : l'indirection a coûté sans rien inverser. C'est exactement ce que décrivent les architectures hexagonale et en oignon — le domaine définit les ports, les adaptateurs s'y plient.

Niveau senior

S'entraîner sur ces questions, chronométré →