Qu'est-ce que le pattern Command ?

Question

Accepted Answer

Le pattern **Command** encapsule une **requête comme un objet** — transformant une action en un objet autonome avec toutes ses informations. Cela permet la mise en file d'attente, la journalisation, l'annulation/refonte, et le découplage entre le demandeur et l'exécuteur.

## Qu'est-ce que le pattern Command fait

```text
COMMAND → encapsulate an action/request as an OBJECT (with its data and an execute method):
  → a command object knows WHAT to do and has the info to do it
  → the invoker triggers commands without knowing their details
  → decouples the object that INVOKES from the object that PERFORMS the action
→ "turn an action into an object" → store, pass, queue, log, undo it
```

## Exemple

```js
// commands encapsulate actions
class AddTextCommand {
  constructor(doc, text) { this.doc = doc; this.text = text; }
  execute() { this.doc.add(this.text); }
  undo() { this.doc.remove(this.text); }   // commands can support undo
}
// invoker executes and tracks commands (for undo/redo)
const cmd = new AddTextCommand(doc, 'hello');
cmd.execute();
cmd.undo();   // reverse it
```

## Ce qu'il rend possible

```text
✓ UNDO/REDO → store executed commands; call undo()/redo() (each command knows how to reverse)
✓ QUEUING → queue commands to execute later; schedule; batch
✓ LOGGING → log commands (e.g. for replay, audit, transactions)
✓ DECOUPLING → invoker doesn't know the command's implementation (just calls execute())
USES → undo/redo (editors), task queues/jobs, transactional operations, action objects
  (e.g. Redux actions), macro recording, GUI buttons/menu items triggering commands
```

## Pourquoi c'est important

Comprendre le pattern Command est précieux car c'est un **pattern comportemental utile** qui rend possibles des capacités importantes comme l'annulation/refonte et la mise en file d'attente, ce qui en fait une connaissance de conception pertinente.

Le pattern Command encapsule une requête comme un objet — transformant une action en un objet autonome avec ses données et une méthode execute, découplant le demandeur de l'exécuteur.

Comprendre ce qu'il fait (représenter une action comme un objet qui sait quoi faire, avec l'invocateur déclenchant des commandes sans connaître leurs détails) est la connaissance centrale.

Comprendre **ce qu'il rend possible** est la clé de sa valeur : **annulation/refonte** (stocker les commandes exécutées et appeler annuler/refaire, chaque commande sachant comment s'inverser — le cas d'usage classique et puissant pour les éditeurs et les applications), **mise en file d'attente** (mettre en file d'attente les commandes à exécuter plus tard, planifier ou traiter par lot), **journalisation** (journaliser les commandes pour rejeu, audit ou transactions), et **découplage** (l'invocateur ne connaissant pas l'implémentation de la commande).

Ces capacités — surtout l'annulation/refonte et la mise en file d'attente — sont véritablement précieuses et difficiles à implémenter proprement sans le pattern Command.

Comprendre les **usages** — annulation/refonte dans les éditeurs, files d'attente de tâches et travaux en arrière-plan, opérations transactionnelles, objets d'action (comme les actions Redux, un exemple moderne largement utilisé), enregistrement de macros, et éléments d'interface utilisateur déclenchant des commandes — clarifie son applicabilité dans le monde réel.

Le pattern Command est la façon propre d'implémenter l'annulation/refonte, la mise en file d'attente, et les architectures basées sur les actions.

Duisant que le pattern Command rend possibles des capacités importantes (annulation/refonte, mise en file d'attente, journalisation, découplage) qui sont précieuses et difficiles à implémenter proprement autrement, et puisqu'il apparaît dans les systèmes réels (éditeurs, files d'attente de tâches, actions Redux), et puisque comprendre ce qu'il fait et rend possible est pertinent pour implémenter ces capacités, comprendre le pattern Command est une connaissance de conception précieuse et pratiquement pertinente — un pattern utile rendant possibles l'annulation/refonte, la mise en file d'attente, et les architectures basées sur les actions (comme les actions Redux), la façon propre d'implémenter ces capacités précieuses, et une connaissance de conception importante pour les actions qui doivent être stockées, mises en file d'attente, journalisées, ou annulées.