Go設計模式原型模式考查點及使用詳解

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())
}