1. 方法的本质
2. 正确选择 receiver 类型
3. 利用对 Go 方法本质的理解巧解难题
4. 小结

Go 语言不支持经典的面向对象语法元素，比如：类、对象、继承等。但 Go 语言也有方法（method）。和函数相比，Go 语言中的方法在声明形式上仅仅多了一个参数，Go 称之为 receiver 参数。而 receiver 参数正是方法与类型之间的纽带。

Go 方法的一般声明形式如下：

func (receiver T/*T) MethodName(参数列表) (返回值列表) {
    // 方法体
}

Go 方法具有如下特点：

方法名的首字母是否大写决定了该方法是否是导出方法；
方法定义要与类型定义放在同一个包内。

receiver 参数的基类型本身不能是指针类型或接口类型:

type MyInt *int
func (r MyInt) String() string { // invalid receiver type MyInt (MyInt is a pointer type)
    return fmt.Sprintf("%d", *(*int)(r))
}
type MyReader io.Reader
func (r MyReader) Read(p []byte) (int, error) { // invalid receiver type MyReader (MyReader is an interface type)
    return r.Read(p)
}

1. 方法的本质

前面提到过：Go 语言没有类，方法与类型通过 receiver 联系在一起，我们可以为任何非内置原生类型定义方法，比如下面的类型 T：

type T struct { 
        a int
}
func (t T) Get() int {  
        return t.a 
}
func (t *T) Set(a int) int { 
        t.a = a 
        return t.a 
}

C++的对象在调用方法时，编译器会自动传入指向对象自身的 this 指针作为方法的第一个参数。而对于 Go 来说，receiver 其实也是同样道理，我们将 receiver 作为第一个参数传入方法的参数列表，上面示例中的类型 T 的方法就可以等价转换为下面的普通函数：

func Get(t T) int {  
        return t.a 
}
func Set(t *T, a int) int { 
        t.a = a 
        return t.a 
}

Go 方法的一般使用方式如下：

var t T
t.Get()
t.Set(1)

我们可以将上面方法调用用下面的方式做等价替换：

var t T
T.Get(t)
(*T).Set(&t, 1) // 这个是可以编译通过的

Go 方法的本质：一个以方法所绑定类型实例为第一个参数的普通函数。

Method Expression 体现了 Go 方法的本质：其自身的类型就是一个普通函数。我们甚至可以将其作为右值赋值给一个函数类型的变量：

var t T
f1 := (*T).Set // f1的类型，也是T类型Set方法的原型：func (t *T, int)int
f2 := T.Get // f2的类型，也是T类型Get方法的原型：func(t T)int
f1(&t, 3)
fmt.Println(f2(t))

2. 正确选择 receiver 类型

我们再来看一下方法和函数的”等价变换公式“：

func (t T) M1() <=> M1(t T)
func (t *T) M2() <=> M2(t *T)

当 receiver 参数的类型为 T 时，即选择值类型的 receiver。

我们选择以 T 作为 receiver 参数类型时，T 的 M1 方法等价为 M1(t T)。我们知道 Go 函数的参数采用的是值拷贝传递，也就是说 M1 函数体中的 t 是 T 类型实例的一个副本，这样 M1 函数的实现中无论对参数 t 做任何修改都只会影响副本，而不会影响到原 T 类型实例。

当 receiver 参数的类型为 *T 时，即选择指针类型的 receiver。

我们选择以T 作为 receiver 参数类型时，T 的 M2 方法等价为 M2(t T)。我们传递给 M2 函数的 t 是 T 类型实例的地址，这样 M2 函数体中对参数 t 做的任何修改都会反映到原 T 类型实例。

// method_nature_1.go 
package main
type T struct {
    a int
}
func (t T) M1() {
    t.a = 10
}
func (t *T) M2() {
    t.a = 11
}
func main() {
    var t T // t.a = 0
    println(t.a)
    t.M1()
    println(t.a)
    t.M2()
    println(t.a)
}

运行该程序：

$ go run method_nature_1.go 
0
0
11

无论是 T 类型实例，还是T 类型实例，都既可以调用 receiver 为 T 类型的方法，也可以调用 receiver 为T 类型的方法。下面例子证明了这一点：

// method_nature_2.go
package main
type T struct {
    a int
}
func (t T) M1() {
}
func (t *T) M2() {
    t.a = 11
}
func main() {
    var t T
    t.M1() // ok
    t.M2() // <=> (&t).M2()
    var pt = &T{}
    pt.M1() // <=> (*pt).M1()
    pt.M2() // ok
}

通过例子我们看到 T 类型实例 t 调用 receiver 类型为T 的 M2 方法是没问题的，同样T 类型实例 pt 调用 receiver 类型为 T 的 M1 方法也是可以的。实际上这都是 Go 语法甜头(syntactic sugar)，即 Go 编译器在编译和生成代码时为我们自动做的转换。

结论:

如果要对类型实例进行修改，那么为 receiver 选择*T 类型；
如果没有对类型实例修改的需求，那么为 receiver 选择 T 类型或T 类型均可；但考虑到 Go 方法调用时，receiver 是以值拷贝的形式传入方法中的。如果类型 size 较大，以值形式传入会导致较大损耗，这时选择T 作为 receiver 类型可能更好些。

3. 利用对 Go 方法本质的理解巧解难题

// method_nature_3.go
package main
import (
    "fmt"
    "time"
)
type field struct {
    name string
}
func (p *field) print() {
    fmt.Println(p.name)
}
func main() {
    data1 := []*field{{"one"}, {"two"}, {"three"}}
    for _, v := range data1 {
        go v.print()
    }
    data2 := []field{{"four"}, {"five"}, {"six"}}
    for _, v := range data2 {
        go v.print()
    }
    time.Sleep(3 * time.Second)
}

该示例在我的多核 MacOS 上运行结果如下（由于 goroutine 调度顺序不同，结果可能与下面的有差异）：

$ go run method_nature_3.go
one
two
three
six
six
six

好了，我们来分析一下。首先，我们根据Go 方法的本质：一个以方法所绑定类型实例为第一个参数的普通函数，对这个程序做个等价变换(这里我们利用 Method Expression)，变换后的源码如下：

// method_nature_4.go
package main
import (
        "fmt"
        "time"
)
type field struct {
        name string
}
func (p *field) print() {
        fmt.Println(p.name)
}
func main() {
        data1 := []*field{{"one"}, {"two"}, {"three"}}
        for _, v := range data1 {
                go (*field).print(v)
        }
        data2 := []field{{"four"}, {"five"}, {"six"}}
        for _, v := range data2 {
                go (*field).print(&v)
        }
        time.Sleep(3 * time.Second)
}

我们可以很清楚地看到使用 go 关键字启动一个新 goroutine 时是如何绑定参数的：

迭代 data1 时，由于 data1 中的元素类型是 field 指针(*field)，因此赋值后 v 就是元素地址，每次调用 print 时传入的参数(v)实际上也是各个 field 元素的地址；
迭代 data2 时，由于 data2 中的元素类型是 field（非指针），需要将其取地址后再传入。这样每次传入的&v 实际上是变量 v 的地址，而不是切片 data2 中各元素的地址；

那么原程序如何修改一下才能让其按期望输出（“one”、“two”、“three”, “four”, “five”, “six”）呢？

其实只需将 field 类型 print 方法的 receiver 类型由*field 改为 field 即可。

// method_nature_5.go
... ...
type field struct {
    name string
}
func (p field) print() {
    fmt.Println(p.name)
}
... ...

修改后的程序的输出结果为（因 goroutine 调度顺序不同，在你的机器上的结果输出顺序与这里可能会有不同）：

one
two
three
four
five
six

// method_nature_4.go
package main
import (
        "fmt"
        "time"
)
type field struct {
        name string
}
func (p field) print() {
        fmt.Println(p.name)
}
func main() {
        data1 := []*field{{"one"}, {"two"}, {"three"}}
        for _, v := range data1 {
                go (field).print(*v) // 解引用后进行值拷贝
        }
        data2 := []field{{"four"}, {"five"}, {"six"}}
        for _, v := range data2 {
                go (field).print(v) // 直接值拷贝
        }
        time.Sleep(3 * time.Second)
}

4. 小结

本节要点：

Go 方法的本质：一个以方法所绑定类型实例为第一个参数的普通函数；
Go 语法甜头使得我们通过类型实例调用类型方法时无需考虑实例类型与 receiver 参数类型是否一致，编译器会为我们做自动转换；
receiver 参数类型选择时要看是否要对类型实例进行修改；如有修改需求，则选择*T；如无修改需求，T 类型 receiver 传值的性能损耗也是考量因素之一。

改善Go语言编程质量的50个有效实践

20 Go 方法的本质

1. 方法的本质

2. 正确选择 receiver 类型

3. 利用对 Go 方法本质的理解巧解难题

4. 小结