Principes SOLID en PHP : théorie et pratique pour un code propre

Principes SOLID en PHP : théorie et pratique

SOLID est l'acronyme de cinq principes fondamentaux de la programmation orientée objet, formulés par Robert Martin (Uncle Bob). Ces principes aident à créer un code flexible, maintenable et évolutif. Dans cet article, nous analyserons chaque principe avec des exemples en PHP et montrerons comment les appliquer dans des projets réels.

1. Single Responsibility Principle (SRP) — Principe de responsabilité unique

Essence : Chaque classe doit avoir une seule raison de changer. Autrement dit, une classe doit être responsable d'une seule tâche.

Violation du SRP :

class Order {    public function calculateTotal() { /* ... */ }    public function saveToDatabase() { /* ... */ }    public function sendEmailNotification() { /* ... */ }}

Ici, la classe Order est responsable à la fois du calcul, de la sauvegarde et de l'envoi de notifications. Cela viole le SRP.

Solution :

class Order {    public function calculateTotal() { /* ... */ }}

class OrderRepository {    public function save(Order $order) { /* ... */ }}

class EmailNotificationService {    public function sendOrderConfirmation(Order $order) { /* ... */ }}

Maintenant, chaque classe a une responsabilité claire et unique, ce qui simplifie les tests et les modifications.

2. Open-Closed Principle (OCP) — Principe d'ouverture/fermeture

Essence : Les classes doivent être ouvertes à l'extension, mais fermées à la modification. Vous devez pouvoir ajouter de nouvelles fonctionnalités sans modifier le code existant.

Violation de l'OCP :

class PaymentProcessor {    public function process($type) {        if ($type == 'credit_card') {            // traitement de la carte de crédit        } elseif ($type == 'paypal') {            // traitement PayPal        }    }}

Pour ajouter un nouveau mode de paiement, il faudrait modifier la classe PaymentProcessor.

Solution avec utilisation d'interfaces :

interface PaymentMethod {    public function process();}

class CreditCardPayment implements PaymentMethod {    public function process() { /* ... */ }}

class PayPalPayment implements PaymentMethod {    public function process() { /* ... */ }}

class PaymentProcessor {    public function process(PaymentMethod $method) {        $method->process();    }}

Maintenant, pour ajouter un nouveau mode de paiement, il suffit de créer une nouvelle classe implémentant l'interface PaymentMethod, sans modifier le code existant.

3. Liskov Substitution Principle (LSP) — Principe de substitution de Barbara Liskov

Essence : Les objets des sous-classes doivent être interchangeables avec les objets de la classe de base sans compromettre la correction du programme. Une sous-classe ne doit pas modifier le comportement attendu de la classe de base.

Violation du LSP :

class Rectangle {    protected $width;    protected $height;

    public function setWidth($w) { $this->width = $w; }    public function setHeight($h) { $this->height = $h; }    public function getArea() { return $this->width * $this->height; }}

class Square extends Rectangle {    public function setWidth($w) {        $this->width = $w;        $this->height = $w; // violation du principe    }    public function setHeight($h) {        $this->height = $h;        $this->width = $h; // violation du principe    }}

Si le code client s'attend à ce que la modification de la largeur n'affecte pas la hauteur, alors Square violera cette attente.

Solution : Évitez l'héritage si la sous-classe ne correspond pas entièrement au comportement du parent. Il est préférable d'utiliser la composition ou des classes séparées :

interface Shape