Patron Commande

Fait partie de la section Programmation Orientée Objet du Journey PHP de Coddy. Leçon 75 sur 91.

Le Command Pattern est un modèle de conception comportemental qui transforme une requête en un objet autonome contenant toutes les informations relatives à cette requête. Cette transformation vous permet de transmettre des requêtes comme arguments de méthode, de retarder ou de mettre en file d’attente l’exécution d’une requête, et de prendre en charge des opérations annulables.

Pense à un restaurant.

Lorsque vous commandez à manger, le serveur écrit votre commande sur un bon (la command), l’apporte à la cuisine et le chef l’execute. Le serveur n’a pas besoin de savoir cuisiner il doit just livrer la command.

Cela découple le demandeur de l’exécuteur.

Voici une implémentation de 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();
    }
}

The invoker déclenche des commands sans savoir ce qu’elles font :

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

Sortie :

Light is ON
Light is OFF

Le modèle Command excelle lorsque vous devez mettre des opérations en file d’attente, implémenter une fonctionnalité d’annulation ou consigner des actions. Chaque command est autonome, ce qui facilite l’ajout de nouvelles commands sans modifier le code existant.

Défi

Facile

Construisons un système de commandes pour un éditeur de texte en utilisant le modèle Command. Les éditeurs de texte doivent souvent prendre en charge des opérations telles que l’écriture de texte, la suppression de texte et l’annulation d’actions : chaque opération devient un objet commande autonome qui peut être exécuté via une interface unifiée.

Vous organiserez votre code sur quatre fichiers :

Command.php : Define une interface Command avec une seule méthode execute(): string. Cela établit le contrat que toutes les commandes de l’éditeur doivent follow.
TextEditor.php, Create une classe TextEditor qui représente le récepteur, l’objet qui effectue réellement le travail. Votre éditeur doit :
- Stocker le texte current (commencer par une chaîne empty)
- Disposer d’une méthode write(string $text): string qui ajoute le texte au content et renvoie "Written: [text]"
- Disposer d’une méthode clear(): string qui vide le content et renvoie "Content cleared"
- Disposer d’une méthode getContent(): string qui renvoie le content current
Commands.php : Inclure les fichiers Command et TextEditor. Create deux classes de commandes qui implémentent l’interface Command :
- WriteCommand : Reçoit un TextEditor et une chaîne de texte dans son constructeur. Sa méthode execute() calls la méthode write() de l’éditeur et renvoie le résultat.
- ClearCommand : Reçoit un TextEditor dans son constructeur. Sa méthode execute() calls la méthode clear() de l’éditeur et renvoie le résultat.
main.php : Inclure le fichier Commands. Vous recevrez deux entrées : un type de commande ("write" ou "clear") et une chaîne de texte (utilisée uniquement pour les commandes write).
Create une instance de TextEditor. Based sur le type de commande, Create l’objet commande appropriate. Puis Create un invoker function ou un mécanisme simple qui appelle execute() sur la commande et affiche le résultat.

Sur une nouvelle ligne, afficher le content current de l’éditeur dans ce format : Content: [content] (s’il est empty, afficher simplement Content: avec rien after l’espace).

Ce défi montre comment le modèle Command encapsule chaque opération sous forme d’objet. L’invoker n’a pas besoin de savoir s’il exécute une commande d’écriture ou de clear. Il appelle simplement execute() et laisse la commande gérer les détails.

Essayez vous-même

<?php

require_once 'Commands.php';

// Lire l'entrée
$commandType = trim(fgets(STDIN)); // "write" ou "clear"
$text = trim(fgets(STDIN));         // texte pour la commande write

// TODO: Créer une instance de TextEditor

// TODO: En fonction du type de commande, créer l'objet commande approprié
// - Si "write", créer un WriteCommand avec l'éditeur et le texte
// - Si "clear", créer un ClearCommand avec l'éditeur

// TODO: Créer un mécanisme d'invoker qui appelle execute() sur la commande
// et affiche le résultat

// TODO: Afficher le contenu actuel de l'éditeur au format : "Content: [content]"
// (si vide, afficher simplement "Content: " sans rien après l'espace)

?>