我可以为常用方法创建方法别名：

1
2
3
4
5
func method1() {
    fmt.Println("method1")
}

var Method1 = method1

但是不能对方法接收者做同样的事情：

1
2
3
4
5
6
7
8
9
type Person struct {
    Name string
}

func (p *Person) methodReciver() {
    fmt.Println("method reciver")
}

var MethodReciver = methodReciver

在这种情况下，我在第var MethodReciver = methodReciver行出现了错误：

1
undefined: methodReciver

完整代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package main

import (
   "fmt"
)

type Person struct {
    Name string
}

func method1() {
    fmt.Println("method1")
}

var Method1 = method1

func (p *Person) methodReceiver() {
    fmt.Println("method receiver")
}

var MethodReceiver = methodReceiver

func main() {
    method1()
    Method1()
    p := Person{"Nick"}
    p.methodReceiver()
    p.MethodReceiver()
}

操场

是否可以为methodReceiver创建方法别名？

基本上，您有2个选择：

1.使用方法表达式

ReceiverType.MethodName的形式，它产生一个函数类型的值：

1
var MethodReceiver = (*Person).methodReceiver

MethodReceiver仅保留函数引用，但不包含接收器，因此，如果要调用它，还必须将一个接收器(类型为*Person)传递给它作为其首个参数：

1
2
var p = &Person{"Alice"}
MethodReceiver(p)  // Receiver is explicit: p

2.使用方法值

形式为x.MethodName，其中表达式x具有静态类型T：

1
2
var p = &Person{"Bob"}
var MethodReceiver2 = p.methodReceiver

方法值也存储接收器，因此，在调用它时，不必将接收器传递给它：

1
MethodReceiver2()  // Receiver is implicit: p

完整的例子

在Go Playground上尝试一下。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
type Person struct {
    Name string
}

func (p *Person) printName() {
    fmt.Println(p.Name)
}

var PrintName1 = (*Person).printName

func main() {
    var p1 *Person = &Person{"Bob"}
    PrintName1(p1) // Have to specify receiver explicitly: p1

    p2 := &Person{"Alice"}
    var PrintName2 = p2.printName // Method value, also stores p2
    PrintName2()                  // Implicit receiver: p2
}

输出：

1
2
Bob
Alice

是。 您可以这样命名：

1
var MethodReceiver = (*Person).methodReceiver

调用它时，必须提供一个指向人员对象的指针作为第一个参数：

1
MethodReceiver(&p)

您可以在Go Playground上看到这一点。

这称为方法表达式var MethodReceiver = (*Person).methodReceiver

操场