Principes et méthodes de refactorisation de code PHP

Le refactoring PHP suit les principes de responsabilité unique, d'ouverture-fermée et de substitution Liskov, et implémente le refactoring en extrayant des méthodes, en utilisant des modèles de conception et en utilisant des outils et des tests. Par exemple, divisez des fonctions complexes, utilisez l'injection de dépendances pour améliorer la testabilité et obtenez l'évolutivité et la maintenabilité du code.

Principes et méthodes de refactoring de code PHP

Principe

• Principe de responsabilité unique (SRP) : Chaque classe ou méthode n'est responsable que d'une tâche spécifique.
• Principe ouvert-fermé (OCP) : le code est ouvert pour extension et fermé pour modification.
• Principe de substitution de Liskov (LSP) : Une sous-classe peut remplacer sa classe parent à tout moment.
• Principe d'inversion de dépendance (DIP) : les modules de haut niveau ne doivent pas dépendre de modules de bas niveau, les deux doivent dépendre d'abstractions.
• Principe DRY (Ne vous répétez pas) : Évitez de dupliquer le code.

Méthode

1. Méthode d'extraction

Extraire une partie du code d'une méthode complexe dans une méthode distincte pour améliorer la lisibilité et la maintenabilité.

Exemple :

class User {
    public function save($data)
    {
        // 验证数据
        // 存储数据
        // 发送确认邮件
    }
}

Après la refactorisation :

class User {
    public function save($data)
    {
        $this->validate($data);
        $this->store($data);
        $this->sendConfirmationEmail();
    }

    private function validate($data) { /* ... */ }
    private function store($data) { /* ... */ }
    private function sendConfirmationEmail() { /* ... */ }
}

2. Utilisation des modèles de conception

Les modèles de conception fournissent des solutions prédéfinies aux problèmes courants tels que les modèles singleton, d'usine et d'observateur.

Exemple :

Utilisez un modèle d'usine pour créer différents objets sans avoir à spécifier des types spécifiques :

interface LoggerFactory
{
    public function createLogger();
}

class FileLoggerFactory implements LoggerFactory
{
    public function createLogger()
    {
        return new FileLogger();
    }
}

class DatabaseLoggerFactory implements LoggerFactory
{
    public function createLogger()
    {
        return new DatabaseLogger();
    }
}

// 使用工厂创建 logger 对象
$factory = new FileLoggerFactory();
$logger = $factory->createLogger();

3. Utilisez des outils

Utilisez des outils d'analyse de code (tels que PHPStan, PHP CS Fixer) pour détecter et résoudre les problèmes potentiels.

4. Effectuer des tests

Écrivez des tests avant de refactoriser le code pour vous assurer que le nouveau code ne casse pas les fonctionnalités existantes.

Cas pratique :

Refactoriser une fonction complexe, la diviser en plusieurs fonctions plus petites et utiliser l'injection de dépendances pour améliorer la testabilité :

Avant le refactoring :

function sendNotification($userId, $message, $type)
{
    // ...发送通知逻辑...
}

Après le refactoring :

interface NotificationSender
{
    public function send($userId, $message, $type);
}

class EmailNotificationSender implements NotificationSender
{
    // ...发送电子邮件通知逻辑...
}

class SmsNotificationSender implements NotificationSender
{
    // ...发送短信通知逻辑...
}

function sendNotification($userId, $message, $type, NotificationSender $sender)
{
    $sender->send($userId, $message, $type);
}

En utilisant la dépendance injection, vous pouvez facilement basculer vers différents expéditeurs de notifications, améliorant ainsi la testabilité et la flexibilité de votre code.

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!