GoLang之方法调用系列一_go 语言调用不同类方法

GoLang之方法调用系列一

1.方法

方法即method，Go语言支持为自定义类型实现方法，method在具体实现上与普通的函数并无不同，只不过会通过运行时栈多传递一个隐含的参数，这个隐含的参数就是所谓的接收者。下面通过代码来进行说明：

type A struct {
    name string
}
func (a A) Name() string {
    a.name = "Hi! " + a.name
    return a.name
}
func main() {
    a := A{name: "eggo"}
    // 1）编译器的语法糖，提供面向对象的语法
    fmt.Println(a.Name())
    // 2）更贴近真实实现的写法，和普通函数调用几乎没什么不同
    fmt.Println(A.Name(a))
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

以上代码展示了两种不同的写法，都能顺利通过编译并正常运行，实际上这两种写法会生成同样的机器码。
第一种：a.Name()，这是我们惯用的写法，很方便；
第二种：A.Name(a)，这种写法更底层也更严谨，要求所有的类型必须严格对应，否则是无法通过编译的。
其实编译器会帮我们把第一种转换为第二种的形式，所以我们惯用的第一种写法只是“语法糖”，方便而已。

深入理解这两种写法的等价性是非常重要的，下面再用代码进一步验证：

type A struct {
    name string
}
func (a A) Name() string {
    a.name = "Hi! " + a.name
    return a.name
}
func NameOfA(a A) string {
    a.name = "Hi! " + a.name
    return a.name
}
func main() {
    t1 := reflect.TypeOf(A.Name)
    t2 := reflect.TypeOf(NameOfA)
    // 会输出true，通过反射来验证，两者的类型是相同的
    fmt.Println(t1 == t2)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

因为Go语言反射获取的函数类型只跟参数和返回值有关，既然t1和t2相等，就说明类型A的方法本质上和函数NameOfA相同。也就进一步验证了：方法本质上就是普通的函数，而接收者就是隐含的第一个参数。

2.值接收者

接下来，我们看看上面第一个示例中，a.Name()执行时函数调用栈是什么情况。
main函数栈帧中局部变量a只有一个string类型的成员，a.Name()会由编译器转换为A.Name(a)这样的函数调用。局部变量a作为要传入的参数，被直接拷贝到参数空间。

A.Name(a)执行时,修改的是参数空间的a.name，string底层指向的字符串内容发生了变化。

函数返回前将返回值写入返回值空间，对应到这个例子，就是拷贝参数a的成员name到返回值空间。

通过值接收者调用方法时，值接收者会作为第一个参数，而Go语言中传参都是值拷贝，所以执行a.Name()修改的并不是局部变量a，而是拷贝过去的参数。要想修改a，还得用指针接收者。

3.指针接收者

我们把上个例子改为指针接收者，然后看看通过指针接收者调用方法时，函数调用栈又会是怎样的情况。

type A struct {
    name string
}
func (pa *A) Name() string {
    pa.name = "Hi! " + pa.name
    return pa.name
}
func main() {
    a := A{name: "eggo"}
    pa := &a
    fmt.Println(pa.Name())
}
1
2
3
4
5
6
7
8
9
10
11
12

main函数栈帧有两个局部变量，pa存储的是a的地址。pa.Name()会由编译器转换为（*A).Name(pa)函数调用，所以参数空间拷贝参数pa的值，也就是局部变量a的地址。

(*A).Name(pa)执行时，修改的是pa指向的结构体，也就是局部变量a.name的值。这个string类型的成员会指向新的底层字符串，而返回值空间被写入的也是pa指向的结构体的成员name。

通过指针类型接收者调用方法时，指针会作为参数传入，传参时拷贝的就是地址，所以这里能够实现对原来变量a的修改。

4.更甜的语法糖

再次修改上面的例子，这一次既有值接收者的方法，又有指针接收者的方法。对于a.GetName()和pa.SetName()这两种形式的方法调用我们已经了然。但是下面这pa.GetName()和a.SetName()也能正常执行是几个意思？

type A struct {
    name string
}
func (a A) GetName() string {
    return a.name
}
func (pa *A) SetName() string {
    pa.name = "Hi! " + pa.name
    return pa.name
}
func main() {
    a := A{name: "eggo"}
    pa := &a
    
    fmt.Println(pa.GetName())
    fmt.Println(a.SetName())
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

不用展开函数调用栈，只需告诉你这是语法糖，理解起来也就没有问题了。编译期间，会把pa.GetName()这种方法调用转换成(*pa).GetName()，也就等价于执行A.GetName(*pa)。而a.SetName()会被转换成(&a).SetName()，也相当于执行（*A).SetName(&a)。所以，看似值接收者和指针接收者交叉访问了对方的方法，实际上依然遵循之前介绍的执行过程。
注：“如果定义的方法不涉及到任何接口类型时是这样的，详细情况以后详述，目前这样理解无碍。”

既然这种语法糖是在编译期间发挥作用的，像下面这种编译期间不能拿到地址的字面量，就不能享受语法糖，转换成对应的指针接收者调用了。

func main() {
    fmt.Println((A{name: "eggo"}).SetName())
}
1
2
3

编译期间会发生错误：

cannot call pointer method on A literal
cannot take the address of A literal
错误: 进程退出代码 2.
1
2
3

5.Method Expression&Method Value

5.1介绍

我们已经知道，Go语言中函数作为变量、参数和返回值时，都是以Function Value的形式存在的。也知道闭包只是有捕获列表(catch list)的Funtion Value而已。

那么如果把方法赋给一个变量，这个变量又是怎样的存在呢？

type A struct {
    name string
}
func (a A) GetName() string {
    return a.name
}
func main(){
    a := A{name:"eggo"}

    f1 := A.GetName      //方法表达式
    f1(a)                //eggo

    f2 := a.GetName      //方法变量
    f2()                 //eggo
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

5.2方法表达式

如果像f1这样，把一个类型的方法赋给它，这样的变量就被称为“方法表达式”。对f1的处理相当于下面这段代码：

......    
func GetName(a A) string{
    return a.name
}
func main(){
    a := A{name:"eggo"}

    f1 := GetName
    f1(a)
}
1
2
3
4
5
6
7
8
9
10
11

所以，f1实际上就是一个普通的Function Value，执行时需要传入一个A类型的变量作为第一个参数。

5.3方法变量（作为局部变量）

然而，像f2这样，通过a.GetName进行赋值，这样的变量被称为“方法变量”。通过方法变量执行方法时，我们无需再传入方法接收者作为第一个参数，这是因为编译器替我们做了处理。方法变量也是一个Function Value，在这个例子中，编译阶段f2()会被转换为A.GetName(a)。但是这只是方法变量作为局部变量的情况。

5.4方法变量（作为返回值）

如果像下面的GetFunc函数这样，把方法变量作为返回值。这个返回值实际上是一个捕获了局部变量a的Function Value，也就是说f3是一个闭包对象。

...... 
func GetFunc() func() string {
    a := A{name: "eggo in GetFunc"}
    return a.GetName
}
func main() {
    a := A{name: "eggo in main"}
    f2 := a.GetName
    fmt.Println(f2()) //这里输出：eggo in main

    f3 := GetFunc()
    fmt.Println(f3()) //这里输出：eggo in GetFunc
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

上面的GetFunc函数和下面这段代码是等价的，通过它我们能够清晰地看到闭包是如何形成的。

func GetFunc() (func()string) {
    a := A{name:"eggo in GetFunc"}

    return func()string{
        return A.GetName(a)  //捕获变量a
    }
}
1
2
3
4
5
6
7
8

f3是一个闭包对象，它执行时用到的是自己捕获的变量，也就是函数GetFunc的局部变量a。而f2这个方法变量，使用的是main函数的局部变量a。这样就很好理解上面这段示例程序的输出结果了。