¿Qué es el patrón Command?

Question

Accepted Answer

El patrón **Command** encapsula una **solicitud como un objeto** — convirtiendo una acción en un objeto independiente con toda su información. Esto permite encolar, registrar, deshacer/rehacer, y desacoplar el solicitante del ejecutor.

## Qué hace el patrón 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
```

## Ejemplo

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

## Qué 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
```

## Por qué es importante

Entender el patrón Command es valioso porque es un **patrón de comportamiento útil** que permite capacidades importantes como deshacer/rehacer y encolar, por lo que es conocimiento de diseño relevante.

El patrón Command encapsula una solicitud como un objeto — convirtiendo una acción en un objeto independiente con sus datos y un método execute, desacoplando el solicitante del ejecutor.

Entender qué hace (representar una acción como un objeto que sabe qué hacer, con el invocador activando comandos sin conocer sus detalles) es el conocimiento central.

Entender **qué permite** es el valor clave: **deshacer/rehacer** (almacenar comandos ejecutados y llamar deshacer/rehacer, siendo cada comando consciente de cómo revertirse a sí mismo — el caso de uso clásico y poderoso para editores y aplicaciones), **encolar** (encolar comandos para ejecutar después, programar o agrupar), **registrar** (registrar comandos para reproducción, auditoría o transacciones), y **desacoplar** (el invocador sin conocer la implementación del comando).

Estas capacidades — especialmente deshacer/rehacer y encolar — son genuinamente valiosas y difíciles de implementar de forma limpia sin el patrón Command.

Entender los **usos** — deshacer/rehacer en editores, colas de tareas y trabajos en segundo plano, operaciones transaccionales, objetos de acción (como acciones de Redux, un ejemplo moderno ampliamente utilizado), grabación de macros, y elementos de GUI activando comandos — aclara su aplicabilidad en el mundo real.

El patrón Command es la forma limpia de implementar deshacer/rehacer, encolar, y arquitecturas basadas en acciones.

Ya que el patrón Command permite capacidades importantes (deshacer/rehacer, encolar, registrar, desacoplar) que son valiosas y difíciles de implementar de forma limpia de otra manera, y ya que aparece en sistemas reales (editores, colas de tareas, acciones de Redux), y ya que entender qué hace y permite es relevante para implementar estas capacidades, entender el patrón Command es conocimiento de diseño valioso y prácticamente relevante — un patrón útil que permite deshacer/rehacer, encolar, y arquitecturas basadas en acciones (como acciones de Redux), la forma limpia de implementar estas capacidades valiosas, y conocimiento de diseño importante para acciones que necesitan ser almacenadas, encoladas, registradas o deshechas.