Modello Command

Fa parte della sezione Programmazione orientata agli oggetti del percorso PHP di Coddy. Lezione 75 di 91.

Il Command Pattern è un pattern di progettazione comportamentale che trasforma una richiesta in un oggetto autonomo contenente tutte le informazioni sulla richiesta. Questa trasformazione ti consente di passare le richieste come argomenti dei metodi, ritardare o mettere in coda l’esecuzione di una richiesta e supportare operazioni annullabili.

Pensa a un ristorante.

Quando ordini del cibo, il cameriere scrive il tuo ordine su un foglietto (il comando), lo porta in cucina e lo chef lo esegue. Il cameriere non deve sapere come cucinare: deve solo consegnare il comando.

Questo disaccoppia il richiedente dall'esecutore.

Ecco un'implementazione di base:

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

L'invocatore attiva i comandi senza sapere cosa fanno:

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

Output:

Light is ON
Light is OFF

Il pattern Command è ideale quando devi mettere in coda delle operazioni, implementare la funzionalità di annullamento o registrare le azioni. Ogni comando è autonomo, il che semplifica l'aggiunta di nuovi comandi senza modificare il codice esistente.

Sfida

Facile

Costruiamo un sistema di comandi per un editor di testo usando il pattern Command. Gli editor di testo devono spesso supportare operazioni come scrivere testo, eliminare testo e annullare azioni: ogni operazione diventa un oggetto comando autonomo che può essere eseguito tramite un’interfaccia unificata.

Organizzerai il codice in quattro file:

Command.php: Definisci un’interfaccia Command con un solo metodo execute(): string. Questo stabilisce il contratto che tutti i comandi dell’editor devono rispettare.
TextEditor.php, crea una classe TextEditor che rappresenta il destinatario, ovvero l’oggetto che esegue effettivamente il lavoro. Il tuo editor dovrebbe:
- Memorizzare il contenuto di testo corrente (iniziare con una stringa vuota)
- Avere un metodo write(string $text): string che aggiunge testo al contenuto e restituisce "Written: [text]"
- Avere un metodo clear(): string che svuota il contenuto e restituisce "Content cleared"
- Avere un metodo getContent(): string che restituisce il contenuto corrente
Commands.php: Includi i file Command e TextEditor. Crea due classi di comando che implementano l’interfaccia Command:
- WriteCommand: Accetta un TextEditor e una stringa di testo nel costruttore. Il suo metodo execute() chiama il metodo write() dell’editor e restituisce il risultato.
- ClearCommand: Accetta un TextEditor nel costruttore. Il suo metodo execute() chiama il metodo clear() dell’editor e restituisce il risultato.
main.php: Includi il file Commands. Riceverai due input: un tipo di comando ("write" o "clear") e una stringa di testo (usata solo per i comandi di scrittura).
Crea un’istanza di TextEditor. In base al tipo di comando, crea l’oggetto comando appropriato. Poi crea una funzione invoker o un meccanismo semplice che chiami execute() sul comando e stampi il risultato.

Su una nuova riga, stampa il contenuto corrente dell’editor in questo formato: Content: [content] (se è vuoto, stampa solo Content: senza niente dopo lo spazio).

Questa sfida dimostra come il pattern Command incapsula ogni operazione come un oggetto. L’invoker non deve sapere se sta eseguendo un comando di scrittura o di cancellazione. Chiama semplicemente execute() e lascia che sia il comando a gestire i dettagli.

Provalo tu

<?php

require_once 'Commands.php';

// Leggi l'input
$commandType = trim(fgets(STDIN)); // "write" o "clear"
$text = trim(fgets(STDIN));         // testo per il comando write

// TODO: Crea un'istanza di TextEditor

// TODO: In base al tipo di comando, crea l'oggetto comando appropriato
// - Se "write", crea un WriteCommand con l'editor e il testo
// - Se "clear", crea un ClearCommand con l'editor

// TODO: Crea un meccanismo di invocazione che chiami execute() sul comando
// e stampi il risultato

// TODO: Stampa il contenuto attuale dell'editor nel formato: "Content: [content]"
// (se è vuoto, stampa soltanto "Content: " senza nulla dopo lo spazio)

?>