Patrón Command

Parte de la sección Programación Orientada a Objetos del Journey de PHP de Coddy. Lección 75 de 91.

El patrón Command es un patrón de diseño de comportamiento que convierte una solicitud en un objeto independiente que contiene toda la información sobre la solicitud. Esta transformación te permite pasar solicitudes como argumentos de métodos, retrasar o poner en cola la ejecución de una solicitud y admitir operaciones que se pueden deshacer.

Piensa en un restaurante.

Cuando pides comida, el camarero escribe tu pedido en una nota (el comando), lo lleva a la cocina y el chef lo ejecuta. El camarero no necesita saber cocinar; solo entrega el comando.

Esto desacopla al solicitante del ejecutor.

Aquí tienes una implementación 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();
    }
}

El invocador activa comandos sin saber qué hacen:

<?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));

Salida:

Light is ON
Light is OFF

El patrón Command sobresale cuando necesitas poner operaciones en cola, implementar la funcionalidad de deshacer o registrar acciones. Cada comando es autónomo, lo que facilita añadir nuevos comandos sin modificar el código existente.

Desafío

Fácil

Construyamos un sistema de comandos para un editor de texto utilizando el patrón Command. Los editores de texto a menudo necesitan admitir operaciones como escribir texto, eliminar texto y deshacer acciones: cada operación se convierte en un objeto de comando independiente que se puede ejecutar a través de una interfaz unificada.

Organizarás tu código en cuatro archivos:

Command.php: Define una interfaz Command con un único método execute(): string. Esto establece el contrato que deben seguir todos los comandos del editor.
TextEditor.php, Crea una clase TextEditor que represente al receptor, el objeto que realmente realiza el trabajo. Tu editor debe:
- Almacenar el contenido de texto actual (comienza con una cadena vacía)
- Tener un método write(string $text): string que añada texto al contenido y devuelva "Written: [text]"
- Tener un método clear(): string que vacíe el contenido y devuelva "Content cleared"
- Tener un método getContent(): string que devuelva el contenido actual
Commands.php: Incluye los archivos Command y TextEditor. Crea dos clases de comandos que implementen la interfaz Command:
- WriteCommand: Recibe un TextEditor y una cadena de texto en su constructor. Su método execute() llama al método write() del editor y devuelve el resultado.
- ClearCommand: Recibe un TextEditor en su constructor. Su método execute() llama al método clear() del editor y devuelve el resultado.
main.php: Incluye el archivo Commands. Recibirás dos entradas: un tipo de comando ("write" o "clear") y una cadena de texto (utilizada solo para los comandos de escritura).
Crea una instancia de TextEditor. Según el tipo de comando, crea el objeto de comando apropiado. Después, crea una función invocadora o un mecanismo sencillo que llame a execute() en el comando e imprima el resultado.

En una línea nueva, imprime el contenido actual del editor con este formato: Content: [content] (si está vacío, imprime simplemente Content: sin nada después del espacio).

Este desafío demuestra cómo el patrón Command encapsula cada operación como un objeto. El invocador no necesita saber si está ejecutando un comando de escritura o de limpieza. Simplemente llama a execute() y permite que el comando gestione los detalles.

Pruébalo tú mismo

<?php

require_once 'Commands.php';

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

// TODO: Crea una instancia de TextEditor

// TODO: Basado en el tipo de comando, crea el objeto de comando apropiado
// - Si "write", crea un WriteCommand con el editor y el texto
// - Si "clear", crea un ClearCommand con el editor

// TODO: Crea un mecanismo invocador que llame a execute() en el comando
// e imprime el resultado

// TODO: Imprime el contenido actual del editor en el formato: "Content: [content]"
// (si está vacío, solo imprime "Content: " sin nada después del espacio)

?>