Ce este modelul Command?

Question

Accepted Answer

Modelul **Command** încapsulează o **cerere ca obiect** — transformând o acțiune într-un obiect independent cu toate informațiile sale. Aceasta permite cozile de așteptare, jurnalizarea, anulare/refacere și decuplarea solicitantului de executor.

## Ce face modelul Command

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

## Exemplu

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

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

## De ce este important

Înțelegerea modelului Command este valoroasă deoarece este un **model behavioral util** care permite capacități importante precum anulare/refacere și cozi de așteptare, deci este cunoaștere de design relevantă.

Modelul Command încapsulează o cerere ca obiect — transformând o acțiune într-un obiect independent cu datele și metoda sa de execuție, decuplând solicitantul de executor.

Înțelegerea ceea ce face (reprezentarea unei acțiuni ca obiect care știe ce să facă, cu invokerul declanșând comenzi fără a cunoaște detaliile acestora) este cunoașterea fundamentală.

Înțelegerea **ceea ce permite** este valoarea cheie: **anulare/refacere** (stocarea comenzilor executate și apelarea anulării/refacerii, fiecare comandă știind cum să se anuleze pe sine — cazul de utilizare clasic și puternic pentru editori și aplicații), **cozi de așteptare** (cozile de comenzi pentru execuție ulterioară, programare sau lotizare), **jurnalizare** (jurnalizarea comenzilor pentru redare, audit sau tranzacții) și **decuplare** (invokerul neștiind implementarea comenzii).

Aceste capacități — în special anulare/refacere și cozi de așteptare — sunt cu adevărat valoroase și greu de implementat curat fără modelul Command.

Înțelegerea **utilizărilor** — anulare/refacere în editori, cozi de sarcini și joburi în fundal, operații transacționale, obiecte de acțiune (cum ar fi acțiunile Redux, un exemplu modern larg utilizat), înregistrarea macrocomenzi și elemente GUI declanșând comenzi — clarifică aplicabilitatea sa din lumea reală.

Modelul Command este modul curat de implementare a anulării/refacerii, cozilor de așteptare și arhitecturilor bazate pe acțiuni.

Deoarece modelul Command permite capacități importante (anulare/refacere, cozi de așteptare, jurnalizare, decuplare) care sunt valoroase și greu de implementat curat altfel, și deoarece apare în sisteme reale (editori, cozi de sarcini, acțiuni Redux), și deoarece înțelegerea a ceea ce face și permite este relevantă pentru implementarea acestor capacități, înțelegerea modelului Command este o cunoaștere de design valoroasă, practic relevantă — un model util care permite anulare/refacere, cozi de așteptare și arhitecturi bazate pe acțiuni (cum ar fi acțiunile Redux), modul curat de implementare a acestor capacități valoroase și cunoaștere de design importantă pentru acțiuni care trebuie stocate, cozite, jurnalizate sau anulate.