Padrão Command

Parte da seção Programação Orientada a Objetos do Journey de PHP da Coddy. Lição 75 de 91.

O Command Pattern é um padrão de projeto comportamental que transforma uma solicitação em um objeto independente contendo todas as informações sobre a solicitação. Essa transformação permite passar solicitações como argumentos de métodos, adiar ou enfileirar a execução de uma solicitação e oferecer suporte a operações que podem ser desfeitas.

Pense em um restaurante.

Quando você pede comida, o garçom escreve seu pedido em um papel (o comando), leva-o à cozinha e o chef o executa. O garçom não precisa saber cozinhar; ele apenas entrega o comando.

Isso desacopla o solicitante do executor.

Aqui está uma implementação básica:

<?php
interface Command {
    public function execute(): string;
}

class Light {
    public function on(): string { return "Light is ON"; }
    public function off(): string { return "Light is OFF"; }
}

class LightOnCommand implements Command {
    public function __construct(private Light $light) {}
    
    public function execute(): string {
        return $this->light->on();
    }
}

class LightOffCommand implements Command {
    public function __construct(private Light $light) {}
    
    public function execute(): string {
        return $this->light->off();
    }
}

O invocador aciona comandos sem saber o que eles fazem:

<?php
class RemoteControl {
    public function press(Command $command): string {
        return $command->execute();
    }
}

$light = new Light();
$remote = new RemoteControl();

echo $remote->press(new LightOnCommand($light)) . "\n";
echo $remote->press(new LightOffCommand($light));

Saída:

Light is ON
Light is OFF

O Padrão de Comando é excelente quando você precisa enfileirar operações, implementar a funcionalidade de desfazer ou registrar ações. Cada comando é independente, o que facilita adicionar novos comandos sem modificar o código existente.

Desafio

Fácil

Vamos criar um sistema de comandos para um editor de texto usando o Padrão Command. Editores de texto geralmente precisam oferecer suporte a operações como escrever texto, excluir texto e desfazer ações: cada operação se torna um objeto de comando independente que pode ser executado por meio de uma interface unificada.

Você organizará seu código em quatro arquivos:

Command.php: Defina uma interface Command com um único método execute(): string. Isso estabelece o contrato que todos os comandos do editor devem seguir.
TextEditor.php, crie uma classe TextEditor que represente o receptor, o objeto que realmente executa o trabalho. Seu editor deve:
- Armazenar o conteúdo de texto atual (começando com uma string vazia)
- Ter um método write(string $text): string que anexa texto ao conteúdo e retorna "Written: [text]"
- Ter um método clear(): string que esvazia o conteúdo e retorna "Content cleared"
- Ter um método getContent(): string que retorna o conteúdo atual
Commands.php: Inclua os arquivos Command e TextEditor. Crie duas classes de comando que implementem a interface Command:
- WriteCommand: Recebe um TextEditor e uma string de texto em seu construtor. Seu método execute() chama o método write() do editor e retorna o resultado.
- ClearCommand: Recebe um TextEditor em seu construtor. Seu método execute() chama o método clear() do editor e retorna o resultado.
main.php: Inclua o arquivo Commands. Você receberá duas entradas: um tipo de comando ("write" ou "clear") e uma string de texto (usada somente para comandos de escrita).
Crie uma instância de TextEditor. Com base no tipo de comando, crie o objeto de comando apropriado. Em seguida, crie uma função invocadora ou um mecanismo simples que chame execute() no comando e imprima o resultado.

Em uma nova linha, imprima o conteúdo atual do editor neste formato: Content: [content] (se estiver vazio, basta imprimir Content: sem nada depois do espaço).

Este desafio demonstra como o Padrão Command encapsula cada operação como um objeto. O invocador não precisa saber se está executando um comando de escrita ou de limpeza. Ele simplesmente chama execute() e deixa que o comando cuide dos detalhes.

Experimente você mesmo

<?php

require_once 'Commands.php';

// Ler entrada
$commandType = trim(fgets(STDIN)); // "write" ou "clear"
$text = trim(fgets(STDIN));         // texto para o comando write

// TODO: Crie uma instância de TextEditor

// TODO: Com base no tipo de comando, crie o objeto de comando apropriado
// - Se "write", crie um WriteCommand com o editor e o texto
// - Se "clear", crie um ClearCommand com o editor

// TODO: Crie um mecanismo invocador que chame execute() no comando
// e imprima o resultado

// TODO: Imprima o conteúdo atual do editor no formato: "Content: [content]"
// (se vazio, apenas imprima "Content: " sem nada após o espaço)

?>