type Prototype interface {
    Clone() SpecificType
}

// 示例代码来自：https://lailin.xyz/post/prototype.html
package prototype

import (
 "encoding/json"
 "time"
)

// Keyword 搜索关键字
type Keyword struct {
 word      string
 visit     int
 UpdatedAt *time.Time
}

// Clone 这里使用序列化与反序列化的方式深拷贝
func (k *Keyword) Clone() *Keyword {
 var newKeyword Keyword
 b, _ := json.Marshal(k)
 json.Unmarshal(b, &newKeyword)
 return &newKeyword
}

// Keywords 关键字 map
type Keywords map[string]*Keyword

// Clone 复制一个新的 keywords
// updatedWords: 需要更新的关键词列表，由于从数据库中获取数据常常是数组的方式
func (words Keywords) Clone(updatedWords []*Keyword) Keywords {
 newKeywords := Keywords{}

 for k, v := range words {
  // 这里是浅拷贝，直接拷贝了地址
  newKeywords[k] = v
 }

 // 替换掉需要更新的字段，这里用的是深拷贝
 for _, word := range updatedWords {
  newKeywords[word.word] = word.Clone()
 }

 return newKeywords
}

package dom

import (
 "bytes"
 "fmt"
)

// Node a document object model node
type Node interface {
 // Strings returns nodes text representation
 String() string
 // Parent returns the node parent
 Parent() Node
 // SetParent sets the node parent
 SetParent(node Node)
 // Children returns the node children nodes
 Children() []Node
 // AddChild adds a child node
 AddChild(child Node)
 // Clone clones a node
 Clone() Node
}

// Element represents an element in document object model
type Element struct {
 text     string
 parent   Node
 children []Node
}

// NewElement makes a new element
func NewElement(text string) *Element {
 return &Element{
  text:     text,
  parent:   nil,
  children: make([]Node, 0),
 }
}

// Parent returns the element parent
func (e *Element) Parent() Node {
 return e.parent
}

// SetParent sets the element parent
func (e *Element) SetParent(node Node) {
 e.parent = node
}

// Children returns the element children elements
func (e *Element) Children() []Node {
 return e.children
}

// AddChild adds a child element
func (e *Element) AddChild(child Node) {
 copy := child.Clone()
 copy.SetParent(e)
 e.children = append(e.children, copy)
}

// Clone makes a copy of particular element. Note that the element becomes a
// root of new orphan tree
func (e *Element) Clone() Node {
 copy := &Element{
  text:     e.text,
  parent:   nil,
  children: make([]Node, 0),
 }
 for _, child := range e.children {
  copy.AddChild(child)
 }
 return copy
}

// String returns string representation of element
func (e *Element) String() string {
 buffer := bytes.NewBufferString(e.text)

 for _, c := range e.Children() {
  text := c.String()
  fmt.Fprintf(buffer, "\n %s", text)
 }

 return buffer.String()
}

func main() {
  // 职级节点--总监
 directorNode := dom.NewElement("Director of Engineering")
  // 职级节点--研发经理
 engManagerNode := dom.NewElement("Engineering Manager")
 engManagerNode.AddChild(dom.NewElement("Lead Software Engineer"))
  // 研发经理是总监的下级
 directorNode.AddChild(engManagerNode)
 directorNode.AddChild(engManagerNode)
  // 办公室经理也是总监的下级
 officeManagerNode := dom.NewElement("Office Manager")
 directorNode.AddChild(officeManagerNode)
 fmt.Println("")
 fmt.Println("# Company Hierarchy")
 fmt.Print(directorNode)
 fmt.Println("")
  // 从研发经理节点克隆出一颗新的树
 fmt.Println("# Team Hiearachy")
 fmt.Print(engManagerNode.Clone())
}
总结