O que é o padrão Command?

Question

Accepted Answer

O padrão **Command** encapsula uma **requisição como um objeto** — transformando uma ação em um objeto autônomo com todas as suas informações. Isso permite enfileiramento, registro, desfazer/refazer e desacoplar o solicitante do executor.

## O que o padrão Command faz

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

## Exemplo

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

## O que 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 que isso importa

Compreender o padrão Command é valioso porque é um **padrão comportamental útil** que permite capacidades importantes como desfazer/refazer e enfileiramento, portanto é conhecimento de design relevante.

O padrão Command encapsula uma requisição como um objeto — transformando uma ação em um objeto autônomo com seus dados e um método execute, desacoplando o solicitante do executor.

Compreender o que faz (representar uma ação como um objeto que sabe o que fazer, com o invocador acionando comandos sem conhecer seus detalhes) é o conhecimento essencial.

Compreender **o que permite** é o valor-chave: **desfazer/refazer** (armazenar comandos executados e chamar desfazer/refazer, com cada comando sabendo como reverter a si mesmo — o caso de uso clássico e poderoso para editores e aplicações), **enfileiramento** (enfileirar comandos para executar depois, agendar ou agrupar), **registro** (registrar comandos para reprodução, auditoria ou transações), e **desacoplamento** (o invocador não conhecendo a implementação do comando).

Essas capacidades — especialmente desfazer/refazer e enfileiramento — são genuinamente valiosas e difíceis de implementar de forma limpa sem o padrão Command.

Compreender os **usos** — desfazer/refazer em editores, filas de tarefas e trabalhos em background, operações transacionais, objetos de ação (como ações Redux, um exemplo moderno amplamente utilizado), gravação de macros e elementos GUI acionando comandos — esclarece sua aplicabilidade no mundo real.

O padrão Command é a forma limpa de implementar desfazer/refazer, enfileiramento e arquiteturas baseadas em ações.

Como o padrão Command permite capacidades importantes (desfazer/refazer, enfileiramento, registro, desacoplamento) que são valiosas e difíceis de implementar de forma limpa de outro modo, e como aparece em sistemas reais (editores, filas de tarefas, ações Redux), e como compreender o que faz e permite é relevante para implementar essas capacidades, compreender o padrão Command é conhecimento de design valioso e praticamente relevante — um padrão útil que permite desfazer/refazer, enfileiramento e arquiteturas baseadas em ações (como ações Redux), a forma limpa de implementar essas capacidades valiosas e conhecimento de design importante para ações que precisam ser armazenadas, enfileiradas, registradas ou desfeitas.