通过append之后得到的切片更改元素值到底对原切片有没有影响？

slice原理我们之前看过一篇文章：
https://www.jianshu.com/p/843aa553b461
问题代码，求a与b的值

package main

import (
	"fmt"
)

func main() {
    var a = make([]int, 0, 10)
	a=append(a,1,2)
	b:=append(a,3)
	b[0] = 99
	fmt.Println(a)
	fmt.Println(b)
}

答案：

[99 2]
[99 2 3]

问题来了：通过append之后得到的切片更改元素值到底对原切片有没有影响？为什么？
为了搞懂它我们测试了一下，并且加了注释方便大家深入理解。

package main

import (
	"fmt"
	"reflect"
	"unsafe"
)

func deferFunc(dsl []int) {
	//1、sl通过方法名传递，所以 sl是结构体值拷贝,所以会是一个新对象，参见pointer和append原理
	//2、新对象因为拷贝了ptr指针, 所以ptr对象不会变化, 参见：reflect.SliceHeader{Data:}
	//3、dsl与sl的ptr虽然相同，但是len不同，所以sl新增的元素对dsl无影响
	fmt.Printf("%s\t pointer:%p, struct: %#v, values:%v\n", "defer_before_append", &dsl, *((*reflect.SliceHeader)(unsafe.Pointer(&dsl))), dsl)
	dsl = append(dsl, 99)
	fmt.Printf("%s\t pointer:%p, struct: %#v, values:%v\n", "defer_after_append", &dsl, *((*reflect.SliceHeader)(unsafe.Pointer(&dsl))), dsl)
}

func main() {
	//拓展一下对象go的对象打印
	//slice是一个结构体
	fmt.Println("==========slice print=============")
	s:=[]int{1}
	//打印结构体指针地址
	fmt.Printf("%p\n",&s)
	//打印结构体首元素指针方法1
	fmt.Printf("%p\n",s)
	//打印结构体首元素指针方法2
	fmt.Printf("%p\n",&s[0])
	//打印结构体值:可以印证:打印结构体首元素指针方法1
	fmt.Printf("%#v\n",*((*reflect.SliceHeader)(unsafe.Pointer(&s))))
	fmt.Println("==========================")

	var sl = make([]int, 0, 10)
	for i := 0; i < 15; i++ {
		//0、append会发生值拷贝，如果是自身对象会复用，所以地址不会变化，参见pointer
		//1、不需要扩容时 ptr对象不会变化, 参见：reflect.SliceHeader{Data:}
		//2、扩容成功时，数据会发生拷贝所以 ptr对象会变化, 参见：reflect.SliceHeader{Data:}
		sl = append(sl, i)
		fmt.Printf("%s\t pointer:%p, struct: %#v, values:%v\n", "before_defer", &sl, *((*reflect.SliceHeader)(unsafe.Pointer(&sl))), sl)
	}
	defer deferFunc(sl)
	//1、append赋值给一个新对象时，因为是值拷贝，所以会是一个新对象，参见pointer和append原理  https://blog.golang.org/go-slices-usage-and-internals
	//2、新对象因为拷贝了ptr指针, 所以ptr对象不会变化, 参见：reflect.SliceHeader{Data:}
	sl2 := append(sl, 5)
	fmt.Printf("%s\t pointer:%p, struct: %#v, values:%v\n", "new_struct", &sl2, *((*reflect.SliceHeader)(unsafe.Pointer(&sl2))), sl2)
	sl2[0] = 100
	//1、sl与sl2的ptr相同，所以sl2对ptr的操作会对sl数据产生影响，所以sl[0]=100
	//2、sl与sl2的ptr虽然相同，但是len不同，所以sl2新增的元素对sl无影响
	sl = append(sl, 4)
	fmt.Printf("%s\t pointer:%p, struct: %#v, values:%v\n", "after_defer", &sl, *((*reflect.SliceHeader)(unsafe.Pointer(&sl))), sl)
}

==========slice print=============
0xc000088020
0xc000090000
0xc000090000
reflect.SliceHeader{Data:0xc000090000, Len:1, Cap:1}
==========================
before_defer	 pointer:0xc000088060, struct: reflect.SliceHeader{Data:0xc000094000, Len:1, Cap:10}, values:[0]
before_defer	 pointer:0xc000088060, struct: reflect.SliceHeader{Data:0xc000094000, Len:2, Cap:10}, values:[0 1]
before_defer	 pointer:0xc000088060, struct: reflect.SliceHeader{Data:0xc000094000, Len:3, Cap:10}, values:[0 1 2]
before_defer	 pointer:0xc000088060, struct: reflect.SliceHeader{Data:0xc000094000, Len:4, Cap:10}, values:[0 1 2 3]
before_defer	 pointer:0xc000088060, struct: reflect.SliceHeader{Data:0xc000094000, Len:5, Cap:10}, values:[0 1 2 3 4]
before_defer	 pointer:0xc000088060, struct: reflect.SliceHeader{Data:0xc000094000, Len:6, Cap:10}, values:[0 1 2 3 4 5]
before_defer	 pointer:0xc000088060, struct: reflect.SliceHeader{Data:0xc000094000, Len:7, Cap:10}, values:[0 1 2 3 4 5 6]
before_defer	 pointer:0xc000088060, struct: reflect.SliceHeader{Data:0xc000094000, Len:8, Cap:10}, values:[0 1 2 3 4 5 6 7]
before_defer	 pointer:0xc000088060, struct: reflect.SliceHeader{Data:0xc000094000, Len:9, Cap:10}, values:[0 1 2 3 4 5 6 7 8]
before_defer	 pointer:0xc000088060, struct: reflect.SliceHeader{Data:0xc000094000, Len:10, Cap:10}, values:[0 1 2 3 4 5 6 7 8 9]
before_defer	 pointer:0xc000088060, struct: reflect.SliceHeader{Data:0xc000098000, Len:11, Cap:20}, values:[0 1 2 3 4 5 6 7 8 9 10]
before_defer	 pointer:0xc000088060, struct: reflect.SliceHeader{Data:0xc000098000, Len:12, Cap:20}, values:[0 1 2 3 4 5 6 7 8 9 10 11]
before_defer	 pointer:0xc000088060, struct: reflect.SliceHeader{Data:0xc000098000, Len:13, Cap:20}, values:[0 1 2 3 4 5 6 7 8 9 10 11 12]
before_defer	 pointer:0xc000088060, struct: reflect.SliceHeader{Data:0xc000098000, Len:14, Cap:20}, values:[0 1 2 3 4 5 6 7 8 9 10 11 12 13]
before_defer	 pointer:0xc000088060, struct: reflect.SliceHeader{Data:0xc000098000, Len:15, Cap:20}, values:[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14]
new_struct	 pointer:0xc000088260, struct: reflect.SliceHeader{Data:0xc000098000, Len:16, Cap:20}, values:[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 5]
after_defer	 pointer:0xc000088060, struct: reflect.SliceHeader{Data:0xc000098000, Len:16, Cap:20}, values:[100 1 2 3 4 5 6 7 8 9 10 11 12 13 14 4]
defer_before_append	 pointer:0xc0000882c0, struct: reflect.SliceHeader{Data:0xc000098000, Len:15, Cap:20}, values:[100 1 2 3 4 5 6 7 8 9 10 11 12 13 14]
defer_after_append	 pointer:0xc0000882c0, struct: reflect.SliceHeader{Data:0xc000098000, Len:16, Cap:20}, values:[100 1 2 3 4 5 6 7 8 9 10 11 12 13 14 99]

总结：

• append会发生值拷贝，如果是自身对象会复用，所以地址不会变化
• append赋值给一个新对象时，因为是值拷贝，所以会是一个新对象
• 切片翻倍扩容时，ptr会发生数据拷贝，变成一个新指针
• append之后的新对象因为拷贝了ptr指针, 所以ptr对象不会变化
• append赋值前后ptr相同，但是len不同，所以赋值后的对象对元素进行修改操作后，会对原对象产生影响
• append赋值前后的ptr虽然相同，但是len不同，所以赋值后新增的元素对原对象无影响（如果原对象不新增对象的话），或者 对应的index值会被覆盖（如果原对象新增元素的话）