goLang中数组-切片-map等值的传递方式

• 新手常常被golang中的值传递和指针传递而搞的很困惑。
  这里总结一下，其实只要把握两点。

1. golang默认都是采用值传递，即拷贝传递
2. 有些值天生就是指针

值传递和引用传递

talk is cheap, 用代码说话。最简单的传进去一个字符串

func changeAString(s string){
	s = "new string"
	}
func main(){
	var a = "string"
	changeAString(a)
	fmt.Println(a)//还是string
	}

很显然，这是值传递，局部变量不改变外部变量。复杂一点，来个数组。

func changeArray(a [3]int){
	a[0] = 12
	}
	
func main(){
	var a = [3]int{1, 2, 3}
	changeArray(a)
	fmt.Println(a)//还是1,2,3
	}

还是值传递，所以说，golang里都是值传递，只是有些类型，天生就是指针而已。我说的就是slice, map, channel 这些语言内构的类型。

func main() {
	// 测试数组的传递方式
	arr := [3]int{1, 2, 3}

	change(arr)
	fmt.Println(arr) // 1,2,3

	changeBySlice(arr[:])
	fmt.Println(arr) //10,2,3

	changeByPoint(&arr)
	fmt.Println(arr) //20,2,3
}

// 值传递
func change(a [3]int) {
	a[0] = 10
}

//slice 是个复合对象，虽然是值传递，但是拷贝值里指针指向的是同一个数组
func changeBySlice(a []int) {
	a[0] = 10

}

// 传指针，这个没啥好说的
func changeByPoint(a *[3]int) {
	(*a)[0] = 20
}

这个例子印证了以上的说法。

学习者有必要了解一下这几个类型的底层是怎么样的，翻源代码(都在 $GOROOT/src/runtime下面)，其实都是结构体，里面保存着指向底层数据结构的指针。map是个hash table, chan复杂一些,这里只介绍slice。

slice底层是一个结构体

type slice struct{
		array unsafe.Point   //底层数组的指针
		len int
		cap int
}

其中len是slice中存有数据的大小，cap是底层数组的大小。

当做切片操作时，引用的是源slice的底层数组，只有在做append操作时如果超过了cap，就会自动分配一个新的底层数组，cap大小是原cap的两倍。

func main() {
	// 测试分片复制时会发生什么
	raw := make([]int, 7, 10)
	fmt.Printf("raw is %v,%p,%v, %d\n", raw, &raw, len(raw), cap(raw))
	foo := raw[:6]

	foo = append(foo, -1)
	fmt.Printf("raw is %v,%p,%v, %d\n", raw, &raw, len(raw), cap(raw))
	fmt.Printf("foo is %v,%p,%v, %d\n", foo, &foo, len(foo), cap(foo))

	foo = append(foo, -2)
	fmt.Printf("raw is %v,%p,%v, %d\n", raw, &raw, len(raw), cap(raw))
	fmt.Printf("foo is %v,%p,%v, %d\n", foo, &foo, len(foo), cap(foo))
	// 结果： 如果切片的大小
}
//output:
raw is [0 0 0 0 0 0 0],0xc00000a0e0,7, 10
raw is [0 0 0 0 0 0 -1],0xc00000a0e0,7, 10
foo is [0 0 0 0 0 0 -1],0xc00000a120,7, 10
raw is [0 0 0 0 0 0 -1],0xc00000a0e0,7, 10
foo is [0 0 0 0 0 0 -1 -2],0xc00000a120,8, 10

第一次的append改变了raw很正常，因为a和 raw公用一个底层数组，这里的奇怪之处在于， 为什么第二次append的时候raw没有变化？

其实答案很简单，第二次append的时候底层数组中的 -1 后面确实加上了 -2这个值，只是因为raw的观测长度为7没有变，所以没有显示全貌。

如果把最后一个append改成 raw:=append(a, -2), 那么在底层数组后边加上-2之外， raw （slice结构体）的len 也要加1， 观测长度变为 8 , 那结果就改变了。

raw := append(a, -2)

//output:
raw is [0 0 0 0 0 0 0],0xc00000a0e0,7, 10

raw is [0 0 0 0 0 0 -1],0xc00000a0e0,7, 10
foo is [0 0 0 0 0 0 -1],0xc00000a120,7, 10
raw is [0 0 0 0 0 0 -1 -2],0xc00000a0e0,8, 10
foo is [0 0 0 0 0 0 -1],0xc00000a120,7, 10

其实只要把slice理解成，从某个指针开始数，往后数几个，这样的函数就很好理解了。

golang提供了一种强制性创建新底层数组的拷贝方法，copy函数

	a := make([]int, 3)
	copy(a, raw[:4]

对a的任何更改或扩容都不会影响源raw ，因为它已经不引用源底层数组了。

那么所谓的值接收者和引用接收者又是什么意思呢？

func(foo) change(){}和func(*foo) change(){}有什么区别

其实很简单，你把它看成是 func change(foo, …args)和 func(*foo, …args)就行了。

只有指针接收者定义的函数能真正改变值的内容。

type foo struct {
	num int
	key *string
	bar map[string]string
}

func (f foo) changeKey() {
	f.num = 2
	*(f.key) = "new Key"
	f.bar["name"] = "yang"

}
func (f *foo) changeKeyByPoint() {
	f.num = 3
	*(f.key) = "new Key by Point"
	f.bar["name"] = "li"

}
func main() {
	str := "hello"
	a := foo{1, &str, make(map[string]string)}
	
	fmt.Printf("num: %d, key: %s, bar: %v\n", a.num, *a.key, a.bar)
	
	a.changeKey()
	fmt.Printf("num: %d, key: %s, bar: %v\n", a.num, *a.key, a.bar)

	a.changeKeyByPoint()
	fmt.Printf("num: %d, key: %s, bar: %v\n", a.num, *a.key, a.bar)

}
	\\output:
	num: 1, key: hello, bar: map[]
	num: 1, key: new Key, bar: map[name:yang]
	num: 3, key: new Key by Point, bar: map[name:li]

changeKey函数是值接收者， 改变的是副本中的num，所以num没有变，而key是一个指针，当然可以改变它指向的值的值。
那为什么bar中的值变了呢，还是上面说的第一条，Map天生就是一个指针（严格来说是包括一个指针的结构），虽然传进去的是一个副本，但是这个副本指向的位置和原来的值是一样的，所以能改变map里的值。

而changeKeyByPoint函数是一个指针接收者，它所做的修改，包括num，都是在原值上进行的。这个我以前有篇文章专门写这个。