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 command), leva-o à cozinha, e o chef o executa. O garçom não precisa saber cozinhar; ele apenas entrega o command.

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();
    }
}

The invoker dispara 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 Command se destaca quando você precisa enfileirar operações, implementar a funcionalidade de desfazer ou registrar ações. Cada command é autocontido, o que facilita adicionar novos commands 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: Define uma interface Command com um único método execute(): string. Isso estabelece o contract que todos os comandos do editor devem follow.
TextEditor.php, Create uma classe TextEditor que representa o receptor, o objeto que realmente executa o trabalho. Seu editor deve:
- Armazenar o texto current (comece com uma string empty)
- Ter um método write(string $text): string que acrescenta texto ao content e retorna "Written: [text]"
- Ter um método clear(): string que esvazia o content e retorna "Content cleared"
- Ter um método getContent(): string que retorna o content current
Commands.php: Inclua os arquivos Command e TextEditor. Create duas classes de comando que implementam a interface Command:
- WriteCommand: Recebe um TextEditor e uma string de texto em seu constructor. Seu método execute() calls o método write() do editor e retorna o resultado.
- ClearCommand: Recebe um TextEditor em seu constructor. Seu método execute() calls o método clear() do editor e retorna o resultado.
main.php: Inclua o arquivo Commands. Você receberá duas entradas: um tipo de command ("write" ou "clear") e uma string de texto (usada apenas para comandos de escrita).
Create uma instância de TextEditor. Based no tipo de command, crie o objeto de comando apropriado. Em seguida, crie uma function invoker ou um mecanismo simples que calls execute() no comando e imprime o resultado.

Em uma nova linha, imprima o content current do editor neste format: Content: [content] (se estiver empty, basta imprimir Content: sem nada após o espaço).

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

REQUIRED OUTPUT FORMAT: [Your translated content here]

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)

?>