方法

假设有两个方法，一个方法的接收者是指针类型，一个方法的接收者是值类型，那么：

  • 对于值类型的变量和指针类型的变量，这两个方法有什么区别？
  • 如果这两个方法是为了实现一个接口，那么这两个方法都可以调用吗？
  • 如果方法是嵌入到其他结构体中的，那么上面两种情况又是怎样的？
  1. package main
  4. import "fmt"
  7. //定义一个结构体
  8. type T struct {
  9.     name string
  10. }
  13. func (t T) method1() {
  14.     t.name = "new name1"
  15. }
  18. func (t *T) method2() {
  19.     t.name = "new name2"
  20. }
  23. func main() {
  26.     t := T{"old name"}
  29.     fmt.Println("method1 调用前 ", t.name)
  30.     t.method1()
  31.     fmt.Println("method1 调用后 ", t.name)
  34.     fmt.Println("method2 调用前 ", t.name)
  35.     t.method2()
  36.     fmt.Println("method2 调用后 ", t.name)
  37. }

运行结果：

  1. method1 调用前  old name
  2. method1 调用后  old name
  3. method2 调用前  old name
  4. method2 调用后  new name2

当调用t.method1()时相当于method1(t)，实参和行参都是类型 T，可以接受。此时在method1()中的t只是参数t的值拷贝，所以method1()的修改影响不到main中的t变量。

当调用t.method2()=>method2(t)，这是将 T 类型传给了 *T 类型，go可能会取 t 的地址传进去：method2(&t)。所以 method1() 的修改可以影响 t。

T 类型的变量这两个方法都是拥有的。

方法值和方法表达式

方法值

我们经常选择一个方法，并且在同一个表达式里执行，比如常见的p.Distance()形式，实际上将其分成两步来执行也是可能的。p.Distance叫作“选择器”，选择器会返回一个方法”值”一个将方法(Point.Distance)绑定到特定接收器变量的函数。这个函数可以不通过指定其接收器即可被调用；即调用时不需要指定接收器，只要传入函数的参数即可：

  1. package main
  4. import "fmt"
  5. import "math"
  8. type Point struct{ X, Y float64 }
  11. //这是给struct Point类型定义一个方法
  12. func (p Point) Distance(q Point) float64 {
  13.     return math.Hypot(q.X-p.X, q.Y-p.Y)
  14. }
  17. func main() {
  20.     p := Point{1, 2}
  21.     q := Point{4, 6}
  24.     distanceFormP := p.Distance   // 方法值(相当于C语言的函数地址,函数指针)
  25.     fmt.Println(distanceFormP(q)) // "5"
  26.     fmt.Println(p.Distance(q))    // "5"
  29.     //实际上distanceFormP 就绑定了 p接收器的方法Distance
  32.     distanceFormQ := q.Distance   //
  33.     fmt.Println(distanceFormQ(p)) // "5"
  34.     fmt.Println(q.Distance(p))    // "5"
  37.     //实际上distanceFormQ 就绑定了 q接收器的方法Distance
  38. }

在一个包的API需要一个函数值、且调用方希望操作的是某一个绑定了对象的方法的话，方法”值”会非常实用.

举例来说，下面例子中的time.AfterFunc这个函数的功能是在指定的延迟时间之后来执行一个(译注：另外的)函数。且这个函数操作的是一个Rocket对象r

  1. type Rocket struct { /* ... */ }
  2. func (r *Rocket) Launch() { /* ... */ }
  3. r := new(Rocket)
  4. time.AfterFunc(10 * time.Second, func() { r.Launch() })

直接用方法”值”传入AfterFunc的话可以更为简短：

  1. time.AfterFunc(10 * time.Second, r.Launch)

省掉了上面那个例子里的匿名函数。

方法表达式

和方法”值”相关的还有方法表达式。当调用一个方法时，与调用一个普通的函数相比，我们必须要用选择器(p.Distance)语法来指定方法的接收器。

当T是一个类型时，方法表达式可能会写作T.f或者(*T).f，会返回一个函数”值”，这种函数会将其第一个参数用作接收器，所以可以用通常(译注：不写选择器)的方式来对其进行调用：

  1. package main
  4. import "fmt"
  5. import "math"
  8. type Point struct{ X, Y float64 }
  11. //这是给struct Point类型定义一个方法
  12. func (p Point) Distance(q Point) float64 {
  13.     return math.Hypot(q.X-p.X, q.Y-p.Y)
  14. }
  17. func main() {
  20.     p := Point{1, 2}
  21.     q := Point{4, 6}
  26.     distance1 := Point.Distance //方法表达式, 是一个函数值(相当于C语言的函数指针)
  27.     fmt.Println(distance1(p, q))
  28.     fmt.Printf("%T\n", distance1) //%T表示打出数据类型 ,这个必须放在Printf使用
  31.     distance2 := (*Point).Distance //方法表达式,必须传递指针类型
  32.     distance2(&p, q)
  33.     fmt.Printf("%T\n", distance2)
  36. }

执行结果

  1. 5
  2. func(main.Point, main.Point) float64
  3. func(*main.Point, main.Point) float64
  4. // 这个Distance实际上是指定了Point对象为接收器的一个方法func (p Point) Distance()，
  5. // 但通过Point.Distance得到的函数需要比实际的Distance方法多一个参数，
  6. // 即其需要用第一个额外参数指定接收器，后面排列Distance方法的参数。
  7. // 看起来本书中函数和方法的区别是指有没有接收器，而不像其他语言那样是指有没有返回值。

当你根据一个变量来决定调用同一个类型的哪个函数时，方法表达式就显得很有用了。你可以根据选择来调用接收器各不相同的方法。下面的例子，变量op代表Point类型的addition或者subtraction方法，Path.TranslateBy方法会为其Path数组中的每一个Point来调用对应的方法：

  1. package main
  4. import "fmt"
  5. import "math"
  8. type Point struct{ X, Y float64 }
  11. //这是给struct Point类型定义一个方法
  12. func (p Point) Distance(q Point) float64 {
  13.         return math.Hypot(q.X-p.X, q.Y-p.Y)
  14. }
  17. func (p Point) Add(another Point) Point {
  18.         return Point{p.X + another.X, p.Y + another.Y}
  19. }
  22. func (p Point) Sub(another Point) Point {
  23.         return Point{p.X - another.X, p.Y - another.Y}
  24. }
  27. func (p Point) Print() {
  28.         fmt.Printf("{%f, %f}\n", p.X, p.Y)
  29. }
  32. //定义一个Point切片类型 Path
  33. type Path []Point
  36. //方法的接收器 是Path类型数据, 方法的选择器是TranslateBy(Point, bool)
  37. func (path Path) TranslateBy(another Point, add bool) {
  38.         var op func(p, q Point) Point //定义一个 op变量 类型是方法表达式 能够接收Add,和 Sub方法
  39.         if add == true {
  40.                 op = Point.Add //给op变量赋值为Add方法
  41.         } else {
  42.                 op = Point.Sub //给op变量赋值为Sub方法
  43.         }
  46.         for i := range path {
  47.                 //调用 path[i].Add(another) 或者 path[i].Sub(another)
  48.                 path[i] = op(path[i], another)
  49.                 path[i].Print()
  50.         }
  51. }
  54. func main() {
  56.         points := Path{
  57.                 {10, 10},
  58.                 {11, 11},
  59.         }
  62.         anotherPoint := Point{5, 5}
  65.         points.TranslateBy(anotherPoint, false)
  68.         fmt.Println("------------------")
  71.         points.TranslateBy(anotherPoint, true)
  72. }

运行结果：

  1. {5.000000, 5.000000}
  2. {6.000000, 6.000000}
  3. ------------------
  4. {10.000000, 10.000000}
  5. {11.000000, 11.000000}