当前位置：首页 > 文章列表 > Golang > Go教程 > Golang命令模式队列与撤销重做实现

Golang命令模式队列与撤销重做实现

2025-12-22 15:00:38 0浏览收藏

本篇文章给大家分享《Golang命令模式队列实现与撤销重做支持》，覆盖了Golang的常见基础知识，其实一个语言的全部知识点一篇文章是不可能说完的，但希望通过这些问题，让读者对自己的掌握程度有一定的认识(B 数)，从而弥补自己的不足，更好的掌握它。

Go中用命令模式实现撤销重做：定义Command接口含Execute/Undo方法，CommandQueue用切片维护history和redoStack，执行新命令时清空redoStack，Undo/Redo操作栈并调用对应方法。

如何使用Golang实现命令模式队列_支持请求撤销和重做

用 Go 实现支持撤销（Undo）和重做（Redo）的命令模式队列，核心是把每个操作封装为可执行、可回滚的 Command 对象，并用两个栈（或切片）分别管理已执行和已撤销的操作历史。

定义命令接口与基础结构

Go 没有接口继承语法，但可通过组合和约定实现类似效果。定义统一的 Command 接口：

type Command interface {
    Execute() error
    Undo() error
}

每个具体命令（如“添加用户”、“删除文件”）都实现这两个方法。注意：Undo 必须能精确逆转 Execute 的副作用，因此命令内部需保存必要上下文（如被删文件名、原值等）。

构建带撤销/重做的命令队列管理器

用一个结构体封装执行历史（history）、撤销历史（redoStack），并提供公开方法：

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
}

这样，批量操作也能被当作一个整体加入队列，保持撤销粒度一致。

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于Golang的相关知识，也可关注golang学习网公众号。