La bonne approche de la programmation PHP : conseils pratiques et exemples

Un code fiable et maintenable est l'épine dorsale de tout projet PHP réussi. Pour y parvenir, nous pouvons écrire du code selon les principes SOLID. Ces principes incluent le principe de responsabilité unique (SRP), le principe ouvert-fermé (OCP), le principe de substitution de Liskov (LSP), le principe de ségrégation d'interface (ISP) et le principe d'inversion de dépendance (DIP).

Principe de responsabilité unique (SRP)

Le principe de responsabilité unique stipule qu'une classe ne devrait avoir qu'une seule raison de changer. En PHP, cela signifie qu'une classe doit avoir une seule responsabilité. Une telle conception peut améliorer la maintenabilité et la lisibilité du code.

Mauvais exemple - Responsabilités mixtes

class  User
 { 
    public  function  verify ( $username , $password ) { /* ... */ } 
    public  function  sendEmail ( $message ) { /* ... */ } 
}

Bon exemple - Responsabilité unique

class  UserAuthenticator
 { 
    public  function  verify ( $username , $password ) { /* ... */ } 
} 
class EmailSender
 {
     public  function  sendEmail ( $message ) { /* ... */ }
}

Principe d'ouverture-fermeture (OCP)

Le principe d'ouverture-fermeture stipule qu'une classe doit être ouverte à l'extension, mais non ouvert à l'extension La modification est fermée. En PHP, on peut implémenter ce principe à l'aide d'interfaces et de classes abstraites. En définissant des interfaces et des classes abstraites, nous pouvons étendre les fonctionnalités sans modifier le code existant.

Mauvais exemple - modification directe

class Square
{
    public $side;
    public function __construct($side)
    {
        $this->side = $side;
    }
}
class AreaCalculator
{
    public function calculate($shapes)
    {
        $area = 0;
        foreach ($shapes as $shape) {
            if ($shape instanceof Square) {
                $area += $shape->side * $shape->side;
            } elseif ($shape instanceof Circle) {
                $area += pi() * $shape->radius * $shape->radius;
            }
        }
        return $area;
    }
}

Bon exemple - ouvert à l'extension

interface Shape
{
    public function area();
}
class Square implements Shape
{
    private $side;
    public function __construct($side)
    {
        $this->side = $side;
    }
    public function area()
    {
        return $this->side * $this->side;
    }
}
class Circle implements Shape
{
    private $radius;
    public function __construct($radius)
    {
        $this->radius = $radius;
    }
    public function area()
    {
        return pi() * $this->radius * $this->radius;
    }
}

Principe de substitution de Lishkov (LSP)

Le principe de substitution de Liskov stipule que les objets des superclasses doivent pouvoir utiliser des sous-classes. Remplacement d'objet sans affecter l'exactitude du programme. En PHP, adhérer à ce principe garantit qu'une classe dérivée conserve le contrat de sa classe de base. Cela garantit la cohérence et la fiabilité du code.

Mauvais exemple - Violation de LSP

class Bird
{
    public function fly() { /* ... */ }
}
class Ostrich extends Bird
{
    public function fly() { throw new Exception("鸵鸟不能飞"); }
}

Bon exemple - Suivre LSP

interface Bird
{
    public function fly();
}
class Sparrow implements Bird
{
    public function fly() { /* ... */ }
}
class Ostrich implements Bird
{
    public function fly() { /* ... */ }
}

Principe d'isolation d'interface (ISP)

Le principe d'isolation d'interface stipule que les clients ne devraient pas être obligés de s'appuyer sur des choses qu'ils ne sont pas en utilisant l'interface. En PHP, cela signifie créer des interfaces plus petites et plus ciblées plutôt que de grandes interfaces monolithiques. Cette conception améliore la flexibilité et la maintenabilité du code.

Mauvais exemple - Abcès d'interface

interface Worker
{
    public function work();
    public function eat();
    public function sleep();
}

Bon exemple - Isolation d'interface

interface Workable
{
    public function work();
}
interface Eatable
{
    public function eat();
}
interface Sleepable
{
    public function sleep();
}

Principe d'inversion de dépendance (DIP)

Le principe d'inversion de dépendance stipule que les modules de haut niveau ne doivent pas dépendre des modules de bas niveau , mais les deux devraient s'appuyer sur l'abstraction. En PHP, nous pouvons utiliser l'injection de dépendances et l'abstraction pour découpler les classes. Cela améliore la testabilité et la maintenabilité de votre code.

Mauvais exemple - les modules de haut niveau dépendent des modules de bas niveau

class LightBulb
{
    public function turnOn() { /* ... */ }
    public function turnOff() { /* ... */ }
}
class Switch
{
    private $bulb;
    public function __construct()
    {
        $this->bulb = new LightBulb();
    }
    public function operate()
    {
        // Operate the bulb
    }
}

Bon exemple - abstraction et injection de dépendances

interface Switchable
{
    public function turnOn();
    public function turnOff();
}
class LightBulb implements Switchable
{
    public function turnOn() { /* ... */ }
    public function turnOff() { /* ... */ }
}
class Switch
{
    private $device;
    public function __construct(Switchable $device)
    {
        $this->device = $device;
    }
    public function operate()
    {
        // Operate the device
    }
}

En conclusion, écrire du code PHP qui adhère aux principes SOLID est essentiel pour créer un code maintenable et évolutif. applications cruciales. En adhérant à ces principes et en mettant en œuvre les exemples fournis, vous pouvez vous assurer que votre code PHP est plus robuste, flexible et plus facile à maintenir au fil du temps. Gardez à l’esprit que l’application de ces principes peut nécessiter des changements dans la réflexion et la conception, mais les avantages en termes de qualité et de maintenabilité du code en valent la peine. Bonne chance pour écrire du bon code PHP !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!