Wat is het Command-patroon?

Question

Accepted Answer

Het **Command**-patroon encapsuleert een **verzoek als een object** — het verandert een actie in een standalone object met alle informatie ervan. Dit maakt queuing, logging, ongedaan maken/opnieuw uitvoeren, en ontkoppeling van aanvrager en uitvoerder mogelijk.

## Wat het Command-patroon doet

```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
```

## Voorbeeld

```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
```

## Wat het mogelijk maakt

```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
```

## Waarom het belangrijk is

Het begrijpen van het Command-patroon is waardevol omdat het een **nuttig gedragspatroon** is dat belangrijke mogelijkheden zoals ongedaan maken/opnieuw uitvoeren en queuing mogelijk maakt, dus het is relevante ontwerpkunde.

Het Command-patroon encapsuleert een verzoek als een object — het verandert een actie in een standalone object met zijn gegevens en een execute-methode, en ontkoppelt de aanvrager van de uitvoerder.

Begrijpen wat het doet (een actie voorstellen als een object dat weet wat te doen, waarbij de invoker commando's triggert zonder hun details te kennen) is de kernkennis.

Begrijpen **wat het mogelijk maakt** is de kernwaarde: **ongedaan maken/opnieuw uitvoeren** (uitgevoerde commando's opslaan en ongedaan maken/opnieuw uitvoeren aanroepen, waarbij elk commando weet hoe het zichzelf moet omdraaien — het klassieke, krachtige use case voor editors en applicaties), **queuing** (commando's in wachtrij plaatsen voor latere uitvoering, planning of batching), **logging** (commando's loggen voor replay, audit of transacties), en **ontkoppeling** (de invoker kent de implementatie van het commando niet).

Deze mogelijkheden — vooral ongedaan maken/opnieuw uitvoeren en queuing — zijn echt waardevol en moeilijk schoon te implementeren zonder het Command-patroon.

Het begrijpen van de **toepassingen** — ongedaan maken/opnieuw uitvoeren in editors, taakwachtrijen en achtergrondtaken, transactionele bewerkingen, actieobjecten (zoals Redux-acties, een veel gebruikt modern voorbeeld), macrorecording, en GUI-elementen die commando's triggeren — verduidelijkt de praktische toepasbaarheid ervan.

Het Command-patroon is de schone manier om ongedaan maken/opnieuw uitvoeren, queuing en op acties gebaseerde architecturen te implementeren.

Omdat het Command-patroon belangrijke mogelijkheden (ongedaan maken/opnieuw uitvoeren, queuing, logging, ontkoppeling) mogelijk maakt die waardevol zijn en moeilijk schoon te implementeren zijn anders, en omdat het in echte systemen voorkomt (editors, taakwachtrijen, Redux-acties), en omdat begrijpen wat het doet en mogelijk maakt relevant is voor het implementeren van deze mogelijkheden, is het begrijpen van het Command-patroon waardevol, praktisch relevante ontwerpkunde — een nuttig patroon dat ongedaan maken/opnieuw uitvoeren, queuing en op acties gebaseerde architecturen (zoals Redux-acties) mogelijk maakt, de schone manier om deze waardevolle mogelijkheden te implementeren, en belangrijke ontwerpkunde voor acties die moeten worden opgeslagen, in wachtrij geplaatst, geregistreerd of ongedaan gemaakt.