Command Pattern in PHP

The Command design pattern, employed within PHP, is a behavioral architectural concept that enables the encapsulation of requests as distinct objects. This approach facilitates the parameterization of clients with queues, requests, and operations while supporting the capability to undo these operations.

This pattern comprises several components:

Command Interface/Abstract Class: At its core, the Command pattern features an interface or abstract class, mandating the presence of an execute() method. Concrete command classes implement this interface, thereby encapsulating specific actions.

Concrete Command Classes: These are the tangible implementations of the Command interface. They serve to encapsulate action details by associating a receiver (the entity responsible for executing the action) with a set of arguments.

Receiver: A receiver represents the entity responsible for executing the requested action. It possesses the knowledge and ability to carry out the specific operation when the execute() method is invoked on the Command.

Invoker: The invoker is a coordinating element that stores and manages commands. It decides when and how to execute a particular command. The beauty of this design lies in its decoupling of the Invoker from the Concrete Commands, allowing the Invoker to execute commands without needing intimate knowledge of the specific actions involved.

Here’s a practical example within PHP to illustrate the Command pattern:

Imagine a rudimentary remote control with two buttons: one for activating a light and another for deactivating a fan. In this scenario, we will apply the Command pattern:

1: Command Interface:

interface RemoteControlCommand {
    public function execute();
}

2: Concrete command implementation:

class TurnOnLight implements RemoteControlCommand {
    private $lightDevice;

    public function __construct(Light $lightDevice) {
        $this->lightDevice = $lightDevice;
    }

    public function execute() {
        $this->lightDevice->turnOn();
    }
}

class TurnOffFan implements RemoteControlCommand {
    private $fanDevice;

    public function __construct(Fan $fanDevice) {
        $this->fanDevice = $fanDevice;
    }

    public function execute() {
        $this->fanDevice->turnOff();
    }
}

3: Receiver Classes:

class Light {
    public function turnOn() {
        echo "The light is now ON\n";
    }

    public function turnOff() {
        echo "The light is now OFF\n";
    }
}

class Fan {
    public function turnOn() {
        echo "The fan is now ON\n";
    }

    public function turnOff() {
        echo "The fan is now OFF\n";
    }
}

4: Invoker:

class RemoteControl {
    private $commandQueue = [];

    public function setCommand(RemoteControlCommand $command) {
        $this->commandQueue[] = $command;
    }

    public function pressButton() {
        foreach ($this->commandQueue as $command) {
            $command->execute();
        }
        $this->commandQueue = [];
    }
}

With these classes, you can create and execute commands using the remote control:

$light = new Light();
$fan = new Fan();

$lightOnCommand = new LightOnCommand($light);
$fanOffCommand = new FanOffCommand($fan);

$remote = new RemoteControl();
$remote->setCommand($lightOnCommand);
$remote->setCommand($fanOffCommand);

$remote->pressButton();

When this code is executed, it will produce the following output

The light is now ON
The fan is now OFF

This practical example explains the command pattern in PHP, where distinct commands, such as activating a light or deactivating a fan, are encapsulated as objects.
This command can be executed through an invoker, without the invoker needing in-depth knowledge about the inner workings of each command.