方法

本文我们讲述方法。

简介

在func关键字和方法名之间存在接收者类型的那些函数，我们称之为方法。接收者可以是结构体类型，也可以是非结构体类型。

方法声明的语法，如下：

func (t Type) methodName(parameter list) {

}

上面这个代码片，就是声明了一个名为methodName的方法，它的接收者类型是Type。t被称为接收者，在方法内部可以访问接收者t。

样本方法

我们来写一段程序，此程序在结构体类型的上面创建了一个方法，并且调用此方法。

package main

import (
    "fmt"
)

type Employee struct {
    name     string
    salary   int
    currency string
}

/*
 displaySalary() method has Employee as the receiver type
*/
func (e Employee) displaySalary() {
    fmt.Printf("Salary of %s is %s%d", e.name, e.currency, e.salary)
}

func main() {
    emp1 := Employee {
        name:     "Sam Adolf",
        salary:   5000,
        currency: "$",
    }
    emp1.displaySalary() //Calling displaySalary() method of Employee type
}

在上面的程序中，我们在Employee结构体上创建了一个displaySalary方法。displaySalary()方法访问了接收者e,同时使用接收者e打印出了name、currency、salary。我们使用了语法 emp1.displaySalary()语法调用了此方法。程序的输出为：Salary of Sam Adolf is $5000。

方法 VS 函数

上面的程序，也可以用函数重写，完全可以不用方法。

package main

import (
    "fmt"
)

type Employee struct {
    name     string
    salary   int
    currency string
}

/*
 displaySalary() method converted to function with Employee as parameter
*/
func displaySalary(e Employee) {
    fmt.Printf("Salary of %s is %s%d", e.name, e.currency, e.salary)
}

func main() {
    emp1 := Employee{
        name:     "Sam Adolf",
        salary:   5000,
        currency: "$",
    }
    displaySalary(emp1)
}

上面的程序，把displaySalary方法改成了一个函数，这个函数接收了一个Employee结构体作为参数，同时这个函数也和displaySalary产生了相同的输出。Salary of Sam Adolf is $5000。

那么，既然我们可以使用函数来完成和方法完全相同的工作，我们为什么还要方法呢？这样做有很多理由，我们来一个个看看这些理由是什么。

. Go并不是一个纯粹的面向对象的语言，它不支持类。因此，方法是实现和类相似的一种方式。我们可以为类型创建一组方法。
在上面的程序中，和Employee类相关的所有行为都可以用Employee做为接收者类型来创建方法。例如，我们可以创建方法： calculatePension、calculateLeaves等等。

. 具有相同名称的方法可以定义在不同的类型上。我们假定有俩个结构体：Square和Circle。那么我们可以在Square和Circle上都创建一个名为Area的方法。

可以看下面的程序。

package main

import (
    "fmt"
    "math"
)

type Rectangle struct {
    length int
    width  int
}

type Circle struct {
    radius float64
}

func (r Rectangle) Area() int {
    return r.length * r.width
}

func (c Circle) Area() float64 {
    return math.Pi * c.radius * c.radius
}

func main() {
    r := Rectangle{
        length: 10,
        width:  5,
    }
    fmt.Printf("Area of rectangle %d\n", r.Area())
    c := Circle{
        radius: 12,
    }
    fmt.Printf("Area of circle %f", c.Area())
}

程序的输出如下：

Area of rectangle 50
Area of circle 452.389342

上面这些方法的特性可用于实现接口。我们将在下一篇教程中详细讨论接口。

指针接收者 VS 值接收者

到目前为止，我们已经了解了拥有值接收者的方法，除此之外，我们还可以创建带有指针接收者的方法。值接收者和指针接收者之间的不同之处在于：对带有指针接收者的方法做出的修改对调用者来说是可见的。而值接收者却并非这样。我们用下面这个程序来理解一下。

package main

import (
    "fmt"
)

type Employee struct {
    name string
    age  int
}

/*
Method with value receiver
*/
func (e Employee) changeName(newName string) {
    e.name = newName
}

/*
Method with pointer receiver
*/
func (e *Employee) changeAge(newAge int) {
    e.age = newAge
}

func main() {
    e := Employee{
        name: "Mark Andrew",
        age:  50,
    }
    fmt.Printf("Employee name before change: %s", e.name)
    e.changeName("Michael Andrew")
    fmt.Printf("\nEmployee name after change: %s", e.name)

    fmt.Printf("\n\nEmployee age before change: %d", e.age)
    (&e).changeAge(51)
    fmt.Printf("\nEmployee age after change: %d", e.age)
}

在上面的程序中，changeName方法有一个值接收者(e Employee)而changeAge方法有一个指针接收者(e *Employee)。在changeName中对Employee结构体的name字段做出的修改对其调用者来说是不可见的。因此，在方法e.changeName("Michael Andrew")调用的前后打印的name值都是相同的。
而changeAge方法有一个指针接收者(e *Employee),在函数调用(&e).changAge(51)之后，对age字段的修改对其调用者来说是可见的。
程序的输出如下：

Employee name before change: Mark Andrew
Employee name after change: Mark Andrew

Employee age before change: 50
Employee age after change: 51

在上面的程序中，我们使用(&e).changeAge(51)来调用changeAge()方法。由于changeAge有一个指针接收者，我们使用(&e)来调用此方法，但是不必要这样调用，Go为我们提供了另一个选择，我们可以使用e.changAge(51)来调用。e.changeAge(51)将要被解释为(&e).changeAge(51)。

我们重写上面的程序，使用e.changeAge(51)来替换(&e).changeAge(51)，它打印的是相同的输出。

package main

import (
    "fmt"
)

type Employee struct {
    name string
    age  int
}

/*
Method with value receiver
*/
func (e Employee) changeName(newName string) {
    e.name = newName
}

/*
Method with pointer receiver
*/
func (e *Employee) changeAge(newAge int) {
    e.age = newAge
}

func main() {
    e := Employee{
        name: "Mark Andrew",
        age:  50,
    }
    fmt.Printf("Employee name before change: %s", e.name)
    e.changeName("Michael Andrew")
    fmt.Printf("\nEmployee name after change: %s", e.name)

    fmt.Printf("\n\nEmployee age before change: %d", e.age)
    e.changeAge(51)
    fmt.Printf("\nEmployee age after change: %d", e.age)
}

什么时候使用指针接收，什么时候使用值接收

通常来说，当对接收者做出的修改需要对调用者可见时，就使用指针接收者。此外，在某些复制数据结构体代价比较大时，也可以使用指针接收者。
设想一下，如果某个结构体有许多字段，那么使用此结构体作为值接收者的话，就需要复制全部的结构体，而这样复制的操作是非常昂贵的。
在这种情况下，如果使用指针接收者的话，就不需要复制结构体，只需要一个指针即可。在其他场景中，可以使用值接收者。

匿名结构体字段的方法

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

package main

import (
    "fmt"
)

type address struct {
    city  string
    state string
}

func (a address) fullAddress() {
    fmt.Printf("Full address: %s, %s", a.city, a.state)
}

type person struct {
    firstName string
    lastName  string
    address
}

func main() {
    p := person{
        firstName: "Elon",
        lastName:  "Musk",
        address: address {
            city:  "Los Angeles",
            state: "California",
        },
    }

    p.fullAddress() //accessing fullAddress method of address struct

}

在上面的程序中，我们使用p.fullAddress()调用了address结构体的fullAddress方法。没必要使用p.address.fullAddress()来调用，它们的输出是一样的。

Full address: Los Angeles, California

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

这个话题主要是针对初学者，因此，我会尽可能讲解的更清楚。

若函数只有一个值参的话，那么它只能接收一个值参。但若方法有一个值接收者的话，它可以同时接收指针和值接收者。

我们用一个案例来理解这一点。

package main

import (
    "fmt"
)

type rectangle struct {
    length int
    width  int
}

func area(r rectangle) {
    fmt.Printf("Area Function result: %d\n", (r.length * r.width))
}

func (r rectangle) area() {
    fmt.Printf("Area Method result: %d\n", (r.length * r.width))
}

func main() {
    r := rectangle{
        length: 10,
        width:  5,
    }
    area(r)
    r.area()

    p := &r
    /*
       compilation error, cannot use p (type *rectangle) as type rectangle
       in argument to area
    */
    //area(p)

    p.area()//calling value receiver with a pointer
}

函数func area(r rectangle)接收一个值参，同时方法func (r rectangle) area()接收了一个值接收者。当我们用area(r)调用这个函数时，它可以正常运行，相似地，我们使用值接收者调用方法r.area()时，它也可以正常运行。

在程序中，我们还创建了一个指向r的指针。如果把这个指针传递给函数area的话，编译器会报错compilation error, cannot use p (type *rectangle) as type rectangle in argument to area。

现在我们来看最棘手的部分，程序中代码p.area()使用指针接收者p调用了方法area，而方法area是只接受值接收者的。但是这样却没问题，原因是p.area()会被Go解释为(*p).area()
。
程序将输出如下：

Area Function result: 50
Area Method result: 50
Area Method result: 50

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

和值参数类似，指针参数的函数只能接收指针。然而 指针接收者的方法却可以同时接收指针和值接收者。

package main

import (
    "fmt"
)

type rectangle struct {
    length int
    width  int
}

func perimeter(r *rectangle) {
    fmt.Println("perimeter function output:", 2*(r.length+r.width))

}

func (r *rectangle) perimeter() {
    fmt.Println("perimeter method output:", 2*(r.length+r.width))
}

func main() {
    r := rectangle{
        length: 10,
        width:  5,
    }
    p := &r //pointer to r
    perimeter(p)
    p.perimeter()

    /*
        cannot use r (type rectangle) as type *rectangle in argument to perimeter
    */
    //perimeter(r)

    r.perimeter()//calling pointer receiver with a value

}

在上面的程序中，定义了一个函数perimeter,它接收指针参数。定义了一个方法perimeter,它接收指针接收者。
当我们使用传递值参给函数perimeter时，编译器是不允许的。因为指针参数的函数不能接收值参。
而当我们用一个值接收者r调用方法perimeter的时候，却没问题。代码r.perimeter()会被编译器解释为(&r).perimeter()。
程序的输出如下：

perimeter function output: 30
perimeter method output: 30
perimeter method output: 30

非结构体接收者的函数

到目前为止，我们都是在结构体类型上定义方法。但其实，在非结构体类型上，也能定义方法。但是有个限制是，在类型上定义方法时，接收者的定义和方法定义必须在同一个包下。我们现在都是在main包下面定义的，因此，他们都没问题。

package main

func (a int) add(b int) {
}

func main() {

}

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

那么怎么解决这个问题呢？我们可以为内置类型int创建一个类型别名，然后用这个类型别名作为接收者来创建一个方法。

package main

import "fmt"

type myInt int

func (a myInt) add(b myInt) myInt {
    return a + b
}

func main() {
    num1 := myInt(5)
    num2 := myInt(10)
    sum := num1.add(num2)
    fmt.Println("Sum is", sum)
}

在上面的程序中，我们为int创建了一个类型别名myInt，然后我们定义了一个以myInt作为接收者的add方法。
程序将输出：Sum is 15 。

上述这些就是Go中的方法，祝您愉快！

本篇系翻译之作，原文地址