Command Pattern

The Command Pattern is a behavioral design pattern that turns a request into a stand-alone object that contains all information about the request. This transformation lets you parameterize methods with different requests, delay or queue a request's execution, and support undoable operations.

1. The Core Concept

The pattern decouples the object that invokes the operation (Sender/Invoker) from the one that knows how to perform it (Receiver).

Command: An object representing a specific action. It wraps the method call and its parameters.
Invoker: The object that triggers the command (e.g., a Button). It doesn't know what the command does, just that it can execute() it.
Receiver: The object that actually does the work (e.g., the Light bulb).

2. Analogy: Restaurant Order

You (Client) give an order to the Waiter (Invoker).
The Waiter writes the order on a Check (Command).
The Waiter places the check in the kitchen queue.
The Chef (Receiver) picks up the check and cooks the meal.

The Waiter doesn't need to know how to cook. The Chef doesn't need to know who ordered. The Check isolates them.

3. Example (TypeScript)

Let's build a remote control for a smart home.

// The Command Interface
interface Command {
    execute(): void;
    undo(): void;
}

// The Receiver
class Light {
    turnOn() { console.log("Light is ON"); }
    turnOff() { console.log("Light is OFF"); }
}

// Concrete Command 1
class TurnOnLightCommand implements Command {
    private light: Light;

    constructor(light: Light) {
        this.light = light;
    }

    execute() {
        this.light.turnOn();
    }

    undo() {
        this.light.turnOff();
    }
}

// The Invoker
class RemoteControl {
    private command: Command;

    setCommand(command: Command) {
        this.command = command;
    }

    pressButton() {
        this.command.execute();
    }

    pressUndo() {
        this.command.undo();
    }
}

// Usage
const light = new Light();
const turnOn = new TurnOnLightCommand(light);

const remote = new RemoteControl();

remote.setCommand(turnOn);
remote.pressButton(); // Output: Light is ON

remote.pressUndo();   // Output: Light is OFF

4. Pros and Cons

Pros	Cons
Decoupling: Removes direct dependency between the invoker and the receiver.	Complexity: Introduces a lot of new classes (a class for every action).
Undo/Redo: Easy to implement undo/redo functionality.
Queueing: Commands can be serialized, queued, or delayed.
Composite Commands: You can assemble simple commands into complex ones (Macros).

programming/design-patterns programming/object-oriented-programming

Backlinks

Created: March 17, 2026 • Last Modified: January 31, 2026

Docs Login