Go中用命令模式实现撤销重做：定义Command接口含Execute/Undo方法，CommandQueue用切片维护history和redoStack，执行新命令时清空redoStack，Undo/Redo操作栈并调用对应方法。
用 Go 实现支持撤销（Undo）和重做（Redo）的命令模式队列，核心是把每个操作封装为可执行、可回滚的 Command 对象，并用两个栈（或切片）分别管理已执行和已撤销的操作历史。
定义命令接口与基础结构
Go 没有接口继承语法，但可通过组合和约定实现类似效果。定义统一的 Command 接口：
type Command interface {
Execute() error
Undo() error
}
每个具体命令（如“添加用户”、“删除文件”）都实现这两个方法。注意：Undo 必须能精确逆转 Execute 的副作用，因此命令内部需保存必要上下文（如被删文件名、原值等）。
构建带撤销/重做的命令队列管理器
用一个结构体封装执行历史（history）、撤销历史（redoStack），并提供公开方法：
立即学习“go语言免费学习笔记（深入）”；
type CommandQueue struct {
history []Command // 已执行且未撤销的命令（从底到顶为时间顺序）
redoStack []Command // 已撤销、可重做的命令（栈顶为最新撤销项）
}
func (cq *CommandQueue) Execute(cmd Command) error {
if err := cmd.Execute(); err != nil {
return err
}
cq.history = append(cq.history, cmd)
cq.redoStack = cq.redoStack[:0] // 执行新命令后清空重做栈
return nil
}
func (cq *CommandQueue) Undo() error {
if len(cq.history) == 0 {
return errors.New("no command to undo")
}
last := cq.history[len(cq.history)-1]
cq.history = cq.history[:len(cq.history)-1]
if err := last.Undo(); err != nil {
return err
}
cq.redoStack = append(cq.redoStack, last)
return nil
}
func (cq *CommandQueue) Redo() error {
if len(cq.redoStack) == 0 {
return errors.New("no command to redo")
}
last := cq.redoStack[len(cq.redoStack)-1]
cq.redoStack = cq.redoStack[:len(cq.redoStack)-1]
if err := last.Execute(); err != nil {
return err
}
cq.history = append(cq.history, last)
return nil
}
关键点：
- 执行新命令时，清空
redoStack—— 符合常见编辑器行为（如 VS Code、IDEA） -
Undo和Redo都要检查栈是否为空，避免 panic - 所有状态变更（
history/redoStack切片操作）都在方法内完成，调用者无需关心内部结构
实现一个具体命令示例：数值累加器
假设我们有一个整数变量，支持“加 X”和“减 X”操作，并能撤销/重做：
type AddCommand struct {
value int
target *int
oldValue int // 用于 Undo 恢复
}
func (ac AddCommand) Execute() error {
ac.oldValue = ac.target
*ac.target += ac.value
return nil
}
func (ac AddCommand) Undo() error {
ac.target = ac.oldValue
return nil
}
使用方式：
var counter int
cq := &CommandQueue{}
cq.Execute(&AddCommand{value: 5, target: &counter}) // counter = 5
cq.Execute(&AddCommand{value: 3, target: &counter}) // counter = 8
cq.Undo() // counter = 5
cq.Redo() // counter = 8
注意：命令对象必须保存足够信息来还原状态，不能依赖外部可变变量（如全局变量或闭包捕获的变量），否则 Undo 可能失效。
进阶建议：线程安全与批量操作
若在并发场景下使用（如 Web 服务中每个请求对应一个命令队列），需加锁：
- 在
CommandQueue中嵌入sync.RWMutex - 所有公开方法（
Execute/Undo/Redo）开头加cq.Lock()，结尾cq.Unlock()
如需支持原子性批量命令（如“全部删除选中项”视为单个可撤销单元），可定义 CompositeCommand：
type CompositeCommand struct {
cmds []Command
}
func (cc *CompositeCommand) Execute() error {
for _, c := range cc.cmds {
if err := c.Execute(); err != nil {
// 可选择部分回滚，或直接返回错误
return err
}
}
return nil
}
func (cc *CompositeCommand) Undo() error {
for i := len(cc.cmds) - 1; i >= 0; i-- {
if err := cc.cmds[i].Undo(); err != nil {
return err
}
}
return nil
}
这样，批量操作也能被当作一个整体加入队列，保持撤销粒度一致。
