方法

方法与函数的区别在于，方法拥有接收者，而函数没有，且只有自定义类型能够拥有方法。先来看一个例子。

type IntSlice []int

func (i IntSlice) Get(index int) int {
	return i[index]
}
func (i IntSlice) Set(index, val int) {
	i[index] = val
}

func (i IntSlice) Len() int {
	return len(i)
}

先声明了一个类型IntSlice，其底层类型为[]int，再声明了三个方法Get，Set和Len，方法的长相与函数并无太大的区别，只是多了一小段(i IntSlice) 。i就是接收者，IntSlice就是接收者的类型，接收者就类似于其他语言中的this或self，只不过在Go中需要显示的指明。

func main() {
   var intSlice IntSlice
   intSlice = []int{1, 2, 3, 4, 5}
   fmt.Println(intSlice.Get(0))
   intSlice.Set(0, 2)
   fmt.Println(intSlice)
   fmt.Println(intSlice.Len())
}

方法的使用就类似于调用一个类的成员方法，先声明，再初始化，再调用。

值接收者

接收者也分两种类型，值接收者和指针接收者，先看一个例子

type MyInt int

func (i MyInt) Set(val int) {
   i = MyInt(val) // 修改了，但是不会造成任何影响
}

func main() {
   myInt := MyInt(1)
   myInt.Set(2)
   fmt.Println(myInt)
}

上述代码运行过后，会发现myInt的值依旧是1，并没有被修改成2。方法在被调用时，会将接收者的值传入方法中，上例的接收者就是一个值接收者，可以简单的看成一个形参，而修改一个形参的值，并不会对方法外的值造成任何影响，那么如果通过指针调用会如何呢？

func main() {
	myInt := MyInt(1)
	(&myInt).Set(2)
	fmt.Println(myInt)
}

遗憾的是，这样的代码依旧不能修改内部的值，为了能够匹配上接收者的类型，Go会将其解引用，解释为(*(&myInt)).Set(2)。

指针接收者

稍微修改了一下，就能正常修改myInt的值。

type MyInt int

func (i *MyInt) Set(val int) {
   *i = MyInt(val)
}

func main() {
   myInt := MyInt(1)
   myInt.Set(2)
   fmt.Println(myInt)
}

现在的接收者就是一个指针接收者，虽然myInt是一个值类型，在通过值类型调用指针接收者的方法时，Go会将其解释为(&myint).Set(2)。所以方法的接收者为指针时，不管调用者是不是指针，都可以修改内部的值。

函数的参数传递过程中，是值拷贝的，如果传递的是一个整型，那就拷贝这个整型，如果是一个切片，那就拷贝这个切片，但如果是一个指针，就只需要拷贝这个指针，显然传递一个指针比起传递一个切片所消耗的资源更小，接收者也不例外，值接收者和指针接收者也是同样的道理。在大多数情况下，都推荐使用指针接收者，不过两者并不应该混合使用，要么都用，要么就都不用，看下面一个例子。

提示

需要先了解接口

type Animal interface {
   Run()
}

type Dog struct {
}

func (d *Dog) Run() {
   fmt.Println("Run")
}

func main() {
   var an Animal
   an = Dog{}
   // an = &Dog{} 正确方式
   an.Run()
}

这一段代码将会无法通过编译，编译器将会输出如下错误

cannot use Dog{} (value of type Dog) as type Animal in assignment:
	Dog does not implement Animal (Run method has pointer receiver)

翻译过来就是，无法使用Dog{}初始化Animal类型的变量，因为Dog没有实现Animal ，解决办法有两种，一是将指针接收者改为值接收者，二是将Dog{}改为&Dog{}，接下来逐个讲解。

type Dog struct {
}

func (d Dog) Run() { // 改为了值接收者
   fmt.Println("Run")
}

func main() { // 可以正常运行
   var an Animal
   an = Dog{}
   // an = &Dog{} 同样可以
   an.Run()
}

在原来的代码中，Run 方法的接收者是*Dog ，自然而然实现Animal接口的就是Dog指针，而不是Dog结构体，这是两个不同的类型，所以编译器就会认为Dog{}并不是Animal的实现，因此无法赋值给变量an，所以第二种解决办法就是赋值Dog指针给变量an。不过在使用值接收者时，Dog指针依然可以正常赋值给animal，这是因为Go会在适当情况下对指针进行解引用，因为通过指针可以找到Dog结构体，但是反过来的话，无法通过Dog结构体找到Dog指针。如果单纯的在结构体中混用值接收者和指针接收者的话无伤大雅，但是和接口一起使用后，就会出现错误，倒不如无论何时要么都用值接收者，要么就都用指针接收者，形成一个良好的规范，也可以减少后续维护的负担。

还有一种情况，就是当值接收者是可寻址的时候，Go会自动的插入指针运算符来进行调用，例如切片是可寻址，依旧可以通过值接收者来修改其内部值。比如下面这个代码

type Slice []int

func (s Slice) Set(i int, v int) {
	s[i] = v
}

func main() {
	s := make(Slice, 1)
	s.Set(0, 1)
	fmt.Println(s)
}

输出

[1]

但这样会引发另一个问题，如果对其添加元素的话，情况就不同了。看下面的例子

type Slice []int

func (s Slice) Set(i int, v int) {
	s[i] = v
}

func (s Slice) Append(a int) {
	s = append(s, a)
}

func main() {
	s := make(Slice, 1, 2)
	s.Set(0, 1)
	s.Append(2)
	fmt.Println(s)
}

[1]

它的输出还是和之前一样，append函数是有返回值的，向切片添加完元素后必须覆盖原切片，尤其是在扩容后，在方法中对值接收者修改并不会产生任何影响，这也就导致了例子中的结果，改成指针接收者就正常了。

type Slice []int

func (s *Slice) Set(i int, v int) {
	(*s)[i] = v
}

func (s *Slice) Append(a int) {
	*s = append(*s, a)
}

func main() {
	s := make(Slice, 1, 2)
	s.Set(0, 1)
	s.Append(2)
	fmt.Println(s)
}

输出

[1 2]