柔軟なPHPアプリケーションを構築するための高度な条件パターン

使用策略模式将条件逻辑替换为可互换行为；2. 采用空对象模式消除空值检查；3. 运用状态模式让对象根据内部状态改变行为；4. 通过规格模式组合复杂业务规则；5. 结合命令模式与守卫实现无条件执行控制；6. 使用基于类的分发替代switch语句；这些模式通过将条件逻辑转化为多态和组合，提升代码的可维护性、可测试性和扩展性，从而构建更灵活的PHP应用。

When building flexible and maintainable PHP applications, relying solely on basic if-else statements can quickly lead to rigid, hard-to-maintain code. Advanced conditional patterns allow developers to write more dynamic, scalable, and readable logic. These patterns go beyond simple branching and embrace design principles that promote separation of concerns, testability, and extensibility.

Here are several advanced conditional patterns you can use to make your PHP applications more adaptable.

1. Strategy Pattern: Replace Conditional Logic with Interchangeable Behaviors

Instead of using long switch or if-elseif chains to determine behavior, encapsulate each variation into its own class using the Strategy pattern.

Example: Payment Processing

interface PaymentProcessor
{
    public function process(float $amount): bool;
}

class CreditCardProcessor implements PaymentProcessor
{
    public function process(float $amount): bool
    {
        // Process credit card
        return true;
    }
}

class PayPalProcessor implements PaymentProcessor
{
    public function process(float $amount): bool
    {
        // Process via PayPal
        return true;
    }
}

class PaymentService
{
    private PaymentProcessor $processor;

    public function setProcessor(PaymentProcessor $processor): void
    {
        $this->processor = $processor;
    }

    public function execute(float $amount): bool
    {
        return $this->processor->process($amount);
    }
}

Why it’s better:

• No conditionals needed when selecting logic
• Easy to add new payment methods
• Promotes dependency injection and testing

Use this when:

• You have multiple algorithms for the same task
• Behavior changes based on context or configuration

2. Null Object Pattern: Eliminate Null Checks

Instead of scattering if ($object !== null) checks, use a Null Object that implements the same interface but does nothing.

interface Logger
{
    public function log(string $message);
}

class FileLogger implements Logger
{
    public function log(string $message)
    {
        file_put_contents('app.log', $message . PHP_EOL, FILE_APPEND);
    }
}

class NullLogger implements Logger
{
    public function log(string $message)
    {
        // Do nothing
    }
}

class UserService
{
    private Logger $logger;

    public function __construct(Logger $logger = null)
    {
        $this->logger = $logger ?? new NullLogger(); // Avoid null checks
    }

    public function register(string $email)
    {
        // No need to check if logger is null
        $this->logger->log("User registered: $email");
    }
}

Benefit: Cleaner code, fewer defensive conditionals.

3. State Pattern: Let Objects Change Behavior Based on Internal State

When an object’s behavior changes drastically based on its state, avoid conditionals like if ($status === 'active') by externalizing state logic.

interface OrderState
{
    public function ship(OrderContext $order);
    public function cancel(OrderContext $order);
}

class PendingState implements OrderState
{
    public function ship(OrderContext $order) { /* Not allowed */ }
    public function cancel(OrderContext $order) { $order->setState(new CancelledState()); }
}

class ShippedState implements OrderState
{
    public function ship(OrderContext $order) { /* Already shipped */ }
    public function cancel(OrderContext $order) { /* Can't cancel */ }
}

class OrderContext
{
    private OrderState $state;

    public function __construct()
    {
        $this->state = new PendingState();
    }

    public function setState(OrderState $state)
    {
        $this->state = $state;
    }

    public function ship() { $this->state->ship($this); }
    public function cancel() { $this->state->cancel($this); }
}

This removes conditionals like:

if ($this->status === 'pending') {
    $this->status = 'shipped';
}

Instead, behavior is delegated to the current state object.

4. Specification Pattern: Compose Complex Business Rules

Use boolean logic via objects to represent business rules. This is especially useful for validation or filtering.

interface Specification
{
    public function isSatisfiedBy($candidate): bool;
    public function and(Specification $other): Specification;
    public function or(Specification $other): Specification;
    public function not(): Specification;
}

class AgeSpecification implements Specification
{
    private int $minAge;

    public function __construct(int $minAge)
    {
        $this->minAge = $minAge;
    }

    public function isSatisfiedBy($candidate): bool
    {
        return $candidate->age >= $this->minAge;
    }

    public function and(Specification $other): Specification
    {
        return new AndSpecification($this, $other);
    }

    // ... similarly for or(), not()
}

Now you can compose rules:

$canVote = (new AgeSpecification(18))->and(new CitizenshipSpecification('US'));
if ($canVote->isSatisfiedBy($user)) { ... }

This replaces complex nested conditionals with readable, reusable rule objects.

5. Command Pattern with Guards: Conditional Execution Without Ifs

Combine the Command pattern with preconditions (guards) to control execution flow.

interface Command
{
    public function canExecute(): bool;
    public function execute();
}

class DeleteAccountCommand implements Command
{
    private User $user;

    public function __construct(User $user)
    {
        $this->user = $user;
    }

    public function canExecute(): bool
    {
        return $this->user->isVerified() && !$this->user->hasActiveSubscriptions();
    }

    public function execute()
    {
        if (!$this->canExecute()) {
            throw new RuntimeException("Cannot execute command");
        }
        // Perform deletion
    }
}

Then process commands generically:

foreach ($commands as $cmd) {
    if ($cmd->canExecute()) {
        $cmd->execute();
    }
}

This centralizes conditional logic and makes command pipelines easy to manage.

6. Use Class-Based Dispatching Instead of Switch Statements

Instead of:

switch ($type) {
    case 'pdf':  return new PdfExporter(); 
    case 'csv':  return new CsvExporter();
    // ...
}

Use a map of types to classes:

class ExporterFactory
{
    private array $map = [
        'pdf' => PdfExporter::class,
        'csv' => CsvExporter::class,
    ];

    public function make(string $type): Exporter
    {
        if (!isset($this->map[$type])) {
            throw new InvalidArgumentException("Unknown type: $type");
        }

        return new $this->map[$type]();
    }
}

Even better: use a DI container to resolve them dynamically.

Final Thoughts

Advanced conditional patterns help you:

• Reduce code duplication
• Improve testability
• Make systems easier to extend
• Avoid deep nesting and cyclomatic complexity

Instead of asking "what should I do next?" in conditionals, ask:

• Can this be an object?
• Can this be injected?
• Can this be composed?

By replacing conditionals with polymorphism and composition, you build systems that are easier to reason about and evolve over time.

Basically, if you're writing if statements to decide what kind of thing to do — it's probably time to use a pattern.

以上が柔軟なPHPアプリケーションを構築するための高度な条件パターンの詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。