Go中的组合模式是通过接口统一节点行为、用值/指针组合实现树形结构多态，而非结构嵌套；区别在于组合模式要求所有节点实现同一接口（如Component），而嵌套结构（如Folder含[]Folder）无行为契约，无法统一操作。
什么是 Go 中的组合模式，它和嵌套结构有什么区别
Go 没有类继承，所以“组合模式”不是靠 extends 或 interface{} 实现的抽象父类那一套，而是靠接口 + 值/指针组合来模拟树形节点统一行为。关键在于：所有节点（叶子和容器）都实现同一个接口，让调用方无需判断类型就能递归操作。
容易混淆的是把 struct 嵌套当成组合模式——比如 type Folder struct { Children []Folder } 这只是数据结构嵌套，没提供统一行为契约，无法实现“对任意节点调用 Print() 就自动展开子树”这种能力。
- 真正组合模式必须定义一个接口（如
Component），并让Leaf和Composite都实现它 - 所有操作方法（
Add、Remove、Operation）都在接口中声明，由具体类型各自实现逻辑 -
Composite类型内部持有[]Component，而不是具体类型切片，这是多态的关键
如何定义 Component 接口与两个具体类型
接口要精简，只包含树形结构真正共用的行为。常见错误是把 Add 和 Remove 强加给 Leaf，结果只能返回错误或 panic —— 更合理的方式是让接口只声明可安全通用的方法（如 GetName()、GetSize()、Accept(Visitor)），而增删操作放在 Composite 上单独提供。
type Component interface {
GetName() string
GetSize() int64
Accept(v Visitor)
}
type Leaf struct {
name string
size int64
}
func (l *Leaf) GetName() string { return l.name }
func (l *Leaf) GetSize() int64 { return l.size }
func (l *Leaf) Accept(v Visitor) { v.VisitLeaf(l) }
type Composite struct {
name string
children []Component
}
func (c *Composite) GetName() string { return c.name }
func (c *Composite) GetSize() int64 {
total := int64(0)
for _, ch := range c.children {
total += ch.GetSize()
}
return total
}
func (c *Composite) Accept(v Visitor) { v.VisitComposite(c) }
func (c *Composite) Add(child Component) {
c.children = append(c.children, child)
}
func (c *Composite) GetChildren() []Component {
return c.children
}
为什么需要 Visitor 模式配合组合模式
纯组合接口如果只暴露 GetName() 和 GetSize()，就很难做差异化遍历（比如“只统计文件数量，跳过目录大小”或“生成带缩进的树状文本”）。这时直接在 Component 加一堆方法会让接口膨胀，且违背单一职责。
立即学习“go语言免费学习笔记（深入）”；
Visitor 是解耦的好办法：把不同遍历逻辑抽成独立结构体，通过 Accept 方法触发双分派，让每个节点自己决定怎么被访问。
-
Visitor是个接口，定义VisitLeaf和VisitComposite方法 - 每个具体 Visitor（如
TreePrinter、SizeCounter）实现该接口，封装自己的逻辑 - 节点的
Accept方法里调用 visitor 对应的 Visit 方法，不关心 visitor 内部怎么处理
type Visitor interface {
VisitLeaf(*Leaf)
VisitComposite(*Composite)
}
type TreePrinter struct {
indent string
}
func (t *TreePrinter) VisitLeaf(l *Leaf) {
fmt.Printf("%s? %s (%d bytes)\n", t.indent, l.GetName(), l.GetSize())
}
func (t *TreePrinter) VisitComposite(c *Composite) {
fmt.Printf("%s? %s\n", t.indent, c.GetName())
newIndent := t.indent + " "
for _, ch := range c.GetChildren() {
ch.Accept(&TreePrinter{indent: newIndent})
}
}
实际使用时最容易踩的三个坑
组合模式在 Go 里写起来简洁，但运行时容易出隐性问题：
- 忘记用指针接收方法：如果
Composite.Add是值接收，append修改的是副本，原结构的children不会变 —— 必须用func (c *Composite) Add(...) - 递归调用没终止条件：比如
Composite.Accept里又调用子节点Accept，但某个子节点被误设为自身，就会无限递归栈溢出 - 混用值和指针类型导致接口实现丢失：定义
var c Component = Leaf{"a", 100}没问题，但var c Component = &Leaf{"a", 100}是另一个类型；若接口方法是值接收，两者都满足；若用了指针接收，只有后者能赋值给Component
最常被忽略的是：组合模式本身不解决线程安全。如果多个 goroutine 同时调用 Composite.Add 或遍历，需自行加锁 —— sync.RWMutex 放在 Composite 结构体里是最直接的做法。
