[译] part 17: golang 方法 methods

https://juejin.im/post/5cab05996fb9a05e396a621f

什么是方法

方法是一个具有特殊接收者类型的函数，接收者在func关键字和方法名称之间。接收者可以是struct类型或非struct类型。接收者可用于方法内部的访问。

以下是创建方法的语法。

  1. func (t Type) methodName(parameter list) {  
  2. }

上面的代码片段创建了一个名为methodName的方法，该方法具有类型为Type的接收者。

方法的例子

让我们编写一个简单的程序，它在结构类型上创建一个方法并调用它。

  1. package main
  3. import (  
  4.     "fmt"
  5. )
  7. type Employee struct {  
  8.     name     string
  9.     salary   int
  10.     currency string
  11. }
  13. /*
  14.  displaySalary() method has Employee as the receiver type
  15. */
  16. func (e Employee) displaySalary() {  
  17.     fmt.Printf("Salary of %s is %s%d", e.name, e.currency, e.salary)
  18. }
  20. func main() {  
  21.     emp1 := Employee {
  22.         name:     "Sam Adolf",
  23.         salary:   5000,
  24.         currency: "$",
  25.     }
  26.     emp1.displaySalary() //Calling displaySalary() method of Employee type

Run in playgroud

在上面程序中的第 16 行，我们在Employee结构类型上创建了一个方法displaySalary。 displaySalary()方法可以访问其中的接收者e Employee。在第 17 行，我们使用接收者e并打印员工的姓名，币种和工资。

在第 26 行，我们使用语法emp1.displaySalary()调用了该方法，程序打印了，Salary of Sam Adolf is $5000

有了函数为啥还需要方法

我们仅使用函数来重写上面的程序。

  1. package main
  3. import (  
  4.     "fmt"
  5. )
  7. type Employee struct {  
  8.     name     string
  9.     salary   int
  10.     currency string
  11. }
  13. /*
  14.  displaySalary() method converted to function with Employee as parameter
  15. */
  16. func displaySalary(e Employee) {  
  17.     fmt.Printf("Salary of %s is %s%d", e.name, e.currency, e.salary)
  18. }
  20. func main() {  
  21.     emp1 := Employee{
  22.         name:     "Sam Adolf",
  23.         salary:   5000,
  24.         currency: "$",
  25.     }
  26.     displaySalary(emp1)
  27. }

Run in playgroud

在上面的程序中，displaySalary从方法变为函数，Employee结构作为参数传递给它。这个程序也产生完全相同的输出Salary of Sam Adolf is $5000。

那么既然函数能实现一样的功能，为什么还需要方法呢。这有几个原因。让我们逐一看看它们。

  • Go 不是纯粹的面向对象编程语言，它不支持类。因此，类型上的方法是一种实现类似于类的行为的方法。
  • 不同类型上可以定义具有相同名称的方法，而函数则不允许具有相同名称。让我们假设我们有一个Square和Circle结构。可以在Square和Circle上定义名为Area的方法。下面举个例子。
  1. package main
  3. import (  
  4.     "fmt"
  5.     "math"
  6. )
  8. type Rectangle struct {  
  9.     length int
  10.     width  int
  11. }
  13. type Circle struct {  
  14.     radius float64
  15. }
  17. func (r Rectangle) Area() int {  
  18.     return r.length * r.width
  19. }
  21. func (c Circle) Area() float64 {  
  22.     return math.Pi * c.radius * c.radius
  23. }
  25. func main() {  
  26.     r := Rectangle{
  27.         length: 10,
  28.         width:  5,
  29.     }
  30.     fmt.Printf("Area of rectangle %d\n", r.Area())
  31.     c := Circle{
  32.         radius: 12,
  33.     }
  34.     fmt.Printf("Area of circle %f", c.Area())
  35. }

Run in playgroud

程序输出，

  1. Area of rectangle 50  
  2. Area of circle 452.389342

方法的上述属性用到了接口的概念，我们将在下一个教程中讨论接口。

指针接收者 VS 值接收者

到目前为止，我们仅仅看到值接收者的方法。也可以使用指针接收者创建方法。值和指针接收者之间的区别在于，使用指针接收者的方法内部进行的更改对于调用者是可见的，而在值接收者中则不是这种情况。让我们在程序的帮助下理解这一点。

  1. package main
  3. import (  
  4.     "fmt"
  5. )
  7. type Employee struct {  
  8.     name string
  9.     age  int
  10. }
  12. /*
  13. Method with value receiver  
  14. */
  15. func (e Employee) changeName(newName string) {  
  16.     e.name = newName
  17. }
  19. /*
  20. Method with pointer receiver  
  21. */
  22. func (e *Employee) changeAge(newAge int) {  
  23.     e.age = newAge
  24. }
  26. func main() {  
  27.     e := Employee{
  28.         name: "Mark Andrew",
  29.         age:  50,
  30.     }
  31.     fmt.Printf("Employee name before change: %s", e.name)
  32.     e.changeName("Michael Andrew")
  33.     fmt.Printf("\nEmployee name after change: %s", e.name)
  35.     fmt.Printf("\n\nEmployee age before change: %d", e.age)
  36.     (&e).changeAge(51)
  37.     fmt.Printf("\nEmployee age after change: %d", e.age)
  38. }

Run in playgroud

在上面的程序中，changeName方法有一个值接收者(e Employee)，而changeAge方法有一个指针接收者(e * Employee)。对changeName中的Employee结构的名称字段所做的更改将对调用者不可见，因此程序在调用方法e.changeName("Michael Andrew")之前和之后打印相同的名称。由于changeAge方法使用了指针接收者(e * Employee)，因此调用方可以看到方法调用(＆e).changeAge(51)之后对age字段所做的更改。这个程序打印，

  1. Employee name before change: Mark Andrew  
  2. Employee name after change: Mark Andrew
  4. Employee age before change: 50  
  5. Employee age after change: 51

在上面的程序的第 36 行，我们使用(＆e).changeAge(51)来调用changeAge方法。由于changeAge有一个指针接收者，我们使用了(＆e)来调用该方法。这不是必需的，语言为我们提供了使用e.changeAge(51)的选项。 在指针接收者的情况下，使用e.changeAge(51)将被语言解释为(＆e).changeAge(51)。

上述程序，用e.changeAge(51)替换(＆e).changeAge(51)也将输出一样的结果。

  1. package main
  3. import (  
  4.     "fmt"
  5. )
  7. type Employee struct {  
  8.     name string
  9.     age  int
  10. }
  12. /*
  13. Method with value receiver  
  14. */
  15. func (e Employee) changeName(newName string) {  
  16.     e.name = newName
  17. }
  19. /*
  20. Method with pointer receiver  
  21. */
  22. func (e *Employee) changeAge(newAge int) {  
  23.     e.age = newAge
  24. }
  26. func main() {  
  27.     e := Employee{
  28.         name: "Mark Andrew",
  29.         age:  50,
  30.     }
  31.     fmt.Printf("Employee name before change: %s", e.name)
  32.     e.changeName("Michael Andrew")
  33.     fmt.Printf("\nEmployee name after change: %s", e.name)
  35.     fmt.Printf("\n\nEmployee age before change: %d", e.age)
  36.     e.changeAge(51)
  37.     fmt.Printf("\nEmployee age after change: %d", e.age)
  38. }

Run in playgroud

什么时候使用指针接收者&什么时候使用值接收者

通常，当调用者需要对方法所做的修改可见时，可以使用指针接收者。

指针接收者也可用于复制数据结构代价比较高的的地方。考虑一个包含许多字段的结构。使用此结构作为方法中的值接收者将需要复制整个结构，这代价是很高的。在这种情况下，如果使用指针接收者，则不会复制结构，并且只在该方法中使用指向它的指针。

在其他情况下，可以使用值接收者。

匿名字段的方法

可以调用属于结构的匿名字段的方法，就好像它们属于结构定义的一样。

  1. package main
  3. import (  
  4.     "fmt"
  5. )
  7. type address struct {  
  8.     city  string
  9.     state string
  10. }
  12. func (a address) fullAddress() {  
  13.     fmt.Printf("Full address: %s, %s", a.city, a.state)
  14. }
  16. type person struct {  
  17.     firstName string
  18.     lastName  string
  19.     address
  20. }
  22. func main() {  
  23.     p := person{
  24.         firstName: "Elon",
  25.         lastName:  "Musk",
  26.         address: address {
  27.             city:  "Los Angeles",
  28.             state: "California",
  29.         },
  30.     }
  32.     p.fullAddress() //accessing fullAddress method of address struct
  34. }

Run in playgroud

在上面程序的第 32 行，我们使用p.fullAddress()调用address结构的fullAddress()方法。不需要用p.address.fullAddress()显式调用。这个程序打印

  1. Full address: Los Angeles, California

方法中的值接收者 VS 函数的值参数

大多数新手都有这个疑惑，我会尽量让它尽可能清楚?。

当函数有一个值参数时，它只接受一个值参数。

当方法具有值接收者时，它将接受指针接受者和值接收者。

按惯例，上代码，

  1. package main
  3. import (  
  4.     "fmt"
  5. )
  7. type rectangle struct {  
  8.     length int
  9.     width  int
  10. }
  12. func area(r rectangle) {  
  13.     fmt.Printf("Area Function result: %d\n", (r.length * r.width))
  14. }
  16. func (r rectangle) area() {  
  17.     fmt.Printf("Area Method result: %d\n", (r.length * r.width))
  18. }
  20. func main() {  
  21.     r := rectangle{
  22.         length: 10,
  23.         width:  5,
  24.     }
  25.     area(r)
  26.     r.area()
  28.     p := &r
  29.     /*
  30.        compilation error, cannot use p (type *rectangle) as type rectangle 
  31.        in argument to area  
  32.     */
  33.     //area(p)
  35.     p.area()//calling value receiver with a pointer
  36. }

Run in playgroud

第 12 行中的函数func area(r rectangle)接受值参数，方法func(r rectangle) area()接受值接收者。

第 25 行，我们使用值参数area(r)调用 area 函数。类似地，我们使用值接收者调用 area 方法r.area()。

我们在第 28 行创建一个指针p指向r。在第 33 行，如果我们尝试将此指针传递给只接受值的函数 area，编译器将会报错，如果取消注释该行，则编译器将抛出编译错误compilation error, cannot use p (type *rectangle) as type rectangle in argument to area

现在是棘手的部分，在第 35 行中，代码p.area()中使用指针接收者p调用值接受者的方法 area，这完全有效。因为 area 有一个值接收者，为方便起见，Go 会把p.area()解析成(* p).area()。

程序会输出，

  1. Area Function result: 50  
  2. Area Method result: 50  
  3. Area Method result: 50

方法中的指针接收者 VS 函数的指针参数

与值参数类似，具有指针参数的函数将仅接受指针，而具有指针接收者的方法将接受值和指针接收者。

  1. package main
  3. import (  
  4.     "fmt"
  5. )
  7. type rectangle struct {  
  8.     length int
  9.     width  int
  10. }
  12. func perimeter(r *rectangle) {  
  13.     fmt.Println("perimeter function output:", 2*(r.length+r.width))
  15. }
  17. func (r *rectangle) perimeter() {  
  18.     fmt.Println("perimeter method output:", 2*(r.length+r.width))
  19. }
  21. func main() {  
  22.     r := rectangle{
  23.         length: 10,
  24.         width:  5,
  25.     }
  26.     p := &r //pointer to r
  27.     perimeter(p)
  28.     p.perimeter()
  30.     /*
  31.         cannot use r (type rectangle) as type *rectangle in argument to perimeter
  32.     */
  33.     //perimeter(r)
  35.     r.perimeter()//calling pointer receiver with a value
  37. }

Run in playgroud

在上述程序中的第 12 行，定义了一个函数perimeter，它接受一个指针参数，在第 17 行，定义了一种具有指针接收者的方法。

在第 27 行，我们用指针参数调用perimeter函数。在第 28 行，我们用指针接受者调用perimeter方法。

在注释行第 33 行中，我们尝试使用值参数r调用perimeter函数。这是不被允许的，因为带有指针参数的函数不接受值参数。如果取消该注释并且程序运行，编译将失败，错误为main.go:33: cannot use r (type rectangle) as type *rectangle in argument to perimeter.

在第 35 行中，我们使用值接收者r调用指针接收者的perimeter方法。这是允许的，为了方便，代码行r.perimeter()将被语言解释为(＆r).perimeter()。该程序将输出，

  1. perimeter function output: 30  
  2. perimeter method output: 30  
  3. perimeter method output: 30

非结构类型的方法

到目前为止，我们只在结构类型上定义了方法，也可以在非结构类型上定义方法。但是有一个需要注意，要在类型上定义方法，方法的接收者类型的定义和方法的定义应该在同一个包中。到目前为止，我们定义的结构上的所有结构和方法都位于同一包中，因此它们有效。

  1. package main
  3. func (a int) add(b int) {  
  4. }
  6. func main() {
  8. }

Run in playgroud

在上面的程序中的第 3 行，我们试图在内置类型int中添加一个名为add的方法。这是不允许的，因为方法add的定义和int类型的定义不在同一个包中。这个程序会抛出编译错误cannot define new methods on non-local type int

让该段代码正确运行方法是为内置类型int创建类型别名，然后创建一个使用此类型别名作为接收者的方法。

  1. package main
  3. import "fmt"
  5. type myInt int
  7. func (a myInt) add(b myInt) myInt {  
  8.     return a + b
  9. }
  11. func main() {  
  12.     num1 := myInt(5)
  13.     num2 := myInt(10)
  14.     sum := num1.add(num2)
  15.     fmt.Println("Sum is", sum)
  16. }

Run in playgroud

在上面程序的第 5 行中，我们为int创建了一个类型别名myInt。然后在第 7 行，我们定义了一个用myInt作为接收者的方法add。

程序将输出Sum is 15.

ft_authoradmin  ft_create_time2019-08-03 16:35
 ft_update_time2019-08-03 16:36