Principles and methods of PHP code refactoring

PHP refactoring follows the principles of single responsibility, open-closed, and Liskov replacement, and implements refactoring by extracting methods, using design patterns, and using tools and tests. For example, split complex functions, use dependency injection to improve testability, and achieve code scalability and maintainability.

Principles and methods of PHP code refactoring

Principle

• Single responsibility Principle (SRP): Each class or method is responsible for only one specific task.
• Open-Closed Principle (OCP): Code is open to extension and closed to modification.
• Liskov Substitution Principle (LSP): A subclass can replace its parent class at any time.
• Dependency Inversion Principle (DIP): High-level modules should not depend on low-level modules, both should depend on abstractions.
• DRY Principle (Don't Repeat Yourself): Avoid duplicating code.

Method

1. Extraction method

Extract part of the code in the complex method into a separate method , improve readability and maintainability.

Example:

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

After refactoring:

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. Design using design patterns

Patterns provide pre-designed solutions to common problems, such as Singleton, Factory, and Observer patterns.

Example:

Use factory pattern to create different objects without having to specify specific types:

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. Using tools

Use code analysis tools (such as PHPStan, PHP CS Fixer) to automatically detect and fix potential problems.

4. Conduct Tests

Write tests before refactoring code to ensure that the new code does not break existing functionality.

Practical case:

Refactor a complex function, split it into several smaller functions, and use dependency injection to improve testability:

Before refactoring:

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

After 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);
}

By using dependency injection, you can easily switch to Different notification senders improve code testability and flexibility.

The above is the detailed content of Principles and methods of PHP code refactoring. For more information, please follow other related articles on the PHP Chinese website!