Command Pattern:
The Command design pattern is a behavioral design pattern that turns a request into a stand-alone object that contains all information about the request. In other words, this pattern encapsulates all the information necessary to call a method at a later time into an object. This transformation lets you parameterize methods with different requests, delay or queue a request's execution, and support undoable operations. In essence, the command design pattern allows more flexibility in how, when, and in what sequence actions or requests are processed, providing a decoupled system where senders and receivers of requests can vary independently.

This pattern consists of the following components:
1. Command:
This is the interface with the method "Execute()" that should be implemented by all concrete commands.

2. Concrete Command:
This is a class that implements the "Command" interface and provides the concrete implementation for the command.

3. Invoker:
This is the class that invokes the command. It's decoupled from the actual command implementation.

4. Receiver:
This is the class that performs the actual work when the commands are executed.

This pattern provides several benefits:
1. Decoupling the sender and receiver:
The invoker (the object that initiates the operation) does not need to know anything about the receiver (the object that performs the operation). This decoupling means that the invoker can be reused with different receivers, making the code more modular and easier to modify or extend.

2. Command queuing and scheduling:
Since commands are represented as objects, they can be stored in a queue and executed at different times. Commands can also be prioritized and delayed.

3. Undo/redo operations:
By storing the state necessary to perform an operation in the command object itself, it makes it easy to implement undo and redo functionality. A history of commands can also be stored.

Imagine you are controlling a Television set, where the TV is the receiver. The remote control is the invoker that executes commands like turning the TV on or off  and changing the channels. The individual buttons on the remote control are the commands.

Implementation in Go:


In the example above, each command encapsulates a request to the TV (either to turn on or off). The remote control, as the invoker, doesn't need to know how to turn on or off the TV; it only needs to know that it can execute commands. The TV (receiver) is the one who knows how to carry out the requested operation.