1
// Command 是命令接口
2
type Command interface {
3
    Execute()
4
    Undo()
5
}

1
// Invoker 管理命令的执行和撤销
2
type Invoker struct {
3
    history []Command // 已执行命令的栈
4
}
5

6
func (inv *Invoker) Execute(cmd Command) {
7
    cmd.Execute()
8
    inv.history = append(inv.history, cmd)
9
}
10

11
func (inv *Invoker) Undo() {
12
    if len(inv.history) == 0 {
13
        return
14
    }
15
    cmd := inv.history[len(inv.history)-1]
16
    inv.history = inv.history[:len(inv.history)-1]
17
    cmd.Undo()
18
}

1
// MacroCommand 宏命令——组合多个子命令
2
type MacroCommand struct {
3
    commands []Command
4
}
5

6
func (mc *MacroCommand) Execute() {
7
    for _, cmd := range mc.commands {
8
        cmd.Execute()
9
    }
10
}
11

12
func (mc *MacroCommand) Undo() {
13
    // 逆序撤销，保证状态正确恢复
14
    for i := len(mc.commands) - 1; i >= 0; i-- {
15
        mc.commands[i].Undo()
16
    }
17
}

1
// 策略：同一个操作的不同实现，调用者知道自己在排序
2
interface SortStrategy {
3
  sort(data: number[]): number[];
4
}
5

6
// 命令：请求被封装成对象，调用者不知道也不关心背后是什么
7
interface Command {
8
  execute(): void;
9
  undo(): void;
10
}

1
// CommandBus 命令总线——路由命令到处理器
2
type CommandBus struct {
3
    handlers map[reflect.Type]CommandHandler
4
}
5

6
type CommandHandler interface {
7
    Handle(cmd Command) error
8
}
9

10
func (bus *CommandBus) Dispatch(cmd Command) error {
11
    handler, ok := bus.handlers[reflect.TypeOf(cmd)]
12
    if !ok {
13
        return fmt.Errorf("no handler for %T", cmd)
14
    }
15
    return handler.Handle(cmd)
16
}

1
package main
2

3
import "fmt"
4

5
// Command 命令接口
6
type Command interface {
7
    Execute()
8
    Undo()
9
}
10

11
// TextBuffer 文本缓冲区——接收者
12
type TextBuffer struct {
13
    content string
14
}
15

16
func (tb *TextBuffer) Insert(text string, pos int) {
17
    tb.content = tb.content[:pos] + text + tb.content[pos:]
18
}
19

20
func (tb *TextBuffer) Delete(pos, length int) string {
21
    deleted := tb.content[pos : pos+length]
22
    tb.content = tb.content[:pos] + tb.content[pos+length:]
23
    return deleted
24
}
25

26
func (tb *TextBuffer) Content() string {
27
    return tb.content
28
}
29

30
// InsertCommand 插入命令
31
type InsertCommand struct {
32
    buffer *TextBuffer
33
    text   string
34
    pos    int
35
}
36

37
func NewInsertCommand(buffer *TextBuffer, text string, pos int) *InsertCommand {
38
    return &InsertCommand{buffer: buffer, text: text, pos: pos}
39
}
40

41
func (ic *InsertCommand) Execute() {
42
    ic.buffer.Insert(ic.text, ic.pos)
43
}
44

45
func (ic *InsertCommand) Undo() {
46
    ic.buffer.Delete(ic.pos, len(ic.text))
47
}
48

49
// DeleteCommand 删除命令
50
type DeleteCommand struct {
51
    buffer  *TextBuffer
52
    pos     int
53
    length  int
54
    deleted string // 撤销时需要恢复的文本
55
}
56

57
func NewDeleteCommand(buffer *TextBuffer, pos, length int) *DeleteCommand {
58
    return &DeleteCommand{buffer: buffer, pos: pos, length: length}
59
}
60

61
func (dc *DeleteCommand) Execute() {
62
    dc.deleted = dc.buffer.Delete(dc.pos, dc.length)
63
}
64

65
func (dc *DeleteCommand) Undo() {
66
    dc.buffer.Insert(dc.deleted, dc.pos)
67
}
68

69
// Editor 编辑器——调用者
70
type Editor struct {
71
    buffer    *TextBuffer
72
    undoStack []Command
73
    redoStack []Command
74
}
75

76
func NewEditor(buffer *TextBuffer) *Editor {
77
    return &Editor{buffer: buffer}
78
}
79

80
func (e *Editor) Execute(cmd Command) {
81
    cmd.Execute()
82
    e.undoStack = append(e.undoStack, cmd)
83
    e.redoStack = nil // 新操作清空重做栈
84
}
85

86
func (e *Editor) Undo() {
87
    if len(e.undoStack) == 0 {
88
        return
89
    }
90
    cmd := e.undoStack[len(e.undoStack)-1]
91
    e.undoStack = e.undoStack[:len(e.undoStack)-1]
92
    cmd.Undo()
93
    e.redoStack = append(e.redoStack, cmd)
94
}
95

96
func (e *Editor) Redo() {
97
    if len(e.redoStack) == 0 {
98
        return
99
    }
100
    cmd := e.redoStack[len(e.redoStack)-1]
101
    e.redoStack = e.redoStack[:len(e.redoStack)-1]
102
    cmd.Execute()
103
    e.undoStack = append(e.undoStack, cmd)
104
}
105

106
func main() {
107
    buffer := &TextBuffer{}
108
    editor := NewEditor(buffer)
109

110
    // 插入 "Hello"
111
    editor.Execute(NewInsertCommand(buffer, "Hello", 0))
112
    fmt.Println(buffer.Content()) // Hello
113

114
    // 插入 " World"
115
    editor.Execute(NewInsertCommand(buffer, " World", 5))
116
    fmt.Println(buffer.Content()) // Hello World
117

118
    // 撤销
119
    editor.Undo()
120
    fmt.Println(buffer.Content()) // Hello
121

122
    // 重做
123
    editor.Redo()
124
    fmt.Println(buffer.Content()) // Hello World
125

126
    // 删除 " World"
127
    editor.Execute(NewDeleteCommand(buffer, 5, 6))
128
    fmt.Println(buffer.Content()) // Hello
129

130
    // 撤销删除
131
    editor.Undo()
132
    fmt.Println(buffer.Content()) // Hello World
133
}

1
// Command 命令接口
2
interface Command {
3
  execute(): void;
4
  undo(): void;
5
}
6

7
// UI 面板状态——接收者
8
interface PanelState {
9
  visible: boolean;
10
  position: { x: number; y: number };
11
  width: number;
12
  height: number;
13
}
14

15
class Panel {
16
  private state: PanelState;
17

18
  constructor(initial: PanelState) {
19
    this.state = { ...initial };
20
  }
21

22
  show() { this.state.visible = true; }
23
  hide() { this.state.visible = false; }
24
  move(x: number, y: number) {
25
    this.state.position = { x, y };
26
  }
27
  resize(width: number, height: number) {
28
    this.state.width = width;
29
    this.state.height = height;
30
  }
31

32
  getState(): PanelState {
33
    // 返回深拷贝，防止外部修改
34
    return JSON.parse(JSON.stringify(this.state));
35
  }
36

37
  restore(state: PanelState) {
38
    this.state = JSON.parse(JSON.stringify(state));
39
  }
40
}
41

42
// MovePanelCommand 移动面板命令
43
class MovePanelCommand implements Command {
44
  private panel: Panel;
45
  private oldPos: { x: number; y: number };
46
  private newPos: { x: number; y: number };
47

48
  constructor(panel: Panel, x: number, y: number) {
49
    this.panel = panel;
50
    this.newPos = { x, y };
51
    this.oldPos = panel.getState().position;
52
  }
53

54
  execute() {
55
    this.panel.move(this.newPos.x, this.newPos.y);
56
  }
57

58
  undo() {
59
    this.panel.move(this.oldPos.x, this.oldPos.y);
60
  }
61
}
62

63
// TogglePanelCommand 显示/隐藏面板命令
64
class TogglePanelCommand implements Command {
65
  private panel: Panel;
66
  private wasVisible: boolean;
67

68
  constructor(panel: Panel) {
69
    this.panel = panel;
70
    this.wasVisible = panel.getState().visible;
71
  }
72

73
  execute() {
74
    this.wasVisible ? this.panel.hide() : this.panel.show();
75
  }
76

77
  undo() {
78
    this.wasVisible ? this.panel.show() : this.panel.hide();
79
  }
80
}
81

82
// CommandManager 命令管理器
83
class CommandManager {
84
  private undoStack: Command[] = [];
85
  private redoStack: Command[] = [];
86

87
  execute(cmd: Command) {
88
    cmd.execute();
89
    this.undoStack.push(cmd);
90
    this.redoStack = []; // 新操作清空重做栈
91
  }
92

93
  undo() {
94
    const cmd = this.undoStack.pop();
95
    if (!cmd) return;
96
    cmd.undo();
97
    this.redoStack.push(cmd);
98
  }
99

100
  redo() {
101
    const cmd = this.redoStack.pop();
102
    if (!cmd) return;
103
    cmd.execute();
104
    this.undoStack.push(cmd);
105
  }
106

107
  canUndo(): boolean { return this.undoStack.length > 0; }
108
  canRedo(): boolean { return this.redoStack.length > 0; }
109
}
110

111
// 使用示例
112
const panel = new Panel({
113
  visible: true,
114
  position: { x: 100, y: 100 },
115
  width: 300,
116
  height: 200,
117
});
118

119
const manager = new CommandManager();
120

121
// 移动面板
122
manager.execute(new MovePanelCommand(panel, 200, 150));
123
console.log(panel.getState().position); // { x: 200, y: 150 }
124

125
// 撤销移动
126
manager.undo();
127
console.log(panel.getState().position); // { x: 100, y: 100 }
128

129
// 重做
130
manager.redo();
131
console.log(panel.getState().position); // { x: 200, y: 150 }