{"title":"Command Design Pattern","description":null,"content":"\n\n\n\n> **DEFINITION**\n>\n> The **Command Design Pattern** is a **behavioral pattern** that turns a request into a **standalone object**, allowing you to **parameterize actions**, queue them, log them, or support undoable operations all while decoupling the sender from the receiver.\n\n\nIt’s particularly useful in situations where:\n\n- You want to **encapsulate operations** as objects.\n- You need to **queue, delay, or log requests**.\n- You want to **support undo/redo functionality**.\n- You want to **decouple the object that invokes an operation from the one that knows how to perform it**.\n\nLet’s walk through a real-world example to see how we can apply the Command Pattern to decouple invokers from executors, and build a more flexible, extensible, and testable command execution framework.\n\n---\n\n# 1. The Problem: The Tightly Coupled Smart Home Controller\n\nImagine you are building a smart home hub. The hub needs to control various devices: lights, thermostats, and more. You need a controller that can send commands to these devices.\n\n### Naive Implementation: One Controller to Rule Them All\n\nThe straightforward approach is to give the controller direct references to every device and write a specific method for each action. Let's see what this looks like.\n\n\n```java\nclass Light {\n public void on() {\n System.out.println(\"Light turned ON\");\n }\n\n public void off() {\n System.out.println(\"Light turned OFF\");\n }\n}\n\nclass Thermostat {\n public void setTemperature(int temp) {\n System.out.println(\"Thermostat set to \" + temp + \"C\");\n }\n}\n\nclass SmartHomeControllerNaive {\n private final Light light;\n private final Thermostat thermostat;\n\n public SmartHomeControllerNaive(Light light, Thermostat thermostat) {\n this.light = light;\n this.thermostat = thermostat;\n }\n\n public void turnOnLight() {\n light.on();\n }\n\n public void turnOffLight() {\n light.off();\n }\n\n public void setThermostatTemperature(int temperature) {\n thermostat.setTemperature(temperature);\n }\n}\n\npublic class SmartHomeNaive {\n public static void main(String[] args) {\n Light light = new Light();\n Thermostat thermostat = new Thermostat();\n SmartHomeControllerNaive controller = new SmartHomeControllerNaive(light, thermostat);\n\n controller.turnOnLight();\n controller.setThermostatTemperature(22);\n controller.turnOffLight();\n }\n}\n```\n\n```python\nclass Light:\n def on(self):\n print(\"Light turned ON\")\n\n def off(self):\n print(\"Light turned OFF\")\n\nclass Thermostat:\n def set_temperature(self, temp):\n print(f\"Thermostat set to {temp}C\")\n\nclass SmartHomeControllerNaive:\n def __init__(self, light, thermostat):\n self.light = light\n self.thermostat = thermostat\n\n def turn_on_light(self):\n self.light.on()\n\n def turn_off_light(self):\n self.light.off()\n\n def set_thermostat_temperature(self, temperature):\n self.thermostat.set_temperature(temperature)\n\nlight = Light()\nthermostat = Thermostat()\ncontroller = SmartHomeControllerNaive(light, thermostat)\n\ncontroller.turn_on_light()\ncontroller.set_thermostat_temperature(22)\ncontroller.turn_off_light()\n```\n\n```cpp\n#include \nusing namespace std;\n\nclass Light {\npublic:\n void on() {\n cout << \"Light turned ON\" << endl;\n }\n\n void off() {\n cout << \"Light turned OFF\" << endl;\n }\n};\n\nclass Thermostat {\npublic:\n void setTemperature(int temp) {\n cout << \"Thermostat set to \" << temp << \"C\" << endl;\n }\n};\n\nclass SmartHomeControllerNaive {\nprivate:\n Light* light;\n Thermostat* thermostat;\n\npublic:\n SmartHomeControllerNaive(Light* light, Thermostat* thermostat)\n : light(light), thermostat(thermostat) {}\n\n void turnOnLight() { light->on(); }\n void turnOffLight() { light->off(); }\n void setThermostatTemperature(int temperature) {\n thermostat->setTemperature(temperature);\n }\n};\n\nint main() {\n Light light;\n Thermostat thermostat;\n SmartHomeControllerNaive controller(&light, &thermostat);\n\n controller.turnOnLight();\n controller.setThermostatTemperature(22);\n controller.turnOffLight();\n return 0;\n}\n```\n\n```go\npackage main\n\nimport \"fmt\"\n\ntype Light struct{}\n\nfunc (l *Light) On() {\n\tfmt.Println(\"Light turned ON\")\n}\n\nfunc (l *Light) Off() {\n\tfmt.Println(\"Light turned OFF\")\n}\n\ntype Thermostat struct{}\n\nfunc (t *Thermostat) SetTemperature(temp int) {\n\tfmt.Printf(\"Thermostat set to %dC\\n\", temp)\n}\n\ntype SmartHomeControllerNaive struct {\n\tlight *Light\n\tthermostat *Thermostat\n}\n\nfunc NewSmartHomeControllerNaive(light *Light, thermostat *Thermostat) *SmartHomeControllerNaive {\n\treturn &SmartHomeControllerNaive{light: light, thermostat: thermostat}\n}\n\nfunc (s *SmartHomeControllerNaive) TurnOnLight() {\n\ts.light.On()\n}\n\nfunc (s *SmartHomeControllerNaive) TurnOffLight() {\n\ts.light.Off()\n}\n\nfunc (s *SmartHomeControllerNaive) SetThermostatTemperature(temperature int) {\n\ts.thermostat.SetTemperature(temperature)\n}\n\nfunc main() {\n\tlight := &Light{}\n\tthermostat := &Thermostat{}\n\tcontroller := NewSmartHomeControllerNaive(light, thermostat)\n\n\tcontroller.TurnOnLight()\n\tcontroller.SetThermostatTemperature(22)\n\tcontroller.TurnOffLight()\n}\n```\n\n```csharp\nusing System;\n\nclass Light\n{\n public void On() { Console.WriteLine(\"Light turned ON\"); }\n public void Off() { Console.WriteLine(\"Light turned OFF\"); }\n}\n\nclass Thermostat\n{\n public void SetTemperature(int temp)\n {\n Console.WriteLine($\"Thermostat set to {temp}C\");\n }\n}\n\nclass SmartHomeControllerNaive\n{\n private readonly Light light;\n private readonly Thermostat thermostat;\n\n public SmartHomeControllerNaive(Light light, Thermostat thermostat)\n {\n this.light = light;\n this.thermostat = thermostat;\n }\n\n public void TurnOnLight() { light.On(); }\n public void TurnOffLight() { light.Off(); }\n public void SetThermostatTemperature(int temperature)\n {\n thermostat.SetTemperature(temperature);\n }\n}\n\nclass Program\n{\n static void Main()\n {\n var light = new Light();\n var thermostat = new Thermostat();\n var controller = new SmartHomeControllerNaive(light, thermostat);\n\n controller.TurnOnLight();\n controller.SetThermostatTemperature(22);\n controller.TurnOffLight();\n }\n}\n```\n\n```typescript\nclass Light {\n on(): void { console.log(\"Light turned ON\"); }\n off(): void { console.log(\"Light turned OFF\"); }\n}\n\nclass Thermostat {\n setTemperature(temp: number): void {\n console.log(`Thermostat set to ${temp}C`);\n }\n}\n\nclass SmartHomeControllerNaive {\n private readonly light: Light;\n private readonly thermostat: Thermostat;\n\n constructor(light: Light, thermostat: Thermostat) {\n this.light = light;\n this.thermostat = thermostat;\n }\n\n turnOnLight(): void { this.light.on(); }\n turnOffLight(): void { this.light.off(); }\n setThermostatTemperature(temperature: number): void {\n this.thermostat.setTemperature(temperature);\n }\n}\n\nconst light = new Light();\nconst thermostat = new Thermostat();\nconst controller = new SmartHomeControllerNaive(light, thermostat);\n\ncontroller.turnOnLight();\ncontroller.setThermostatTemperature(22);\ncontroller.turnOffLight();\n```\n\n\n### Why This Design Fails as the System Grows?\n\nThis simple controller **works for now**, but quickly falls apart as complexity increases.\n\n#### 1. Tight Coupling\n\nThe `SmartHomeControllerNaive` is directly tied to every device and their specific method names. You cannot reuse or generalize actions. Every new device requires adding new fields and new methods to the controller.\n\n#### 2. Poor Scalability\n\nAdding a new device (sprinkler, garage door, speaker) means adding new fields to the controller, writing more methods for each action, and growing a single class into a bloated monolith. The controller knows about every device in the house.\n\n#### 3. No Undo/Redo Support\n\nThere is no way to reverse a command. Want to implement \"undo last action\"? You would need to track device states manually, write custom undo logic for every method, and add a large switch/if-else block to figure out what action to reverse. Fragile, repetitive, and error-prone.\n\n#### 4. No Scheduling or Queuing\n\nIf a user wants to set a rule like \"turn on the lights at 7 PM,\" you cannot queue up what to do because actions are hardcoded into method calls, not represented as standalone objects you can store and execute later.\n\n#### 5. No Reusable Actions\n\nIf the same \"turn on light\" action needs to be triggered from a physical button, a voice assistant, a mobile app, and a timer, each trigger point needs its own coupling to the Light class. The action cannot be passed around as a first-class object.\n\n### What We Really Need\n\nWe need to treat each command (\"turn on light\", \"set thermostat to 22C\") as a standalone object that encapsulates what to do, which device it affects, how to execute it, and how to undo it. The controller, remote, or scheduler should not care how a command works. It should just know which command to execute.\n\nThis is exactly what the **Command Design Pattern** enables.\n\n---\n\n# 2. What is the Command Pattern\n\nThe Command pattern is a behavioral design pattern that turns a request into a standalone object containing all the information needed to perform that request. This lets you parameterize methods with different requests, delay or queue a request's execution, and support undoable operations.\n\nTwo characteristics define the pattern:\n\n1. **Encapsulation of requests as objects.** Each action (turn on light, set temperature, play music) becomes its own object implementing a common interface. The object holds a reference to the receiver and knows exactly how to execute (and optionally undo) the action.\n2. **Decoupling of invoker and receiver.** The invoker (a button, scheduler, or voice assistant) does not know which receiver it is talking to or what the action does. It simply holds a Command reference and calls `execute()`. This means the same invoker can trigger any command without modification.\n\n\n> **Real-World Analogy**\n>\n> Think about ordering at a restaurant. You tell the waiter what you want (your request), and the waiter writes it on an order slip. The waiter does not cook the food. They carry the slip to the kitchen and hand it to the chef. The chef reads the slip and prepares the dish. \n>\n> The order slip is the command object. The waiter is the invoker, carrying and delivering the request. The chef is the receiver, doing the actual work. The customer is the client, creating the request. \n>\n> The waiter does not need to know how to cook, and the chef does not need to know who ordered. The slip decouples them completely. If you want to cancel, the waiter pulls the slip from the queue, the same slip that started the process can undo it.\n\n\n---\n\n### Class Diagram\n\n\n```mermaid\nclassDiagram\n class Command {\n <>\n +execute()\n +undo()\n }\n\n class ConcreteCommandA {\n -receiver: ReceiverA\n +execute()\n +undo()\n }\n\n class ConcreteCommandB {\n -receiver: ReceiverB\n +execute()\n +undo()\n }\n\n class ReceiverA {\n +action()\n }\n\n class ReceiverB {\n +action()\n }\n\n class Invoker {\n -command: Command\n -history: Stack~Command~\n +setCommand(Command)\n +executeCommand()\n +undoLast()\n }\n\n Command <|.. ConcreteCommandA\n Command <|.. ConcreteCommandB\n ConcreteCommandA --> ReceiverA : delegates to\n ConcreteCommandB --> ReceiverB : delegates to\n Invoker --> Command : invokes\n\n style Command fill:#00ceff,stroke:#000,color:#000\n style ConcreteCommandA fill:#ffa94d,stroke:#000,color:#000\n style ConcreteCommandB fill:#ffa94d,stroke:#000,color:#000\n style ReceiverA fill:#69db7c,stroke:#000,color:#000\n style ReceiverB fill:#69db7c,stroke:#000,color:#000\n style Invoker fill:#38d9a9,stroke:#000,color:#000\n```\n\n\n#### Command (Interface)\n\nDeclares the common interface that all commands must implement. At minimum, this is an `execute()` method. Most practical implementations also include an `undo()` method.\n\n\n> **Should undo() be part of the interface?**\n>\n> If every command in your system needs to be reversible, yes. If only some do, consider a separate `UndoableCommand` interface or a no-op default implementation. For this chapter, we include `undo()` in the base interface because undo is one of Command's primary strengths.\n\n\n#### ConcreteCommand (e.g., `LightOnCommand`, `SetTemperatureCommand`)\n\nImplements the Command interface and bridges the gap between the invoker and a specific receiver.\n\nStores a reference to the receiver that will perform the actual work. Implement `execute()` by delegating to the receiver's method(s).\n\n#### Receiver (e.g., `Light`, `Thermostat`)\n\nThe object that performs the actual business logic. It knows how to carry out the operation but has no knowledge of commands or the invoker. The receiver does not depend on the command infrastructure at all. It is a plain domain object.\n\n#### Invoker (e.g., `RemoteControl`, `Scheduler`)\n\nTriggers command execution. It does not know what the command does or which receiver is involved. It only knows how to call `execute()` and optionally maintain a command history for undo.\n\n---\n\n# 3. How It Works\n\nHere is the Command workflow step by step:\n\n\n```mermaid\nsequenceDiagram\n participant Client as Client\n participant Invoker as RemoteControl\n participant Command as LightOnCommand\n participant Receiver as Light\n\n Client->>Command: new LightOnCommand(light)\n Client->>Invoker: setCommand(lightOnCmd)\n\n Client->>Invoker: pressButton()\n Invoker->>Command: execute()\n Command->>Receiver: on()\n Note over Invoker: Push to history stack\n\n Client->>Invoker: pressUndo()\n Note over Invoker: Pop from history stack\n Invoker->>Command: undo()\n Command->>Receiver: off()\n```\n\n\n#### **Step 1: Client creates receivers and commands**\n\nThe client instantiates the receiver objects (Light, Thermostat) and creates concrete command objects, passing each command a reference to the appropriate receiver.\n\n#### **Step 2: Client configures the invoker**\n\nThe client assigns command objects to the invoker (e.g., assigning a command to a button slot on a remote control).\n\n#### **Step 3: User triggers the invoker**\n\nWhen the user presses a button, the invoker calls `execute()` on the assigned command. The invoker does not know what will happen, it just calls the interface method.\n\n#### **Step 4: Command delegates to the receiver**\n\nThe concrete command's `execute()` method calls the appropriate method on the receiver. If undo is needed, the command first captures the receiver's current state.\n\n#### **Step 5: Invoker records the command in history**\n\nAfter successful execution, the invoker pushes the command onto a history stack for potential undo.\n\n#### **Step 6: User triggers undo**\n\nThe invoker pops the most recent command from the history stack and calls its `undo()` method. The command reverses its effect on the receiver.\n\n---\n\n# 4. Implementing Command Pattern\n\nLet’s refactor our Smart Home Controller to use the **Command Pattern** with support for **undoable actions**. We'll encapsulate each action as a command, decouple the invoker from the logic, and allow undoing previous actions.\n\n\n```mermaid\nclassDiagram\n class Command {\n <>\n +execute()\n +undo()\n }\n\n class LightOnCommand {\n -light: Light\n +execute()\n +undo()\n }\n\n class LightOffCommand {\n -light: Light\n +execute()\n +undo()\n }\n\n class SetTemperatureCommand {\n -thermostat: Thermostat\n -newTemp: int\n -previousTemp: int\n +execute()\n +undo()\n }\n\n class Light {\n +on()\n +off()\n }\n\n class Thermostat {\n -currentTemp: int\n +setTemperature(temp)\n +getCurrentTemperature(): int\n }\n\n class RemoteControl {\n -history: Stack~Command~\n +executeCommand(Command)\n +undoLast()\n }\n\n Command <|.. LightOnCommand\n Command <|.. LightOffCommand\n Command <|.. SetTemperatureCommand\n LightOnCommand --> Light : delegates to\n LightOffCommand --> Light : delegates to\n SetTemperatureCommand --> Thermostat : delegates to\n RemoteControl --> Command : invokes\n\n style Command fill:#00ceff,stroke:#000,color:#000\n style LightOnCommand fill:#ffa94d,stroke:#000,color:#000\n style LightOffCommand fill:#ffa94d,stroke:#000,color:#000\n style SetTemperatureCommand fill:#ffa94d,stroke:#000,color:#000\n style Light fill:#69db7c,stroke:#000,color:#000\n style Thermostat fill:#69db7c,stroke:#000,color:#000\n style RemoteControl fill:#38d9a9,stroke:#000,color:#000\n```\n\n\n### Step 1: Define the Command Interface\n\nAll commands must implement `execute()` and `undo()`.\n\n\n```java\ninterface Command {\n void execute();\n void undo();\n}\n```\n\n```python\nfrom abc import ABC, abstractmethod\n\nclass Command(ABC):\n @abstractmethod\n def execute(self):\n pass\n\n @abstractmethod\n def undo(self):\n pass\n```\n\n```cpp\nclass Command {\npublic:\n virtual ~Command() = default;\n virtual void execute() = 0;\n virtual void undo() = 0;\n};\n```\n\n```go\ntype Command interface {\n\tExecute()\n\tUndo()\n}\n```\n\n```csharp\ninterface ICommand\n{\n void Execute();\n void Undo();\n}\n```\n\n```typescript\ninterface Command {\n execute(): void;\n undo(): void;\n}\n```\n\n\n### Step 2: Define the Receivers\n\nThese are the actual smart home devices that perform the work. They have no knowledge of commands or the invoker.\n\n\n```java\nclass Light {\n public void on() {\n System.out.println(\"Light turned ON\");\n }\n\n public void off() {\n System.out.println(\"Light turned OFF\");\n }\n}\n\nclass Thermostat {\n private int currentTemperature = 20;\n\n public void setTemperature(int temp) {\n System.out.println(\"Thermostat set to \" + temp + \"C\");\n currentTemperature = temp;\n }\n\n public int getCurrentTemperature() {\n return currentTemperature;\n }\n}\n```\n\n```python\nclass Light:\n def on(self):\n print(\"Light turned ON\")\n\n def off(self):\n print(\"Light turned OFF\")\n\nclass Thermostat:\n def __init__(self):\n self.current_temperature = 20\n\n def set_temperature(self, temp):\n print(f\"Thermostat set to {temp}C\")\n self.current_temperature = temp\n\n def get_current_temperature(self):\n return self.current_temperature\n```\n\n```cpp\n#include \n#include \nusing namespace std;\n\nclass Light {\npublic:\n void on() { cout << \"Light turned ON\" << endl; }\n void off() { cout << \"Light turned OFF\" << endl; }\n};\n\nclass Thermostat {\nprivate:\n int currentTemperature = 20;\n\npublic:\n void setTemperature(int temp) {\n cout << \"Thermostat set to \" << temp << \"C\" << endl;\n currentTemperature = temp;\n }\n\n int getCurrentTemperature() const { return currentTemperature; }\n};\n```\n\n```go\ntype Light struct{}\n\nfunc (l *Light) On() {\n\tfmt.Println(\"Light turned ON\")\n}\n\nfunc (l *Light) Off() {\n\tfmt.Println(\"Light turned OFF\")\n}\n\ntype Thermostat struct {\n\tcurrentTemperature int\n}\n\nfunc (t *Thermostat) SetTemperature(temp int) {\n\tfmt.Printf(\"Thermostat set to %dC\\n\", temp)\n\tt.currentTemperature = temp\n}\n\nfunc (t *Thermostat) GetCurrentTemperature() int {\n\treturn t.currentTemperature\n}\n```\n\n```csharp\nusing System;\nusing System.Collections.Generic;\n\nclass Light\n{\n public void On() { Console.WriteLine(\"Light turned ON\"); }\n public void Off() { Console.WriteLine(\"Light turned OFF\"); }\n}\n\nclass Thermostat\n{\n private int currentTemperature = 20;\n\n public void SetTemperature(int temp)\n {\n Console.WriteLine($\"Thermostat set to {temp}C\");\n currentTemperature = temp;\n }\n\n public int GetCurrentTemperature() => currentTemperature;\n}\n```\n\n```typescript\nclass Light {\n on(): void { console.log(\"Light turned ON\"); }\n off(): void { console.log(\"Light turned OFF\"); }\n}\n\nclass Thermostat {\n private currentTemperature: number = 20;\n\n setTemperature(temp: number): void {\n console.log(`Thermostat set to ${temp}C`);\n this.currentTemperature = temp;\n }\n\n getCurrentTemperature(): number {\n return this.currentTemperature;\n }\n}\n```\n\n\n### Step 3: Implement Concrete Commands\n\nEach command wraps a specific receiver action. For simple on/off commands, undo calls the inverse method. For commands that change state (like temperature), the command saves the previous state before executing so it can restore it during undo.\n\n\n```java\nclass LightOnCommand implements Command {\n private final Light light;\n\n public LightOnCommand(Light light) {\n this.light = light;\n }\n\n @Override\n public void execute() { light.on(); }\n\n @Override\n public void undo() { light.off(); }\n}\n\nclass LightOffCommand implements Command {\n private final Light light;\n\n public LightOffCommand(Light light) {\n this.light = light;\n }\n\n @Override\n public void execute() { light.off(); }\n\n @Override\n public void undo() { light.on(); }\n}\n\nclass SetTemperatureCommand implements Command {\n private final Thermostat thermostat;\n private final int newTemperature;\n private int previousTemperature;\n\n public SetTemperatureCommand(Thermostat thermostat, int temperature) {\n this.thermostat = thermostat;\n this.newTemperature = temperature;\n }\n\n @Override\n public void execute() {\n previousTemperature = thermostat.getCurrentTemperature();\n thermostat.setTemperature(newTemperature);\n }\n\n @Override\n public void undo() {\n thermostat.setTemperature(previousTemperature);\n }\n}\n```\n\n```python\nclass LightOnCommand(Command):\n def __init__(self, light):\n self.light = light\n\n def execute(self):\n self.light.on()\n\n def undo(self):\n self.light.off()\n\nclass LightOffCommand(Command):\n def __init__(self, light):\n self.light = light\n\n def execute(self):\n self.light.off()\n\n def undo(self):\n self.light.on()\n\nclass SetTemperatureCommand(Command):\n def __init__(self, thermostat, temperature):\n self.thermostat = thermostat\n self.new_temperature = temperature\n self.previous_temperature = None\n\n def execute(self):\n self.previous_temperature = self.thermostat.get_current_temperature()\n self.thermostat.set_temperature(self.new_temperature)\n\n def undo(self):\n self.thermostat.set_temperature(self.previous_temperature)\n```\n\n```cpp\nclass LightOnCommand : public Command {\nprivate:\n Light* light;\n\npublic:\n LightOnCommand(Light* light) : light(light) {}\n void execute() override { light->on(); }\n void undo() override { light->off(); }\n};\n\nclass LightOffCommand : public Command {\nprivate:\n Light* light;\n\npublic:\n LightOffCommand(Light* light) : light(light) {}\n void execute() override { light->off(); }\n void undo() override { light->on(); }\n};\n\nclass SetTemperatureCommand : public Command {\nprivate:\n Thermostat* thermostat;\n int newTemperature;\n int previousTemperature;\n\npublic:\n SetTemperatureCommand(Thermostat* thermostat, int temperature)\n : thermostat(thermostat), newTemperature(temperature), previousTemperature(0) {}\n\n void execute() override {\n previousTemperature = thermostat->getCurrentTemperature();\n thermostat->setTemperature(newTemperature);\n }\n\n void undo() override {\n thermostat->setTemperature(previousTemperature);\n }\n};\n```\n\n```go\ntype LightOnCommand struct {\n\tlight Light\n}\n\nfunc NewLightOnCommand(light Light) *LightOnCommand {\n\treturn &LightOnCommand{light: light}\n}\n\nfunc (c *LightOnCommand) Execute() { c.light.on() }\n\nfunc (c *LightOnCommand) Undo() { c.light.off() }\n\ntype LightOffCommand struct {\n\tlight Light\n}\n\nfunc NewLightOffCommand(light Light) *LightOffCommand {\n\treturn &LightOffCommand{light: light}\n}\n\nfunc (c *LightOffCommand) Execute() { c.light.off() }\n\nfunc (c *LightOffCommand) Undo() { c.light.on() }\n\ntype SetTemperatureCommand struct {\n\tthermostat Thermostat\n\tnewTemperature int\n\tpreviousTemperature int\n}\n\nfunc NewSetTemperatureCommand(thermostat Thermostat, temperature int) *SetTemperatureCommand {\n\treturn &SetTemperatureCommand{thermostat: thermostat, newTemperature: temperature}\n}\n\nfunc (c *SetTemperatureCommand) Execute() {\n\tc.previousTemperature = c.thermostat.getCurrentTemperature()\n\tc.thermostat.setTemperature(c.newTemperature)\n}\n\nfunc (c *SetTemperatureCommand) Undo() {\n\tc.thermostat.setTemperature(c.previousTemperature)\n}\n```\n\n```csharp\nclass LightOnCommand : ICommand\n{\n private readonly Light light;\n public LightOnCommand(Light light) { this.light = light; }\n public void Execute() { light.On(); }\n public void Undo() { light.Off(); }\n}\n\nclass LightOffCommand : ICommand\n{\n private readonly Light light;\n public LightOffCommand(Light light) { this.light = light; }\n public void Execute() { light.Off(); }\n public void Undo() { light.On(); }\n}\n\nclass SetTemperatureCommand : ICommand\n{\n private readonly Thermostat thermostat;\n private readonly int newTemperature;\n private int previousTemperature;\n\n public SetTemperatureCommand(Thermostat thermostat, int temperature)\n {\n this.thermostat = thermostat;\n this.newTemperature = temperature;\n }\n\n public void Execute()\n {\n previousTemperature = thermostat.GetCurrentTemperature();\n thermostat.SetTemperature(newTemperature);\n }\n\n public void Undo()\n {\n thermostat.SetTemperature(previousTemperature);\n }\n}\n```\n\n```typescript\nclass LightOnCommand implements Command {\n constructor(private readonly light: Light) {}\n execute(): void { this.light.on(); }\n undo(): void { this.light.off(); }\n}\n\nclass LightOffCommand implements Command {\n constructor(private readonly light: Light) {}\n execute(): void { this.light.off(); }\n undo(): void { this.light.on(); }\n}\n\nclass SetTemperatureCommand implements Command {\n private previousTemperature: number = 0;\n\n constructor(\n private readonly thermostat: Thermostat,\n private readonly newTemperature: number\n ) {}\n\n execute(): void {\n this.previousTemperature = this.thermostat.getCurrentTemperature();\n this.thermostat.setTemperature(this.newTemperature);\n }\n\n undo(): void {\n this.thermostat.setTemperature(this.previousTemperature);\n }\n}\n```\n\n\nNotice the key difference between `LightOnCommand` and `SetTemperatureCommand`. The light commands have a trivial undo: just call the opposite method. The temperature command needs to save the previous temperature before changing it, because there is no single \"reverse\" of setting a temperature, you need to know what it was before.\n\n### Step 4: Create the Invoker with Undo Support\n\nThe `RemoteControl` is the invoker. It accepts any command, executes it, and maintains a history stack for undo. It never knows what the commands do or which devices they affect.\n\n\n```java\nimport java.util.Stack;\n\nclass RemoteControl {\n private final Stack history = new Stack<>();\n\n public void executeCommand(Command command) {\n command.execute();\n history.push(command);\n }\n\n public void undoLast() {\n if (!history.isEmpty()) {\n Command lastCommand = history.pop();\n lastCommand.undo();\n } else {\n System.out.println(\"Nothing to undo.\");\n }\n }\n}\n```\n\n```python\nclass RemoteControl:\n def __init__(self):\n self.history = []\n\n def execute_command(self, command):\n command.execute()\n self.history.append(command)\n\n def undo_last(self):\n if self.history:\n last_command = self.history.pop()\n last_command.undo()\n else:\n print(\"Nothing to undo.\")\n```\n\n```cpp\nclass RemoteControl {\nprivate:\n stack history;\n\npublic:\n void executeCommand(Command* command) {\n command->execute();\n history.push(command);\n }\n\n void undoLast() {\n if (!history.empty()) {\n Command* lastCommand = history.top();\n history.pop();\n lastCommand->undo();\n } else {\n cout << \"Nothing to undo.\" << endl;\n }\n }\n};\n```\n\n```go\ntype RemoteControl struct {\n\thistory []Command\n}\n\nfunc (r *RemoteControl) ExecuteCommand(command Command) {\n\tcommand.Execute()\n\tr.history = append(r.history, command)\n}\n\nfunc (r *RemoteControl) UndoLast() {\n\tif len(r.history) > 0 {\n\t\tlastCommand := r.history[len(r.history)-1]\n\t\tr.history = r.history[:len(r.history)-1]\n\t\tlastCommand.Undo()\n\t} else {\n\t\tfmt.Println(\"Nothing to undo.\")\n\t}\n}\n```\n\n```csharp\nclass RemoteControl\n{\n private readonly Stack history = new();\n\n public void ExecuteCommand(ICommand command)\n {\n command.Execute();\n history.Push(command);\n }\n\n public void UndoLast()\n {\n if (history.Count > 0)\n {\n var lastCommand = history.Pop();\n lastCommand.Undo();\n }\n else\n {\n Console.WriteLine(\"Nothing to undo.\");\n }\n }\n}\n```\n\n```typescript\nclass RemoteControl {\n private readonly history: Command[] = [];\n\n executeCommand(command: Command): void {\n command.execute();\n this.history.push(command);\n }\n\n undoLast(): void {\n if (this.history.length > 0) {\n const lastCommand = this.history.pop()!;\n lastCommand.undo();\n } else {\n console.log(\"Nothing to undo.\");\n }\n }\n}\n```\n\n\nThe `RemoteControl` is clean and focused. It does not import Light, Thermostat, or any device class. It only depends on the Command interface. Adding a hundred new device types does not require changing a single line in this class.\n\n### Step 5: Client Code\n\nThe client wires everything together: creates receivers, wraps them in commands, and hands the commands to the invoker.\n\n\n```java\npublic class SmartHomeApp {\n public static void main(String[] args) {\n Light light = new Light();\n Thermostat thermostat = new Thermostat();\n\n Command lightOn = new LightOnCommand(light);\n Command lightOff = new LightOffCommand(light);\n Command setTemp = new SetTemperatureCommand(thermostat, 25);\n\n RemoteControl remote = new RemoteControl();\n\n System.out.println(\"--- Executing Commands ---\");\n remote.executeCommand(lightOn);\n remote.executeCommand(setTemp);\n remote.executeCommand(lightOff);\n\n System.out.println(\"\\n--- Undoing Commands ---\");\n remote.undoLast();\n remote.undoLast();\n remote.undoLast();\n remote.undoLast();\n }\n}\n```\n\n```python\ndef main():\n light = Light()\n thermostat = Thermostat()\n\n light_on = LightOnCommand(light)\n light_off = LightOffCommand(light)\n set_temp = SetTemperatureCommand(thermostat, 25)\n\n remote = RemoteControl()\n\n print(\"--- Executing Commands ---\")\n remote.execute_command(light_on)\n remote.execute_command(set_temp)\n remote.execute_command(light_off)\n\n print(\"\\n--- Undoing Commands ---\")\n remote.undo_last()\n remote.undo_last()\n remote.undo_last()\n remote.undo_last()\n\nif __name__ == \"__main__\":\n main()\n```\n\n```cpp\nint main() {\n Light light;\n Thermostat thermostat;\n\n LightOnCommand lightOn(&light);\n LightOffCommand lightOff(&light);\n SetTemperatureCommand setTemp(&thermostat, 25);\n\n RemoteControl remote;\n\n cout << \"--- Executing Commands ---\" << endl;\n remote.executeCommand(&lightOn);\n remote.executeCommand(&setTemp);\n remote.executeCommand(&lightOff);\n\n cout << \"\\n--- Undoing Commands ---\" << endl;\n remote.undoLast();\n remote.undoLast();\n remote.undoLast();\n remote.undoLast();\n\n return 0;\n}\n```\n\n```go\npackage main\n\nfunc main() {\n\tlight := NewLight()\n\tthermostat := NewThermostat()\n\n\tlightOn := NewLightOnCommand(light)\n\tlightOff := NewLightOffCommand(light)\n\tsetTemp := NewSetTemperatureCommand(thermostat, 25)\n\n\tremote := NewRemoteControl()\n\n\tprintln(\"--- Executing Commands ---\")\n\tremote.ExecuteCommand(lightOn)\n\tremote.ExecuteCommand(setTemp)\n\tremote.ExecuteCommand(lightOff)\n\n\tprintln(\"\\n--- Undoing Commands ---\")\n\tremote.UndoLast()\n\tremote.UndoLast()\n\tremote.UndoLast()\n\tremote.UndoLast()\n}\n```\n\n```csharp\nclass SmartHomeApp\n{\n static void Main()\n {\n var light = new Light();\n var thermostat = new Thermostat();\n\n ICommand lightOn = new LightOnCommand(light);\n ICommand lightOff = new LightOffCommand(light);\n ICommand setTemp = new SetTemperatureCommand(thermostat, 25);\n\n var remote = new RemoteControl();\n\n Console.WriteLine(\"--- Executing Commands ---\");\n remote.ExecuteCommand(lightOn);\n remote.ExecuteCommand(setTemp);\n remote.ExecuteCommand(lightOff);\n\n Console.WriteLine(\"\\n--- Undoing Commands ---\");\n remote.UndoLast();\n remote.UndoLast();\n remote.UndoLast();\n remote.UndoLast();\n }\n}\n```\n\n```typescript\nconst light = new Light();\nconst thermostat = new Thermostat();\n\nconst lightOn: Command = new LightOnCommand(light);\nconst lightOff: Command = new LightOffCommand(light);\nconst setTemp: Command = new SetTemperatureCommand(thermostat, 25);\n\nconst remote = new RemoteControl();\n\nconsole.log(\"--- Executing Commands ---\");\nremote.executeCommand(lightOn);\nremote.executeCommand(setTemp);\nremote.executeCommand(lightOff);\n\nconsole.log(\"\\n--- Undoing Commands ---\");\nremote.undoLast();\nremote.undoLast();\nremote.undoLast();\nremote.undoLast();\n```\n\n\n#### Expected Output:\n\n\n```shell\n--- Executing Commands ---\nLight turned ON\nThermostat set to 25C\nLight turned OFF\n\n--- Undoing Commands ---\nLight turned ON\nThermostat set to 20C\nLight turned OFF\nNothing to undo.\n```\n\n\nThe undo sequence reverses the commands in the exact opposite order. The light comes back on (undoing the off), the thermostat returns to 20C (its original value, saved before executing), and the light turns off (undoing the original on). The fourth undo correctly reports that there is nothing left to undo.\n\n### What We Achieved\n\nLets compare this with the naive approach:\n\n\n| Aspect | Naive Controller | Command Pattern |\n|--------|-----------------|-----------------|\n| Coupling | Controller directly references every device class | Controller only knows the Command interface |\n| Adding devices | New fields, new methods in controller | New command class, zero changes to controller |\n| Undo support | Would require custom reverse logic per method | Built-in, each command handles its own undo |\n| Queuing/scheduling | Not possible, actions are method calls | Commands are objects, store them in any data structure |\n| Reuse | Each trigger point needs device-specific code | Same command object works from any invoker |\n\n\n---\n\n# 5. Practical Example: Text Editor with Undo/Redo\n\nLet's apply the Command pattern to a different domain: a text editor. This reinforces the concept and shows how Command handles a richer state-tracking scenario.\n\nThe editor supports typing text and deleting the last N characters. Both operations are undoable. We use a two-stack approach for full undo/redo.\n\n### Class Diagram\n\n\n```mermaid\nclassDiagram\n class EditorCommand {\n <>\n +execute()\n +undo()\n }\n\n class TypeCommand {\n -editor: TextEditor\n -text: String\n +execute()\n +undo()\n }\n\n class DeleteCommand {\n -editor: TextEditor\n -count: int\n -deletedText: String\n +execute()\n +undo()\n }\n\n class TextEditor {\n -content: StringBuilder\n +append(text: String)\n +deleteLast(count: int): String\n +getContent(): String\n }\n\n class EditorInvoker {\n -undoStack: Stack~EditorCommand~\n -redoStack: Stack~EditorCommand~\n +execute(cmd: EditorCommand)\n +undo()\n +redo()\n }\n\n EditorCommand <|.. TypeCommand\n EditorCommand <|.. DeleteCommand\n TypeCommand --> TextEditor : modifies\n DeleteCommand --> TextEditor : modifies\n EditorInvoker --> EditorCommand : invokes\n\n style EditorCommand fill:#00ceff,stroke:#000,color:#000\n style TypeCommand fill:#ffa94d,stroke:#000,color:#000\n style DeleteCommand fill:#ffa94d,stroke:#000,color:#000\n style TextEditor fill:#69db7c,stroke:#000,color:#000\n style EditorInvoker fill:#38d9a9,stroke:#000,color:#000\n```\n\n\n### Implementation\n\n\n```java\nimport java.util.Stack;\n\nclass TextEditor {\n private StringBuilder content = new StringBuilder();\n\n public void append(String text) {\n content.append(text);\n }\n\n public String deleteLast(int count) {\n int start = Math.max(0, content.length() - count);\n String deleted = content.substring(start);\n content.delete(start, content.length());\n return deleted;\n }\n\n public String getContent() {\n return content.toString();\n }\n}\n\ninterface EditorCommand {\n void execute();\n void undo();\n}\n\nclass TypeCommand implements EditorCommand {\n private final TextEditor editor;\n private final String text;\n\n public TypeCommand(TextEditor editor, String text) {\n this.editor = editor;\n this.text = text;\n }\n\n @Override\n public void execute() {\n editor.append(text);\n System.out.println(\"Typed: \\\"\" + text + \"\\\"\");\n }\n\n @Override\n public void undo() {\n editor.deleteLast(text.length());\n System.out.println(\"Undo type: \\\"\" + text + \"\\\"\");\n }\n}\n\nclass DeleteCommand implements EditorCommand {\n private final TextEditor editor;\n private final int count;\n private String deletedText;\n\n public DeleteCommand(TextEditor editor, int count) {\n this.editor = editor;\n this.count = count;\n }\n\n @Override\n public void execute() {\n deletedText = editor.deleteLast(count);\n System.out.println(\"Deleted: \\\"\" + deletedText + \"\\\"\");\n }\n\n @Override\n public void undo() {\n editor.append(deletedText);\n System.out.println(\"Undo delete: restored \\\"\" + deletedText + \"\\\"\");\n }\n}\n\nclass EditorInvoker {\n private final Stack undoStack = new Stack<>();\n private final Stack redoStack = new Stack<>();\n\n public void execute(EditorCommand command) {\n command.execute();\n undoStack.push(command);\n redoStack.clear();\n }\n\n public void undo() {\n if (!undoStack.isEmpty()) {\n EditorCommand command = undoStack.pop();\n command.undo();\n redoStack.push(command);\n } else {\n System.out.println(\"Nothing to undo.\");\n }\n }\n\n public void redo() {\n if (!redoStack.isEmpty()) {\n EditorCommand command = redoStack.pop();\n command.execute();\n undoStack.push(command);\n } else {\n System.out.println(\"Nothing to redo.\");\n }\n }\n}\n\npublic class TextEditorApp {\n public static void main(String[] args) {\n TextEditor editor = new TextEditor();\n EditorInvoker invoker = new EditorInvoker();\n\n invoker.execute(new TypeCommand(editor, \"Hello\"));\n invoker.execute(new TypeCommand(editor, \" World\"));\n invoker.execute(new TypeCommand(editor, \"!\"));\n System.out.println(\"Content: \\\"\" + editor.getContent() + \"\\\"\");\n\n System.out.println(\"\\n--- Undo ---\");\n invoker.undo();\n System.out.println(\"Content: \\\"\" + editor.getContent() + \"\\\"\");\n\n invoker.undo();\n System.out.println(\"Content: \\\"\" + editor.getContent() + \"\\\"\");\n\n System.out.println(\"\\n--- Redo ---\");\n invoker.redo();\n System.out.println(\"Content: \\\"\" + editor.getContent() + \"\\\"\");\n\n System.out.println(\"\\n--- New operation clears redo ---\");\n invoker.execute(new DeleteCommand(editor, 3));\n System.out.println(\"Content: \\\"\" + editor.getContent() + \"\\\"\");\n\n invoker.redo();\n\n System.out.println(\"\\n--- Undo delete ---\");\n invoker.undo();\n System.out.println(\"Content: \\\"\" + editor.getContent() + \"\\\"\");\n }\n}\n```\n\n```python\nfrom abc import ABC, abstractmethod\n\nclass TextEditor:\n def __init__(self):\n self.content = \"\"\n\n def append(self, text):\n self.content += text\n\n def delete_last(self, count):\n start = max(0, len(self.content) - count)\n deleted = self.content[start:]\n self.content = self.content[:start]\n return deleted\n\n def get_content(self):\n return self.content\n\nclass EditorCommand(ABC):\n @abstractmethod\n def execute(self):\n pass\n\n @abstractmethod\n def undo(self):\n pass\n\nclass TypeCommand(EditorCommand):\n def __init__(self, editor, text):\n self.editor = editor\n self.text = text\n\n def execute(self):\n self.editor.append(self.text)\n print(f'Typed: \"{self.text}\"')\n\n def undo(self):\n self.editor.delete_last(len(self.text))\n print(f'Undo type: \"{self.text}\"')\n\nclass DeleteCommand(EditorCommand):\n def __init__(self, editor, count):\n self.editor = editor\n self.count = count\n self.deleted_text = \"\"\n\n def execute(self):\n self.deleted_text = self.editor.delete_last(self.count)\n print(f'Deleted: \"{self.deleted_text}\"')\n\n def undo(self):\n self.editor.append(self.deleted_text)\n print(f'Undo delete: restored \"{self.deleted_text}\"')\n\nclass EditorInvoker:\n def __init__(self):\n self.undo_stack = []\n self.redo_stack = []\n\n def execute(self, command):\n command.execute()\n self.undo_stack.append(command)\n self.redo_stack.clear()\n\n def undo(self):\n if self.undo_stack:\n command = self.undo_stack.pop()\n command.undo()\n self.redo_stack.append(command)\n else:\n print(\"Nothing to undo.\")\n\n def redo(self):\n if self.redo_stack:\n command = self.redo_stack.pop()\n command.execute()\n self.undo_stack.append(command)\n else:\n print(\"Nothing to redo.\")\n\nif __name__ == \"__main__\":\n editor = TextEditor()\n invoker = EditorInvoker()\n\n invoker.execute(TypeCommand(editor, \"Hello\"))\n invoker.execute(TypeCommand(editor, \" World\"))\n invoker.execute(TypeCommand(editor, \"!\"))\n print(f'Content: \"{editor.get_content()}\"')\n\n print(\"\\n--- Undo ---\")\n invoker.undo()\n print(f'Content: \"{editor.get_content()}\"')\n\n invoker.undo()\n print(f'Content: \"{editor.get_content()}\"')\n\n print(\"\\n--- Redo ---\")\n invoker.redo()\n print(f'Content: \"{editor.get_content()}\"')\n\n print(\"\\n--- New operation clears redo ---\")\n invoker.execute(DeleteCommand(editor, 3))\n print(f'Content: \"{editor.get_content()}\"')\n\n invoker.redo()\n\n print(\"\\n--- Undo delete ---\")\n invoker.undo()\n print(f'Content: \"{editor.get_content()}\"')\n```\n\n```cpp\n#include \n#include \n#include \nusing namespace std;\n\nclass TextEditor {\nprivate:\n string content;\n\npublic:\n void append(const string& text) { content += text; }\n\n string deleteLast(int count) {\n int start = max(0, (int)content.length() - count);\n string deleted = content.substr(start);\n content = content.substr(0, start);\n return deleted;\n }\n\n string getContent() const { return content; }\n};\n\nclass EditorCommand {\npublic:\n virtual ~EditorCommand() = default;\n virtual void execute() = 0;\n virtual void undo() = 0;\n};\n\nclass TypeCommand : public EditorCommand {\nprivate:\n TextEditor* editor;\n string text;\n\npublic:\n TypeCommand(TextEditor* editor, const string& text)\n : editor(editor), text(text) {}\n\n void execute() override {\n editor->append(text);\n cout << \"Typed: \\\"\" << text << \"\\\"\" << endl;\n }\n\n void undo() override {\n editor->deleteLast(text.length());\n cout << \"Undo type: \\\"\" << text << \"\\\"\" << endl;\n }\n};\n\nclass DeleteCommand : public EditorCommand {\nprivate:\n TextEditor* editor;\n int count;\n string deletedText;\n\npublic:\n DeleteCommand(TextEditor* editor, int count)\n : editor(editor), count(count) {}\n\n void execute() override {\n deletedText = editor->deleteLast(count);\n cout << \"Deleted: \\\"\" << deletedText << \"\\\"\" << endl;\n }\n\n void undo() override {\n editor->append(deletedText);\n cout << \"Undo delete: restored \\\"\" << deletedText << \"\\\"\" << endl;\n }\n};\n\nclass EditorInvoker {\nprivate:\n stack undoStack;\n stack redoStack;\n\n void clearStack(stack& s) {\n while (!s.empty()) s.pop();\n }\n\npublic:\n void execute(EditorCommand* command) {\n command->execute();\n undoStack.push(command);\n clearStack(redoStack);\n }\n\n void undo() {\n if (!undoStack.empty()) {\n EditorCommand* command = undoStack.top();\n undoStack.pop();\n command->undo();\n redoStack.push(command);\n } else {\n cout << \"Nothing to undo.\" << endl;\n }\n }\n\n void redo() {\n if (!redoStack.empty()) {\n EditorCommand* command = redoStack.top();\n redoStack.pop();\n command->execute();\n undoStack.push(command);\n } else {\n cout << \"Nothing to redo.\" << endl;\n }\n }\n};\n\nint main() {\n TextEditor editor;\n EditorInvoker invoker;\n\n TypeCommand type1(&editor, \"Hello\");\n TypeCommand type2(&editor, \" World\");\n TypeCommand type3(&editor, \"!\");\n\n invoker.execute(&type1);\n invoker.execute(&type2);\n invoker.execute(&type3);\n cout << \"Content: \\\"\" << editor.getContent() << \"\\\"\" << endl;\n\n cout << \"\\n--- Undo ---\" << endl;\n invoker.undo();\n cout << \"Content: \\\"\" << editor.getContent() << \"\\\"\" << endl;\n\n invoker.undo();\n cout << \"Content: \\\"\" << editor.getContent() << \"\\\"\" << endl;\n\n cout << \"\\n--- Redo ---\" << endl;\n invoker.redo();\n cout << \"Content: \\\"\" << editor.getContent() << \"\\\"\" << endl;\n\n cout << \"\\n--- New operation clears redo ---\" << endl;\n DeleteCommand del(&editor, 3);\n invoker.execute(&del);\n cout << \"Content: \\\"\" << editor.getContent() << \"\\\"\" << endl;\n\n invoker.redo();\n\n cout << \"\\n--- Undo delete ---\" << endl;\n invoker.undo();\n cout << \"Content: \\\"\" << editor.getContent() << \"\\\"\" << endl;\n\n return 0;\n}\n```\n\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\t\"strings\"\n)\n\ntype TextEditor struct {\n\tcontent strings.Builder\n}\n\nfunc (t *TextEditor) Append(text string) {\n\tt.content.WriteString(text)\n}\n\nfunc (t *TextEditor) DeleteLast(count int) string {\n\ts := t.content.String()\n\tstart := len(s) - count\n\tif start < 0 {\n\t\tstart = 0\n\t}\n\tdeleted := s[start:]\n\tt.content.Reset()\n\tt.content.WriteString(s[:start])\n\treturn deleted\n}\n\nfunc (t *TextEditor) GetContent() string {\n\treturn t.content.String()\n}\n\ntype EditorCommand interface {\n\tExecute()\n\tUndo()\n}\n\ntype TypeCommand struct {\n\teditor *TextEditor\n\ttext string\n}\n\nfunc NewTypeCommand(editor *TextEditor, text string) *TypeCommand {\n\treturn &TypeCommand{editor: editor, text: text}\n}\n\nfunc (c *TypeCommand) Execute() {\n\tc.editor.Append(c.text)\n\tfmt.Printf(\"Typed: %q\\n\", c.text)\n}\n\nfunc (c *TypeCommand) Undo() {\n\tc.editor.DeleteLast(len(c.text))\n\tfmt.Printf(\"Undo type: %q\\n\", c.text)\n}\n\ntype DeleteCommand struct {\n\teditor *TextEditor\n\tcount int\n\tdeletedText string\n}\n\nfunc NewDeleteCommand(editor *TextEditor, count int) *DeleteCommand {\n\treturn &DeleteCommand{editor: editor, count: count}\n}\n\nfunc (c *DeleteCommand) Execute() {\n\tc.deletedText = c.editor.DeleteLast(c.count)\n\tfmt.Printf(\"Deleted: %q\\n\", c.deletedText)\n}\n\nfunc (c *DeleteCommand) Undo() {\n\tc.editor.Append(c.deletedText)\n\tfmt.Printf(\"Undo delete: restored %q\\n\", c.deletedText)\n}\n\ntype EditorInvoker struct {\n\tundoStack []EditorCommand\n\tredoStack []EditorCommand\n}\n\nfunc (e *EditorInvoker) Execute(command EditorCommand) {\n\tcommand.Execute()\n\te.undoStack = append(e.undoStack, command)\n\te.redoStack = e.redoStack[:0]\n}\n\nfunc (e *EditorInvoker) Undo() {\n\tif len(e.undoStack) > 0 {\n\t\tcommand := e.undoStack[len(e.undoStack)-1]\n\t\te.undoStack = e.undoStack[:len(e.undoStack)-1]\n\t\tcommand.Undo()\n\t\te.redoStack = append(e.redoStack, command)\n\t} else {\n\t\tfmt.Println(\"Nothing to undo.\")\n\t}\n}\n\nfunc (e *EditorInvoker) Redo() {\n\tif len(e.redoStack) > 0 {\n\t\tcommand := e.redoStack[len(e.redoStack)-1]\n\t\te.redoStack = e.redoStack[:len(e.redoStack)-1]\n\t\tcommand.Execute()\n\t\te.undoStack = append(e.undoStack, command)\n\t} else {\n\t\tfmt.Println(\"Nothing to redo.\")\n\t}\n}\n\nfunc main() {\n\teditor := &TextEditor{}\n\tinvoker := &EditorInvoker{}\n\n\tinvoker.Execute(NewTypeCommand(editor, \"Hello\"))\n\tinvoker.Execute(NewTypeCommand(editor, \" World\"))\n\tinvoker.Execute(NewTypeCommand(editor, \"!\"))\n\tfmt.Printf(\"Content: %q\\n\", editor.GetContent())\n\n\tfmt.Println(\"\\n--- Undo ---\")\n\tinvoker.Undo()\n\tfmt.Printf(\"Content: %q\\n\", editor.GetContent())\n\n\tinvoker.Undo()\n\tfmt.Printf(\"Content: %q\\n\", editor.GetContent())\n\n\tfmt.Println(\"\\n--- Redo ---\")\n\tinvoker.Redo()\n\tfmt.Printf(\"Content: %q\\n\", editor.GetContent())\n\n\tfmt.Println(\"\\n--- New operation clears redo ---\")\n\tinvoker.Execute(NewDeleteCommand(editor, 3))\n\tfmt.Printf(\"Content: %q\\n\", editor.GetContent())\n\n\tinvoker.Redo()\n\n\tfmt.Println(\"\\n--- Undo delete ---\")\n\tinvoker.Undo()\n\tfmt.Printf(\"Content: %q\\n\", editor.GetContent())\n}\n```\n\n```csharp\nusing System;\nusing System.Collections.Generic;\nusing System.Text;\n\nclass TextEditor\n{\n private StringBuilder content = new StringBuilder();\n\n public void Append(string text) { content.Append(text); }\n\n public string DeleteLast(int count)\n {\n int start = Math.Max(0, content.Length - count);\n string deleted = content.ToString(start, content.Length - start);\n content.Remove(start, content.Length - start);\n return deleted;\n }\n\n public string GetContent() { return content.ToString(); }\n}\n\ninterface IEditorCommand\n{\n void Execute();\n void Undo();\n}\n\nclass TypeCommand : IEditorCommand\n{\n private readonly TextEditor editor;\n private readonly string text;\n\n public TypeCommand(TextEditor editor, string text)\n {\n this.editor = editor;\n this.text = text;\n }\n\n public void Execute()\n {\n editor.Append(text);\n Console.WriteLine(\"Typed: \\\"\" + text + \"\\\"\");\n }\n\n public void Undo()\n {\n editor.DeleteLast(text.Length);\n Console.WriteLine(\"Undo type: \\\"\" + text + \"\\\"\");\n }\n}\n\nclass DeleteCommand : IEditorCommand\n{\n private readonly TextEditor editor;\n private readonly int count;\n private string deletedText = \"\";\n\n public DeleteCommand(TextEditor editor, int count)\n {\n this.editor = editor;\n this.count = count;\n }\n\n public void Execute()\n {\n deletedText = editor.DeleteLast(count);\n Console.WriteLine(\"Deleted: \\\"\" + deletedText + \"\\\"\");\n }\n\n public void Undo()\n {\n editor.Append(deletedText);\n Console.WriteLine(\"Undo delete: restored \\\"\" + deletedText + \"\\\"\");\n }\n}\n\nclass EditorInvoker\n{\n private readonly Stack undoStack = new Stack();\n private readonly Stack redoStack = new Stack();\n\n public void Execute(IEditorCommand command)\n {\n command.Execute();\n undoStack.Push(command);\n redoStack.Clear();\n }\n\n public void Undo()\n {\n if (undoStack.Count > 0)\n {\n IEditorCommand command = undoStack.Pop();\n command.Undo();\n redoStack.Push(command);\n }\n else\n {\n Console.WriteLine(\"Nothing to undo.\");\n }\n }\n\n public void Redo()\n {\n if (redoStack.Count > 0)\n {\n IEditorCommand command = redoStack.Pop();\n command.Execute();\n undoStack.Push(command);\n }\n else\n {\n Console.WriteLine(\"Nothing to redo.\");\n }\n }\n}\n\nclass Program\n{\n static void Main()\n {\n TextEditor editor = new TextEditor();\n EditorInvoker invoker = new EditorInvoker();\n\n invoker.Execute(new TypeCommand(editor, \"Hello\"));\n invoker.Execute(new TypeCommand(editor, \" World\"));\n invoker.Execute(new TypeCommand(editor, \"!\"));\n Console.WriteLine(\"Content: \\\"\" + editor.GetContent() + \"\\\"\");\n\n Console.WriteLine(\"\\n--- Undo ---\");\n invoker.Undo();\n Console.WriteLine(\"Content: \\\"\" + editor.GetContent() + \"\\\"\");\n\n invoker.Undo();\n Console.WriteLine(\"Content: \\\"\" + editor.GetContent() + \"\\\"\");\n\n Console.WriteLine(\"\\n--- Redo ---\");\n invoker.Redo();\n Console.WriteLine(\"Content: \\\"\" + editor.GetContent() + \"\\\"\");\n\n Console.WriteLine(\"\\n--- New operation clears redo ---\");\n invoker.Execute(new DeleteCommand(editor, 3));\n Console.WriteLine(\"Content: \\\"\" + editor.GetContent() + \"\\\"\");\n\n invoker.Redo();\n\n Console.WriteLine(\"\\n--- Undo delete ---\");\n invoker.Undo();\n Console.WriteLine(\"Content: \\\"\" + editor.GetContent() + \"\\\"\");\n }\n}\n```\n\n```typescript\nclass TextEditor {\n private content: string = \"\";\n\n append(text: string): void { this.content += text; }\n\n deleteLast(count: number): string {\n const start = Math.max(0, this.content.length - count);\n const deleted = this.content.substring(start);\n this.content = this.content.substring(0, start);\n return deleted;\n }\n\n getContent(): string { return this.content; }\n}\n\ninterface EditorCommand {\n execute(): void;\n undo(): void;\n}\n\nclass TypeCommand implements EditorCommand {\n private readonly editor: TextEditor;\n private readonly text: string;\n\n constructor(editor: TextEditor, text: string) {\n this.editor = editor;\n this.text = text;\n }\n\n execute(): void {\n this.editor.append(this.text);\n console.log(`Typed: \"${this.text}\"`);\n }\n\n undo(): void {\n this.editor.deleteLast(this.text.length);\n console.log(`Undo type: \"${this.text}\"`);\n }\n}\n\nclass DeleteCommand implements EditorCommand {\n private readonly editor: TextEditor;\n private readonly count: number;\n private deletedText: string = \"\";\n\n constructor(editor: TextEditor, count: number) {\n this.editor = editor;\n this.count = count;\n }\n\n execute(): void {\n this.deletedText = this.editor.deleteLast(this.count);\n console.log(`Deleted: \"${this.deletedText}\"`);\n }\n\n undo(): void {\n this.editor.append(this.deletedText);\n console.log(`Undo delete: restored \"${this.deletedText}\"`);\n }\n}\n\nclass EditorInvoker {\n private undoStack: EditorCommand[] = [];\n private redoStack: EditorCommand[] = [];\n\n execute(command: EditorCommand): void {\n command.execute();\n this.undoStack.push(command);\n this.redoStack = [];\n }\n\n undo(): void {\n if (this.undoStack.length > 0) {\n const command = this.undoStack.pop() as EditorCommand;\n command.undo();\n this.redoStack.push(command);\n } else {\n console.log(\"Nothing to undo.\");\n }\n }\n\n redo(): void {\n if (this.redoStack.length > 0) {\n const command = this.redoStack.pop() as EditorCommand;\n command.execute();\n this.undoStack.push(command);\n } else {\n console.log(\"Nothing to redo.\");\n }\n }\n}\n\nconst editor = new TextEditor();\nconst invoker = new EditorInvoker();\n\ninvoker.execute(new TypeCommand(editor, \"Hello\"));\ninvoker.execute(new TypeCommand(editor, \" World\"));\ninvoker.execute(new TypeCommand(editor, \"!\"));\nconsole.log(`Content: \"${editor.getContent()}\"`);\n\nconsole.log(\"\\n--- Undo ---\");\ninvoker.undo();\nconsole.log(`Content: \"${editor.getContent()}\"`);\n\ninvoker.undo();\nconsole.log(`Content: \"${editor.getContent()}\"`);\n\nconsole.log(\"\\n--- Redo ---\");\ninvoker.redo();\nconsole.log(`Content: \"${editor.getContent()}\"`);\n\nconsole.log(\"\\n--- New operation clears redo ---\");\ninvoker.execute(new DeleteCommand(editor, 3));\nconsole.log(`Content: \"${editor.getContent()}\"`);\n\ninvoker.redo();\n\nconsole.log(\"\\n--- Undo delete ---\");\ninvoker.undo();\nconsole.log(`Content: \"${editor.getContent()}\"`);\n```\n\n\nA few things to notice. First, redo works correctly: after undoing \" World\" and \"!\", redoing brings back \" World\" by re-executing the same TypeCommand. Second, performing a new operation (delete) after undoing clears the redo stack, which is why \"Nothing to redo\" appears. This is standard undo/redo behavior, a new action creates a new timeline.\n\nThird, the DeleteCommand saves the deleted text during execute so it can restore it during undo. This is the same \"save state before modifying\" pattern we saw with SetTemperatureCommand.","pageType":"lld-interviews"}

Get Premium