Introduction

En tant que développeur web (front ou back), tu as probablement déjà rencontré des situations où un simple changement dans le code a causé des bugs dans d'autres parties du système.

Cette situation arrive souvent lorsque le code n'est pas conçu pour être évolutif ou modulaire.

C'est là que notre Principe d'Ouverture/Fermeture (OCP) entre en jeu, c'est 1 des 5 principes fondamentaux du concept de code SOLID.

Nous allons décortiquer ensemble ce principe et voir comment il peut rendre ton code plus robuste, évolutif et facile à maintenir.

C'est quoi ce Principe d'Ouverture/Fermeture (OCP) ?

Ce principe dit que : les entités logicielles (classes, modules, fonctions, etc.) doivent être ouvertes à l'extension mais fermées à la modification.

Cela signifie que tu dois pouvoir ajouter de nouvelles fonctionnalités à une "codebase" sans modifier son code source existant.

En d’autres termes, tu dois pouvoir étendre le comportement du code sans avoir à toucher aux lignes de code déjà testées et validées.

Pourquoi ce principe est-il si important pour notre code ?

Dans le monde du développement web/logiciel, il est super fréquent que les besoins évoluent très rapidement.

Une nouvelle fonctionnalité est requise, un service tiers change d’API, ou les clients demandent de nouveaux comportements.

Si ton code est construit de manière monolithique, tu devras constamment le modifier pour répondre à ces changements, augmentant ainsi les risques de bugs et rendant le système plus difficile à maintenir.

En suivant l'OCP, tu conçois ton code de manière à ce qu'il soit extensible sans toucher aux parties existantes.

Cela conduit à des applications web plus modulaires, où chaque composant est indépendant et les évolutions d'une fonctionnalité ne vont pas créer des bugs dans toute l’application.

Comment mettre en pratique le principe d'OCP ?

Voyons comment appliquer le principe d'Ouverture/Fermeture dans ton code.

1. Utiliser des abstractions :

Une façon de rendre ton code extensible est de le structurer avec des interfaces ou des classes abstraites. Cela permet de définir un comportement général que d’autres entités peuvent implémenter.

Par exemple : tu as un système qui gère différentes méthodes de paiement (carte de crédit, PayPal, ...), tu peux créer une interface Paiement qui définit les méthodes communes comme payer().

Chaque méthode de paiement spécifique (CarteDeCrédit, PayPal, ...) implémente cette interface, te permettant d'ajouter facilement une nouvelle méthode de paiement sans toucher au code existant.

interface Paiement {
  payer(montant: number): void
}

class CarteDeCrédit implements Paiement {
  payer(montant: number): void {
    console.log(`Paiement de ${montant} avec une carte de crédit.`)
  }
}

class PayPal implements Paiement {
  payer(montant: number): void {
    console.log(`Paiement de ${montant} avec PayPal.`)
  }
}

// Ajout d'un nouveau moyen de paiement
class CryptoMonnaie implements Paiement {
  payer(montant: number): void {
    console.log(`Paiement de ${montant} avec une cryptomonnaie.`)
  }
}

2. Éviter les modifications directes du code existant :

Plutôt que de modifier les classes ou fonctions existantes, crée des extensions ou des dérivations qui ajoutent le nouveau comportement. Cela permet de garder le code original intact tout en ajoutant de nouvelles fonctionnalités.

3. Favoriser la composition plutôt que l'héritage excessif :

Dans certains cas, au lieu d’étendre une classe via l’héritage, il est souvent préférable de composer tes objets.

Par exemple, en injectant des dépendances qui implémentent certaines interfaces. Cela rend les modules plus flexibles et moins couplés, ce qui permet d'ajouter facilement de nouveaux comportements.

Exemple avec un site e-commerce :

Supposons que ton site calcule les frais de livraison en fonction du pays. Initialement, tu n'as que deux types de frais : national et international.

Si un jour tu dois ajouter des options comme la livraison express ou des livraisons spécifiques à certaines régions, tu risques de devoir modifier plusieurs parties de ton code.

En suivant l'OCP, tu peux concevoir un système où le calcul des frais de livraison est basé sur des stratégies extensibles sans modification du code existant.

Tu définis une interface FraisDeLivraison et implémente des classes spécifiques pour chaque type de livraison.

Voici un exemple de code :

interface FraisDeLivraison {
  calculer(): number
}

class LivraisonNationale implements FraisDeLivraison {
  calculer(): number {
    return 5.0 // frais fixes pour les livraisons nationales
  }
}

class LivraisonInternationale implements FraisDeLivraison {
  calculer(): number {
    return 20.0 // frais fixes pour les livraisons internationales
  }
}

// Ajout d'une nouvelle option de livraison express
class LivraisonExpress implements FraisDeLivraison {
  calculer(): number {
    return 15.0 // frais pour la livraison express
  }
}

Grâce à cette structure, tu peux ajouter autant d'options de livraison que nécessaire sans toucher au code existant. Il suffit de créer une nouvelle classe qui implémente l'interface.

Les avantages de l'OCP dans ton code :

Réduction des risques de bugs : Puisque tu n’as pas besoin de modifier le code existant, tu réduis le risque d'introduire des régressions ou des bugs involontaires.
Modularité accrue : Chaque nouvelle fonctionnalité est encapsulée dans une entité indépendante, ce qui améliore la lisibilité et la maintenance du code.
Facilité d'évolution : En appliquant le principe OCP, ton code devient plus facilement adaptable aux changements futurs, un atout précieux dans un environnement web où les besoins évoluent rapidement.

Conclusion :

Le Principe d'Ouverture/Fermeture est un pilier central des bonnes pratiques de développement, en particulier dans un domaine aussi changeant que le développement web. En suivant ce principe, tu rends ton code plus extensible, plus fiable, et beaucoup plus facile à maintenir.

En tant que développeur, appliquer l'OCP te permet de mieux gérer la complexité de tes applications et d'offrir un code plus propre et plus solide, capable de résister aux exigences changeantes du web moderne.