Use policy mode to replace conditional logic with interchangeable behavior; 2. Use empty object mode to eliminate null value checks; 3. Use state mode to make objects change behavior according to internal state; 4. Combining complex business rules through specification mode; 5. Combining command mode with guards to achieve unconditional execution control; 6. Use class-based distribution to replace switch statements; these modes improve the maintainability, testability and scalability of the code by converting conditional logic into polymorphism and combinations, thereby building more flexible PHP applications.

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 extension.

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 conditions 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 defending conditions.

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

When an object's behavior changes drastically based on its state, avoid conditions 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 conditions 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 conditions 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 generally:

 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 conditions, ask:

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

By replacing conditions 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.

The above is the detailed content of Advanced Conditional Patterns for Building Flexible PHP Applications. For more information, please follow other related articles on the PHP Chinese website!