Go语言中的命令模式

package main

import "fmt"

// Command is the abstract interface for commands
type Command interface {
  Execute()
}

// Editor is the struct for text editor
type Editor struct {
  text string // the text content of the editor
}

// Copy is the method of Editor to copy text
func (e *Editor) Copy() {
  fmt.Println("Copied: " + e.text) // output the copied text (simulated by printing)
}

// Cut is the method of Editor to cut text
func (e *Editor) Cut() {
  fmt.Println("Cut: " + e.text) // output the cut text (simulated by printing)
  e.text = ""                   // clear the text content of the editor
}

// Paste is the method of Editor to paste text
func (e *Editor) Paste(text string) {
  e.text = text                       // set the text content of the editor
  fmt.Println("Pasted: " + e.text)    // output the pasted text (simulated by printing)
}

// Undo is the method of Editor to undo an operation
func (e *Editor) Undo(command Command) {
  fmt.Println("Undoing...") // output a message (simulated by printing)
  command.Execute()         // execute the command again
}

// History is the struct for history records
type History struct {
  commands []Command // the slice of command objects
}

// Push is the method of History to push a command object
func (h *History) Push(command Command) {
  h.commands = append(h.commands, command) // append the command object to the slice
}

// Pop is the method of History to pop a command object
func (h *History) Pop() Command {
  if len(h.commands) == 0 {
    return nil // return nil if the slice is empty
  }
  command := h.commands[len(h.commands)-1] // get the last command object
  h.commands = h.commands[:len(h.commands)-1] // remove the last command object from the slice
  return command // return the command object
}

// CopyCommand is the concrete struct for copy command
type CopyCommand struct {
  editor *Editor // the reference to the editor
}

// Execute is the method of CopyCommand to execute the command
func (c *CopyCommand) Execute() {
  c.editor.Copy() // call the copy method of the editor
}

// CutCommand is the concrete struct for cut command
type CutCommand struct {
  editor *Editor // the reference to the editor
}

// Execute is the method of CutCommand to execute the command
func (c *CutCommand) Execute() {
  c.editor.Cut() // call the cut method of the editor
}

// PasteCommand is the concrete struct for paste command
type PasteCommand struct {
  editor *Editor // the reference to the editor
  text   string  // the text to be pasted
}

// Execute is the method of PasteCommand to execute the command
func (p *PasteCommand) Execute() {
  p.editor.Paste(p.text) // call the paste method of the editor with the text
}

func main() {
  // create an editor and a history
  editor := &Editor{text: "Hello World"}
  history := &History{}

  // create and execute some commands
  copyCommand := &CopyCommand{editor: editor}
  copyCommand.Execute()
  history.Push(copyCommand)

  cutCommand := &CutCommand{editor: editor}
  cutCommand.Execute()
  history.Push(cutCommand)

  pasteCommand := &PasteCommand{editor: editor, text: "Go"}
  pasteCommand.Execute()
  history.Push(pasteCommand)

  // output:
  // Copied: Hello World
  // Cut: Hello World
  // Pasted: Go

  // undo some commands
  editor.Undo(history.Pop())
  editor.Undo(history.Pop())
  editor.Undo(history.Pop())

  // output:
  // Undoing...
  // Pasted: Go
  // Undoing...
  // Cut: Hello World
  // Undoing...
  // Copied: Hello World

}