2.Go 方法（Method）

1. 方法是什么：带接收者的函数#

Go 方法的基本形式是：

1
type User struct {
2
  Name string
3
  Age  int
4
}
5

6
func (u User) SayHello() {
7
  fmt.Println("hello,", u.Name)
8
}

这里和普通函数的差别在于：

• 普通函数：参数全写在括号里
• 方法：函数名前面多了一个接收者 (u User)

接收者不是特殊语法糖，本质上是在说：

• SayHello 这个行为属于 User
• 调用时可以写成 u.SayHello()

方法可以定义在任意“已定义类型”上，不一定非得是结构体，但最常见场景确实是结构体。

2. 值接收者：方法拿到的是接收者副本#

值接收者写法：

1
func (u User) Grow() {
2
  u.Age++
3
}

这里 u 是调用对象的一份拷贝。

这意味着：

• 在方法里改 u.Age，默认不会改到原对象
• 值接收者更适合“只读语义”或“小对象副本语义”

例如：

1
u := User{Name: "Tom", Age: 18}
2
u.Grow()
3
fmt.Println(u.Age) // 仍然是 18

因为 Grow 改的是副本，不是原值。

但要注意一个边界：

• 值接收者复制的是“接收者值”
• 如果接收者内部字段本身又是 slice、map、pointer，这些字段指向的底层数据仍可能共享

所以“值接收者不会影响外部”这句话，只对字段本身是纯值时最直观。

3. 指针接收者：方法拿到的是指向原对象的指针#

指针接收者写法：

1
func (u *User) Grow() {
2
  u.Age++
3
}

这里 u 的类型是 *User，方法操作的是原对象。

例如：

1
u := User{Name: "Tom", Age: 18}
2
u.Grow()
3
fmt.Println(u.Age) // 19

虽然代码写的是 u.Grow()，但如果 u 是可取地址的值，Go 会自动帮你取地址，等价于：

1
(&u).Grow()

这就是很多人第一次学 Go 方法时最困惑的点：值居然能调指针接收者方法。

4. “能调用”和“方法集包含”不是一回事#

这是整个主题的核心。

Go 有两个相关但不同的规则：

1. 方法调用规则
2. 方法集规则

方法调用规则#

如果一个值是可寻址的，且需要调用指针接收者方法，Go 可以自动取地址。

所以：

1
u.Grow()

在 u 可寻址时，可以成立。

方法集规则#

方法集决定“某个类型真正拥有哪些方法”，它是更严格的类型系统规则。

对一个已定义类型 T：

• T 的方法集只包含接收者为 T 的方法
• T 的方法集包含接收者为 T 和 T 的方法

这就是为什么：

• 值 T 有时能调用指针方法
• 但 T 并不因此拥有 T 的完整方法集

5. 方法集：它决定接口实现，不是调用方便性#

方法集最重要的用途，不是“决定你能不能点出来调用”，而是“决定一个类型是否实现某接口”。

例如：

1
type Speaker interface {
2
  Speak()
3
}

如果有：

1
func (u User) Speak() {}

那么：

• User 实现了 Speaker
• User 也实现了 Speaker

因为 *User 的方法集包含 User 的值接收者方法。

但如果是：

1
func (u *User) Speak() {}

那么：

• User 实现了 Speaker
• User 不实现 Speaker

因为 User 的方法集里没有这个指针接收者方法。

这就是面试和实战里最常见的判断题来源。

6. 为什么 T 的方法集比 T 更大#

因为 Go 规定：

• T 的方法集：只有 T 接收者方法
• T 的方法集：同时包含 T 和 T 接收者方法

这样设计的结果是：

• 指针值比普通值“能力更多”
• 用 T 更容易满足接口
• 值接收者方法天然兼容值和指针两种调用方

这也解释了一个实践建议：

• 如果某类型的方法里只要有一个必须用指针接收者，通常整组方法都倾向统一成指针接收者风格

这样 API 一致性更好。

7. 自动取地址有边界：不是所有值都能调指针接收者方法#

Go 自动取地址只发生在“值可寻址”时。

例如变量通常可寻址：

1
u := User{}
2
u.Grow() // 可以

但函数返回值、map 元素这类经常不可寻址：

1
makeUser().Grow()    // 常见非法场景
2
m["tom"].Grow()      // 非法，map 元素不可寻址

根因不是“语法不够智能”，而是语言不允许对这些非可寻址结果偷偷构造稳定地址。

这也是“调用规则”里很重要的边界。

8. 值接收者 vs 指针接收者：不是只看能不能改值#

很多人把区别简化成：

• 值接收者：不修改原值
• 指针接收者：修改原值

这不算错，但太浅。

更完整的判断维度包括：

• 是否需要修改接收者状态
• 接收者是否很大，复制成本是否高
• 是否希望方法集在接口实现上更明确
• 是否需要统一整组方法风格
• 类型内部是否包含锁等不应复制的字段

例如带 sync.Mutex 的结构体通常不应使用值接收者，因为复制锁本身就有问题。

9. 方法值与方法表达式也会受接收者规则影响#

虽然本题重点不是这个，但方法集常和它们连在一起。

例如：

1
f := u.SayHello

这是方法值，接收者已经绑定。

而：

1
f := User.SayHello

这是方法表达式，接收者要显式传入。

这里的关键不是记术语，而是理解：方法本质上仍然和接收者类型绑定，换一种写法，这个绑定关系不会消失。

图意：这张图具体说明类型 T、指针类型 *T 和接口 I 的方法集合如何比较，重点看左边 T 只有值接收者方法、中间 *T 同时拥有值和指针接收者方法，最后理解接口实现判断是按方法集做包含关系比较，而不是按“调用时能不能自动取地址”判断。

1. 误以为值能调用指针方法，就说明值类型实现了该接口#

错误理解：

1
c.Inc()

能调用成功，于是认为：

1
var x Incer = c

也应该成立。

这是错的。前者靠的是“可寻址值的自动取地址”，后者看的是方法集，Counter 的方法集里并没有 Inc。

2. 在 map 元素上调用指针接收者方法#

错误示例：

1
m := map[string]Counter{"a": {N: 1}}
2
m["a"].Inc()

map 元素不可寻址，Go 不能对它自动取地址，因此这种写法不成立。

1
m := map[string]*User{
2
  "tom": {Age: 18},
3
}
4
m["tom"].Age = 20
5
# 为什么 m["tom"].Age = 20 不行，但 m["tom"] = User{...} 又可以。

3. 值接收者里修改字段，却以为改到了原对象#

错误示例：

1
func (c Counter) Inc() {
2
  c.N++
3
}

如果你想修改原对象，这样写通常达不到预期，因为改的是副本。

4. 一个类型的方法有的用值接收者，有的用指针接收者，但没有明确理由#

这会让 API 风格和接口实现边界变得很乱。混用不是绝对禁止，但应该有明确原因，而不是随手写。

5. 在包含锁或大对象的结构体上使用值接收者#

如果结构体包含 sync.Mutex 之类字段，值接收者可能导致复制锁，语义和并发安全都会出问题。

1. 值接收者的优点是语义简单#

优点：

• 更接近“这个方法只读当前值”
• 小对象上复制成本低
• T 和 T 都能直接使用这些方法

代价：

• 大对象复制成本可能上升
• 若内部含引用字段，读者容易误判“完全不会影响外部状态”

2. 指针接收者更适合可变对象和大结构体#

优点：

• 避免大对象复制
• 可以直接修改原对象
• 更容易统一整组方法风格

代价：

• 引入共享可变状态
• 接口实现判断更容易出错
• 使用者必须更关注 nil 和对象生命周期

3. 方法集规则让类型系统更严格，但初学门槛更高#

Go 没有简单地用“能调用就算有方法”这套宽松规则，而是把“方法集”和“自动取地址调用”分开。这提高了接口判断的一致性，但也让初学者很容易在 T/*T 上踩坑。

1. 值接收者和指针接收者的区别是什么#

值接收者方法拿到的是接收者副本，通常不修改原对象；指针接收者方法拿到的是原对象地址，通常可以修改原对象，并且避免大对象复制。

2. 为什么值也能调用指针接收者方法#

因为如果这个值是可寻址的，Go 会在方法调用时自动取地址，把 t.M() 解释成 (&t).M()。这是调用规则，不等于该方法属于值类型的方法集。

3. T 和 T 的方法集分别是什么#

对已定义类型 T，T 的方法集只包含接收者为 T 的方法；*T 的方法集包含接收者为 T 和 *T 的方法。

4. 为什么 T 可能实现接口而 T 不实现#

因为接口实现看方法集。如果接口需要的方法只用指针接收者定义，那么它只在 *T 的方法集中，不在 T 的方法集中，所以只有 *T 实现该接口。

5. 为什么 map 元素不能调用指针接收者方法#

因为 map 元素不可寻址，Go 不能对它做自动取地址，所以无法把 m[k].M() 转成 (&m[k]).M()。

6. 什么时候优先用指针接收者#

当方法需要修改接收者、接收者较大、类型包含锁或不适合复制的字段，或者希望整组方法保持统一时，优先使用指针接收者。