Command Pattern: Turn an Action into Data

What is the Command pattern?

The Command pattern is a behavioral design pattern that turns a request into a stand-alone object carrying everything needed to perform it — the action, its parameters, and a reference to its receiver. Once an action is data, infrastructure can do things to it that are impossible with a plain method call: queue it, log it, retry it, schedule it, compose it into macros, and undo it.

The pattern splits three roles that usually blur together: the client that creates a command, the invoker that decides when it runs (a button, a queue worker, a history stack), and the receiver that does the actual work. The invoker's ignorance is the feature — an undo stack can manage ten thousand different operations because it sees nothing but execute() and undo().

The logic, step by step

interface Command {
  execute(): void;
  undo(): void;
}

class InsertText implements Command {
  constructor(private doc: TextDocument, private at: number, private text: string) {}
  execute(): void { this.doc.insert(this.at, this.text); }
  undo(): void { this.doc.delete(this.at, this.text.length); }
}

class DeleteRange implements Command {
  private removed = '';
  constructor(private doc: TextDocument, private at: number, private len: number) {}
  execute(): void { this.removed = this.doc.delete(this.at, this.len); }
  undo(): void { this.doc.insert(this.at, this.removed); }
}

class History {
  private done: Command[] = [];
  run(cmd: Command): void { cmd.execute(); this.done.push(cmd); }
  undoLast(): void { this.done.pop()?.undo(); }
}

const history = new History();
history.run(new InsertText(doc, 0, 'Hello'));
history.run(new DeleteRange(doc, 0, 5));
history.undoLast(); // "Hello" is back — DeleteRange remembered what it removed

When to use it — and when not to

Command vs related patterns

Strategy pattern — Strategy encapsulates how something is done and a context holds one at a time; Command encapsulates that something should be done and invokers can hold thousands (queues, histories, macros).

Observer pattern — Observer notifies whoever happens to listen; Command targets a known receiver. Events describe the past ("order placed"), commands request a future ("place order").