「这是我参与2022首次更文挑战的第14天，活动详情查看：2022首次更文挑战」
Slice 也是值传递么？
看个例子吧:
func TestSliceReference(t *testing.T) {
var args = []int64{1,2,3}
fmt.Printf("切片args的地址： %p\n",args)
modifiedNumber3(args)
fmt.Println(args)
}
func modifiedNumber3(args []int64) {
fmt.Printf("形参切片的地址 %p \n",args)
args[0] = 10
}
运行结果：
=== RUN TestSliceReference
切片args的地址： 0xc000016120
形参切片的地址 0xc000016120
[10 2 3]
--- PASS: TestSliceReference (0.00s)
PASS
发现没有，切片的地址和形参的地址为啥一样， 难道也问题？ 不是值传递？上面可以看到，我们并没有用取址符 & 来进行地址转换，就把 slice 打印出来来，再测试一下:
func TestSliceReference2(t *testing.T) {
var args = []int64{1,2,3}
fmt.Printf("切片args的地址： %p \n",args)
fmt.Printf("切片args第一个元素的地址： %p \n",&args[0])
fmt.Printf("直接对切片args取地址%v \n",&args)
modifiedNumber4(args)
fmt.Println(args)
}
func modifiedNumber4(args []int64) {
fmt.Printf("形参切片的地址 %p \n",args)
fmt.Printf("形参切片args第一个元素的地址： %p \n",&args[0])
fmt.Printf("直接对形参切片args取地址%v \n",&args)
args[0] = 10
}
运行结果
=== RUN TestSliceReference2
切片args的地址： 0xc0000ee030
切片args第一个元素的地址： 0xc0000ee030
直接对切片args取地址&[1 2 3]
形参切片的地址 0xc0000ee030
形参切片args第一个元素的地址： 0xc0000ee030
直接对形参切片args取地址&[1 2 3]
[10 2 3]
--- PASS: TestSliceReference2 (0.00s)
PASS
可以看到的是 使用 & 地址符进行取址是无效的，而且使用 %p 取出的地址是和第一个元素地址是一样的。为啥这样？ 看 fmt.Printf 源码
fmt包,print.go中的printValue这个方法,截取重点部分，因为`slice`也是引用类型，所以会进入这个`case`：
case reflect.Ptr:
// pointer to array or slice or struct? ok at top level
// but not embedded (avoid loops)
if depth == 0 && f.Pointer() != 0 {
switch a := f.Elem(); a.Kind() {
case reflect.Array, reflect.Slice, reflect.Struct, reflect.Map:
p.buf.writeByte('&')
p.printValue(a, verb, depth+1)
return
}
}
fallthrough
case reflect.Chan, reflect.Func, reflect.UnsafePointer:
p.fmtPointer(f, verb)
可以看到 p.buf.writeByte('&') 这个代码打印地址输出结果带有 & , 这个就是为啥
fmt.Printf("切片args的地址： %p \n",args)
打印出来的是一个地址 0xc0000ee030。
为啥打印出来的切片中还会包含 "[]" 呢?
看下 printValue 源码：
case reflect.Array, reflect.Slice:
//省略部分代码
} else {
p.buf.writeByte('[')
for i := 0; i < f.Len(); i++ {
if i > 0 {
p.buf.writeByte(' ')
}
p.printValue(f.Index(i), verb, depth+1)
}
p.buf.writeByte(']')
}
因为递归调用了 p.printValue(a, verb, depth+1) 进行打印， 这个就是为啥
fmt.Printf("直接对切片args取地址%v \n",&args)
输出直接对切片args取地址
&[1 2 3]
还有个问题， 为啥 %p 输出的内存地址 和 slice 结构里面第一个元素的地址是一样的呢？
func (p *pp) fmtPointer(value reflect.Value, verb rune) {
var u uintptr
switch value.Kind() {
case reflect.Chan, reflect.Func, reflect.Map, reflect.Ptr, reflect.Slice, reflect.UnsafePointer:
u = value.Pointer()
default:
p.badVerb(verb)
return
}
...... 省略部分代码
// If v's Kind is Slice, the returned pointer is to the first
// element of the slice. If the slice is nil the returned value
// is 0. If the slice is empty but non-nil the return value is non-zero.
func (v Value) Pointer() uintptr {
// TODO: deprecate
k := v.kind()
switch k {
case Chan, Map, Ptr, UnsafePointer:
return uintptr(v.pointer())
case Func:
if v.flag&flagMethod != 0 {
....... 省略部分代码
上面有一句话，If v’s Kind is Slice, the returned pointer is to the first。意思是对于 slice 类型，返回的是元素第一个元素的地址，这里正好解释上面为什么 fmt.Printf("切片args的地址： %p \n",args)和fmt.Printf("形参切片的地址 %p \n",args)打印出来的地址是一样的，因为args是引用类型，所以他们都返回slice这个结构里的第一个元素的地址。
Slice 的结构
//runtime/slice.go
type slice struct {
array unsafe.Pointer
len int
cap int
}
slice 是一个结构体， 第一个元素是指针类型，这个指针指向的是底层数组的第一个指针。所以当 slice 类型的时候， fmt.Printlnf() d打印的是第一个元素的地址。其实也是指针处理，只不过指针的存放的内容是第一个元素的内存地址，但是这个指针的在传递过程中是会拷贝的。
slice 其实也是值传递，为啥引用类型传递可以修改原内容的数据， 因为底层默认传递的指向第一个元素地址的指针。容易混淆的是 fmt.printf() 打印的是第一个这个传递指针对应的内容，而不是存储指针的地址，会给人一种错觉，以为是引用传递。
map 是值传递么？
map 没有明显的指针
func TestMapReference(t *testing.T) {
persons:=make(map[string]int)
persons["asong"]=8
addr:=&persons
fmt.Printf("原始map的内存地址是：%p\n",addr)
modifiedAge(persons)
fmt.Println("map值被修改了，新值为:",persons)
}
func modifiedAge(person map[string]int) {
fmt.Printf("函数里接收到map的内存地址是：%p\n",&person)
person["asong"]=9
}
运行结果：
=== RUN TestMapReference
原始map的内存地址是：0xc00000e038
函数里接收到map的内存地址是：0xc00000e040
map值被修改了，新值为: map[asong:9]
--- PASS: TestMapReference (0.00s)
PASS
接着看一下 map 源码
//src/runtime/map.go
// makemap implements Go map creation for make(map[k]v, hint).
// If the compiler has determined that the map or the first bucket
// can be created on the stack, h and/or bucket may be non-nil.
// If h != nil, the map can be created directly in h.
// If h.buckets != nil, bucket pointed to can be used as the first bucket.
func makemap(t *maptype, hint int, h *hmap) *hmap {
mem, overflow := math.MulUintptr(uintptr(hint), t.bucket.size)
if overflow || mem > maxAlloc {
hint = 0
}
// initialize Hmap
if h == nil {
h = new(hmap)
}
h.hash0 = fastrand()
map 使用 make 函数返回的是一个 hmap 类型的指针，func modifiedAge(persons map[string]int) 其实和 func modifiedAge(person *hmap) 意思是一样的，这样实际上传递也是使用了指针的副本进行传递， 属于值传递， map 也是引用类型，但是传递的类型不是引用，也是值传递，传递的是指针的拷贝。
chan 是值传递么
func TestChanReferencr(t *testing.T) {
p := make(chan bool)
fmt.Printf("原始chan的内存地址是：%p\n", &p)
go func(p chan bool) {
fmt.Printf("函数里接收到chan的内存地址是：%p\n", &p)
//模拟耗时
time.Sleep(2 * time.Second)
p <- true
}(p)
select {
case l := <-p:
fmt.Println(l)
}
}
运行结果
=== RUN TestChanReferencr
原始chan的内存地址是：0xc000120028
函数里接收到chan的内存地址是：0xc000120030
true
--- PASS: TestChanReferencr (2.00s)
PASS
看到实参和形参地址返回的是不一样的，chan 的底层实现
// src/runtime/chan.go
func makechan(t *chantype, size int) *hchan {
elem := t.elem
// compiler checks this but be safe.
if elem.size >= 1<<16 {
throw("makechan: invalid channel element type")
}
if hchanSize%maxAlign != 0 || elem.align > maxAlign {
throw("makechan: bad alignment")
}
mem, overflow := math.MulUintptr(elem.size, uintptr(size))
if overflow || mem > maxAlloc-hchanSize || size < 0 {
panic(plainError("makechan: size out of range"))
}
其实可以看到 和 map 有点类型，通过 mak 函数，返回的也是一个 hchan 类型的指针，实际上在操作中，传递的是指针的副本。属于值传递。
struct 是值传递么？
看个例子
type Persons struct {
Name string
Age int64
}
func TestStructRerence(t *testing.T) {
per := Persons{
Name: "asong",
Age: int64(8),
}
fmt.Printf("原始struct地址是：%p\n", &per)
modifiedAge2(per)
fmt.Println(per)
}
func modifiedAge2(per Persons) {
fmt.Printf("函数里接收到struct的内存地址是：%p\n", &per)
per.Age = 10
}
运行结果：
=== RUN TestStructRerence
原始struct地址是：0xc00000c048
函数里接收到struct的内存地址是：0xc00000c060
{asong 8}
--- PASS: TestStructRerence (0.00s)
PASS
可以看到 struct 就是值传递， 没有指针发现没？ 当你修改指为10 的时候，发现没有修改成功，原来 struct 中 Age 值，还是 8
总结
Go 语言中的参数传递都是值传递，虽然 Go 语言中都是值传递，但我们还是可以修改原参数中的内容的，因此传递的参数是引用类型。
