Published Apr 13, 2022
[
A generic example would be you ordering food at a restaurant. You (i.e.
Client) ask the waiter (i.e. Invoker) to bring some food (i.e. Command) and
waiter simply forwards the request to Chef (i.e. Receiver) who has the
knowledge of what and how to cook. Another example would be you (i.e. Client)
switching on (i.e. Command) the television (i.e. Receiver) using a remote
control (Invoker).
Allows you to encapsulate actions in objects. The key idea behind this pattern is to provide the means to decouple client from receiver.
In object-oriented programming, the command pattern is a behavioral design pattern in which an object is used to encapsulate all information needed to perform an action or trigger an event at a later time. This information includes the method name, the object that owns the method and values for the method parameters.
First of all we have the receiver that has the implementation of every action that could be performed
// Receiver
class Bulb {
protected isOn: boolean = false;
turnOn() {
this.isOn = true;
console.log("Bulb has been lit")
}
turnOff() {
this.isOn = false;
console.log("Darkness!")
}
getStatus(): boolean {
return this.isOn
}
}
then we have an interface that each of the commands are going to implement and then we have a set of commands
interface Command {
execute()
undo()
redo()
}
class TurnOn implements Command {
protected bulb;
constructor(bulb: Bulb) {
this.bulb = bulb
}
execute() {
this.bulb.turnOn();
}
undo(){
this.bulb.turnOff()
}
redo(){
this.execute()
}
}
class TurnOff implements Command {
protected bulb;
constructor(bulb: Bulb) {
this.bulb = bulb;
}
execute() {
this.bulb.turnOff()
}
undo(){
this.bulb.turnOn()
}
redo(){
this.execute()
}
}
Then we have an Invoker with whom the client will interact to process any
commands
class RemoteControl {
submit(command: Command) {
command.execute()
}
}
Finally let’s see how we can use it in our client
test('test command design patterns', () => {
const bulb = new Bulb();
const turnOn = new TurnOn(bulb)
const turnOff = new TurnOff(bulb)
const remoteControl = new RemoteControl()
expect(bulb.getStatus()).toEqual(false)
remoteControl.submit(turnOn)
expect(bulb.getStatus()).toEqual(true)
remoteControl.submit(turnOff)
expect(bulb.getStatus()).toEqual(false)
})
Command pattern can also be used to implement a transaction based system.
Where you keep maintaining the history of commands as soon as you execute
them. If the final command is successfully executed, all good otherwise just
iterate through the history and keep executing the undo on all the executed
commands.