Remplacement des IF imbriqués par le modèle de stratégie dans PHP moderne

要替换PHP中嵌套的if语句，应使用策略模式，1. 定义策略接口；2. 创建具体策略类；3. 使用上下文类管理策略；4. 通过类型选择并执行对应策略，从而提升代码的可维护性、可测试性和扩展性，最终实现清晰、解耦的设计。

When your PHP code starts piling up with deeply nested if or elseif statements—especially when they’re making decisions based on types, statuses, or user roles—it’s a clear sign that your code is becoming harder to read, test, and maintain. One powerful way to clean this up is by replacing those nested conditionals with the Strategy Pattern.

Let’s walk through how and why you’d do this in modern PHP.

Why Replace Nested Ifs?

Nested if statements often look like this:

function calculateShipping($order) {
    if ($order->type === 'standard') {
        if ($order->weight <= 5) {
            return 5.00;
        } elseif ($order->weight <= 10) {
            return 10.00;
        } else {
            return 15.00;
        }
    } elseif ($order->type === 'express') {
        if ($order->weight <= 5) {
            return 15.00;
        } elseif ($order->weight <= 10) {
            return 25.00;
        } else {
            return 40.00;
        }
    }
    // ... more conditions
}

This gets messy fast. It violates the Open/Closed Principle (OCP), is hard to test, and makes adding new shipping types a chore.

The Strategy Pattern helps by encapsulating each algorithm (or behavior) into its own class, making it easy to swap them in and out.

What Is the Strategy Pattern?

The Strategy Pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. The context (e.g., shipping calculator) uses a strategy without knowing the internal details.

In PHP, this typically involves:

• A strategy interface
• Multiple concrete strategy classes
• A context that uses the selected strategy

Refactoring with the Strategy Pattern

1. Define the Strategy Interface

interface ShippingStrategy {
    public function calculate(float $weight): float;
}

2. Create Concrete Strategies

class StandardShipping implements ShippingStrategy {
    public function calculate(float $weight): float {
        return $weight <= 5 ? 5.00 : ($weight <= 10 ? 10.00 : 15.00);
    }
}

class ExpressShipping implements ShippingStrategy {
    public function calculate(float $weight): float {
        return $weight <= 5 ? 15.00 : ($weight <= 10 ? 25.00 : 40.00);
    }
}

You could go further and break down the weight logic into separate strategies or use configuration, but this keeps it simple.

3. Use a Context or Resolver

class ShippingCalculator {
    private array $strategies;

    public function __construct() {
        $this->strategies = [
            'standard' => new StandardShipping(),
            'express'  => new ExpressShipping(),
        ];
    }

    public function calculate(string $type, float $weight): float {
        if (!isset($this->strategies[$type])) {
            throw new InvalidArgumentException("Unknown shipping type: $type");
        }

        return $this->strategies[$type]->calculate($weight);
    }
}

4. Use It Cleanly

$calculator = new ShippingCalculator();
$cost = $calculator->calculate('express', 7); // returns 25.00

No more nested ifs. Just a clean, readable call.

Benefits in Modern PHP

Using the Strategy Pattern in PHP 8+ brings several advantages:

• Type Safety: With interfaces and strict typing, you catch errors early.
• Testability: Each strategy can be tested in isolation.
• Extensibility: Add a new shipping method? Just create a new class and register it.
• Readability: No more tracing through 10 levels of if/else.
• Integration with DI: You can inject strategies via dependency injection containers (e.g., in Laravel or Symfony).

For example, in Laravel, you might bind strategies in a service provider:

$this->app->bind(ShippingStrategy::class . '_express', fn() => new ExpressShipping());

Or use a strategy factory with config-driven registration.

When to Use It

Consider the Strategy Pattern when you see:

• Multiple conditionals based on a type or mode
• Repeated switch or if-elseif blocks
• Code that’s hard to test due to branching
• Business rules that may change or expand

It’s overkill for two simple branches, but shines when you have 3+ variations or expect growth.

Final Thoughts

Replacing nested if statements with the Strategy Pattern leads to code that’s:

• More maintainable
• Easier to test
• Simpler to extend

In modern PHP, with namespaces, autoloading, and strong OOP support, this pattern fits naturally into your architecture.

You don’t need a framework to use it—just a little forethought and a commitment to clean design.

Basically, if your if chain is making you scroll sideways, it’s time to strategize.

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!