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: 需要更新的關鍵詞列表，由于從數(shù)據(jù)庫中獲取數(shù)據(jù)常常是數(shù)組的方式
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() {
  // 職級節(jié)點--總監(jiān)
	directorNode := dom.NewElement("Director of Engineering")
  // 職級節(jié)點--研發(fā)經理
	engManagerNode := dom.NewElement("Engineering Manager")
	engManagerNode.AddChild(dom.NewElement("Lead Software Engineer"))
  // 研發(fā)經理是總監(jiān)的下級
	directorNode.AddChild(engManagerNode)
	directorNode.AddChild(engManagerNode)
  // 辦公室經理也是總監(jiān)的下級
	officeManagerNode := dom.NewElement("Office Manager")
	directorNode.AddChild(officeManagerNode)
	fmt.Println("")
	fmt.Println("# Company Hierarchy")
	fmt.Print(directorNode)
	fmt.Println("")
  // 從研發(fā)經理節(jié)點克隆出一顆新的樹
	fmt.Println("# Team Hiearachy")
	fmt.Print(engManagerNode.Clone())
}