This lesson follows Chain of Responsibility. A command packages an operation rather than deciding which handler receives it.

Command represents a request as an object. It stores the information needed to execute that request through a common method. This lets callers pass, queue, or record operations. The cost is another representation and rules for execution state.

Keep input controls separate from the operation

An editor's toolbar button and keyboard shortcut both append text. Copying edit logic into both controls ties the interface to the editor implementation. Connect both controls to a command contract instead.

interface Command { execute(): void }
interface UndoableCommand extends Command { undo(): void }
class Editor { text = "draft"; }
class AppendText implements UndoableCommand {
  private before: string | undefined;
  private executed = false;
  constructor(private editor: Editor, private addition: string) {}
  execute(): void {
    if (this.executed) throw new Error("Use a fresh command per edit");
    this.before = this.editor.text;
    this.editor.text += this.addition;
    this.executed = true;
  }
  undo(): void {
    if (!this.executed || this.before === undefined) {
      throw new Error("No edit to undo");
    }
    this.editor.text = this.before;
    this.before = undefined;
  }
}
class Button {
  constructor(private command: Command) {}
  click() { this.command.execute(); }
}

const editor = new Editor();
const edit = new AppendText(editor, " revised");
new Button(edit).click();
editor.text; // draft revised
edit.undo(); // draft

This is a single-use edit command with one undo. A UI that creates repeated edits must construct a fresh command per action. A stateless save command can be reusable. Do not confuse sharing an operation definition with sharing one mutable undo record.

Record enough information to reverse work

Map the roles

Role	In this example	Job
Sender (invoker)	Button, the keyboard shortcut	Starts requests. Holds a reference to a command and triggers it instead of calling the receiver. Usually receives a pre-built command from the client.
Command	Command, UndoableCommand	Declares a single method for executing the command, plus undo() when reversal is supported
Concrete commands	AppendText	Implement a kind of request. They do not do the real work themselves. They pass the call to a receiver, with the arguments stored in their fields.
Receiver	Editor	Contains the business logic. Almost any object can be a receiver.
Client	the code that wires a button to new AppendText(editor, " revised")	Creates and configures concrete commands, passing every request argument and the receiver into the command's constructor

Reach for it when a request needs a life of its own

• you want to parameterize objects with operations. A command turns a method call into an object. You can pass it as an argument, store it in another object, or swap it at runtime. A configurable context menu, where each item triggers a command chosen by the user, is a classic case.
• you want to queue operations, schedule them, or run them remotely. A command can be serialized into a string, written to a file or a database, and restored later. The same trick lets you queue, log, or send commands over the network.
• you want reversible operations. Command is the most popular way to build undo and redo. You keep a history stack of executed commands with backups of the state they changed.

Undo has two catches. Saving application state is hard when some of it is private, which Memento helps with. State backups can also use a lot of memory, so some commands perform the inverse operation instead, which can be hard or impossible.

Implement it in five steps

Refactor existing code toward the pattern in this order:

1. Declare the command interface with a single execution method.
2. Extract requests into concrete command classes that implement the interface. Each class gets fields for the request arguments and a reference to the receiver, all set through the constructor.
3. Identify the classes that act as senders. Add fields that store commands. Senders talk to commands only through the command interface, and they usually get commands from client code instead of creating them.
4. Change the senders so they execute the command instead of sending a request to the receiver directly.
5. Have the client initialize objects in this order: create the receivers, create the commands and link them to receivers, then create the senders and link them to commands.

Name what it costs

You gain	You pay
Classes that invoke operations are decoupled from classes that perform them (single responsibility)	A whole new layer between senders and receivers makes the code more complicated
New commands without breaking existing client code (open/closed)	Undo history consumes memory, and inverse operations can fail
Undo and redo	A durable queue needs serializable data and execution rules
Deferred execution of operations	Command objects or request records to maintain
Several simple commands combined into one complex command, a macro

Do not confuse it with its neighbors

Pattern	How it relates
Chain of Responsibility, Mediator, Observer	All four connect senders and receivers differently. Command creates a one-way connection between a sender and a receiver. Chain passes a request along possible receivers, Mediator routes through a central object, and Observer lets receivers subscribe dynamically.
Chain of Responsibility	Chain handlers can be implemented as commands. Or the request passed down a chain can itself be a command.
Memento	Use them together for undo. Commands perform operations on a target object. Mementos save that object's state just before a command runs.
Strategy	Both parameterize an object with some action, but with different intent. Command turns any operation into an object you can defer, queue, store, or send. Strategy describes different ways to do the same thing and lets you swap algorithms in one context.
Prototype	Helps when you need to save copies of commands into a history.
Visitor	Think of Visitor as a more powerful Command, whose objects can run operations over objects of different classes.

Retrieve and apply

Define a rename command's arguments, receiver, and undo data. Continue to Iterator to separate traversal state from collection storage.