Golang 方法：值接收者与指针接收者详解

声明方法

方法就是带接收者的函数：接收者是写在方法名前面的一个额外参数。接收者把方法和某个类型绑定在一起。

package main

import (
	"fmt"
	"math"
)

type Circle struct {
	Radius float64
}

func (c Circle) Area() float64 {
	return math.Pi * c.Radius * c.Radius
}

func (c Circle) String() string {
	return fmt.Sprintf("Circle(r=%.1f)", c.Radius)
}

func main() {
	c := Circle{Radius: 2}
	fmt.Printf("%.2f\n", c.Area())
	fmt.Println(c) // uses the String method
}

接收者的名字通常是取自类型名的一两个字母（Circle 用 c）。Go 不使用 this 或 self，风格指南也不鼓励使用这样的名字。

因为 Circle 有一个 String() string 方法，它满足 fmt.Stringer，所以 fmt.Println 打印的是这个方法的结果，而不是 {2}。

值接收者与指针接收者

值接收者 (c Circle) 拿到的是一份副本。指针接收者 (c *Circle) 拿到的是地址，所以对字段的修改会保留下来。

package main

import "fmt"

type Counter struct {
	n int
}

func (c Counter) IncByValue() {
	c.n++ // changes the copy only
}

func (c *Counter) Inc() {
	c.n++
}

func (c Counter) Value() int {
	return c.n
}

func main() {
	var c Counter
	c.IncByValue()
	fmt.Println(c.Value()) // 0

	c.Inc() // Go takes &c automatically
	c.Inc()
	fmt.Println(c.Value()) // 2

	p := &c
	fmt.Println(p.Value()) // Go dereferences p automatically
}

IncByValue 能编译通过，却没有任何可见的效果，这是一个经典的 bug。如果一个方法要修改它的接收者，就需要指针接收者。

这些调用还体现了 Go 提供的两个便利。在可寻址的变量上调用 c.Inc()，会被改写为 (&c).Inc()；在指针上调用 p.Value()，会被改写为 (*p).Value()。你很少需要只为了调用方法而写 & 或 *。

自动取 & 需要一个可寻址的东西。map 元素和复合字面量都不可寻址：

m := map[string]Counter{"a": {}}
m["a"].Inc()    // compile error: cannot call pointer method Inc on Counter
Counter{}.Inc() // same error: a composite literal is not addressable

在 map 中存储指针（map[string]*Counter），或者把值复制出来，修改后再写回去。

选择哪种接收者

Go FAQ 和标准库遵循同一条经验法则：保持一致。如果有任何方法需要指针接收者，就让所有方法都使用指针接收者，这样方法集是可预测的。如果一个包含 sync.Mutex 的结构体通过值接收者被复制，go vet 会把它标记出来（passes lock by value）。

方法集与接口

这个区别对接口影响最大。T 的方法集包含值接收者的方法。*T 的方法集则同时包含值接收者和指针接收者的方法。

package main

import "fmt"

type Shape interface {
	Area() float64
}

type Square struct{ Side float64 }

func (s *Square) Area() float64 { return s.Side * s.Side }

type Rect struct{ W, H float64 }

func (r Rect) Area() float64 { return r.W * r.H }

func main() {
	shapes := []Shape{
		&Square{Side: 3},  // *Square has Area
		Rect{W: 2, H: 5},  // Rect has Area
		&Rect{W: 1, H: 1}, // *Rect has it too
	}
	for _, s := range shapes {
		fmt.Printf("%T %.0f\n", s, s.Area())
	}
}

如果在那个切片里写 Square{Side: 3} 而不加 &，就无法编译：

cannot use Square{…} (value of struct type Square) as Shape value in array or slice literal: Square does not implement Shape (method Area has pointer receiver)

原因是：接口中可以存放一个不可寻址的 Square 副本，所以 Go 无法取它的地址来调用指针方法。更多内容见接口。

非结构体类型上的方法

在你的包中声明的任何具名类型都可以有方法，不只是结构体。

package main

import (
	"fmt"
	"strings"
)

type Celsius float64

func (c Celsius) Fahrenheit() float64 {
	return float64(c)*9/5 + 32
}

type Tags []string

func (t Tags) String() string {
	return "#" + strings.Join(t, " #")
}

type Status int

func (s Status) String() string {
	switch s {
	case 0:
		return "pending"
	case 1:
		return "done"
	}
	return fmt.Sprintf("Status(%d)", int(s))
}

func main() {
	fmt.Println(Celsius(100).Fahrenheit())
	fmt.Println(Tags{"go", "backend"})
	fmt.Println(Status(1), Status(7))
}

限制在于：类型必须和方法定义在同一个包中，而且它的底层类型不能是指针或接口。你不能在自己的包中给 int、string 或 time.Time 添加方法。用一个新的具名类型把它包起来，这才是 Go 的做法。给整数类型定义 String() 方法，也是让枚举输出可读文本的办法；见用 iota 实现枚举。

方法值与方法表达式

绑定到某个具体接收者的方法，就是一个函数值：

package main

import "fmt"

type Greeter struct{ Name string }

func (g Greeter) Hello(to string) string {
	return g.Name + " says hi to " + to
}

func main() {
	g := Greeter{Name: "Ana"}

	f := g.Hello // method value: receiver bound now
	g.Name = "Bob"
	fmt.Println(f("Cy")) // still Ana: the receiver was copied

	h := Greeter.Hello // method expression: receiver becomes the first parameter
	fmt.Println(h(g, "Dee"))
}

使用值接收者的方法值在创建时会复制接收者，所以 f 打印的仍然是 Ana。如果是指针接收者，它会保存指针，因而能看到之后的修改。方法值很适合用作回调：http.HandleFunc("/", srv.handleIndex)。

常见错误

• 会修改接收者的方法却用了值接收者。 能编译通过，却只是悄悄修改了一份副本。
• 混用两种接收者。 会让人搞不清是 T 还是 *T 满足某个接口。每个类型只选一种。
• 在 nil 指针上调用指针方法。 这是允许的，方法会以 nil 接收者运行，只有在访问字段时才会 panic。有些类型（比如 nil 安全的链表）会有意利用这一点，但大多数类型并不预期这种情况。