golang slice实践以及底层实现

桃扇骨 2021-10-14 23:23 303阅读 0赞

### slice实践以及底层原理 ###

*  slice是传值还是传地址
 *  slice作为函数入参的各种坑
 *  Slice数据结构
 *  创建Slice
 *  Slice扩容
 *   *  扩容策略
     *  扩容前后的地址是否一致
 *  Slice 拷贝

Topic:

1.  slice是传值还是传地址
2.  slice作为函数入参的各种坑
3.  切片的数据结构
4.  切片的创建
5.  切片的扩容
6.  切片的拷贝
7.  base golang 1.13

# slice是传值还是传地址 #

先看测试例子1:

func testModifyElem(s []int) { 
    	s[0] = 1
    	fmt.Printf("s inter address is %p \n", s)
    	fmt.Println("s=", s)
    }
    
    func main()  { 
    	fmt.Println("------------------------ slice0 -------------------------")
    	sa := make([]int, 10)
    	fmt.Printf("sa address is %p \n", sa)
    	fmt.Println("sa=", sa)
    	testModifyElem(sa)
    	fmt.Printf("post sa address is %p \n", sa)
    	fmt.Println("post sa=", sa)
    }

输出结果是：

------------------------ slice0 -------------------------
    sa address is 0xc00001e0a0 
    sa= [0 0 0 0 0 0 0 0 0 0]
    s inter address is 0xc00001e0a0 
    s= [1 0 0 0 0 0 0 0 0 0]
    post sa address is 0xc00001e0a0 
    post sa= [1 0 0 0 0 0 0 0 0 0]

上面的testModifyElem函数传递的是 slice 对象，输出结果可以看出两点:

1.  函数内部对slice某个元素的修改，会影响函数外面的slice。
2.  函数内部的slice地址和函数外部的slice是一致的。

这种现象会给人一种感觉，golang slice的传递是引用传递(实际上是错误的)。我们再来看一个例子：

func testModifyElem2(s []int) { 
    	s[0] = 1
    	fmt.Printf("s inter address is %p \n", s)
    	fmt.Println("s=", s)
    	s = append(s, 11)
    	fmt.Printf("s inter address（after append） is %p \n", s)
    	fmt.Println("s=（after append）", s)
    }
    
    func main()  { 
    	fmt.Println("------------------------ slice0 -------------------------")
    	sa := make([]int, 10)
    	fmt.Printf("sa address is %p \n", sa)
    	fmt.Println("sa=", sa)
    	testModifyElem2(sa)
    	fmt.Printf("post sa address is %p \n", sa)
    	fmt.Println("post sa=", sa)
    }

输出结果是：

------------------------ slice0 -------------------------
    sa address is 0xc00009e000 
    sa= [0 0 0 0 0 0 0 0 0 0]
    s inter address is 0xc00009e000 
    s= [1 0 0 0 0 0 0 0 0 0]
    s inter address（after append） is 0xc0000b0000 
    s=（after append） [1 0 0 0 0 0 0 0 0 0 11]
    post sa address is 0xc00009e000 
    post sa= [1 0 0 0 0 0 0 0 0 0]

从这个输出结果我们可以得到：

1.  函数内部对slice某个元素的修改，会影响函数外面的slice。
2.  如果函数内部对slice的append操作，不会影响到函数外部slice。
3.  我们的slice len和cap都是10，函数内部的append会导致扩容，扩容之后，地址发生了变化，但是函数外部的slice地址并没有变化。这说明了golang的slice传递slice不是引用传递，而是值传递。

还有一种场景，如果slice在函数内部append不会导致扩容呢？看下面的例子：

func testModifyElem2(s []int) { 
    	s[0] = 1
    	fmt.Printf("s inter address is %p \n", s)
    	fmt.Println("s=", s)
    	s = append(s, 11)
    	fmt.Printf("s inter address（after append） is %p \n", s)
    	fmt.Println("s=（after append）", s)
    }
    
    func main()  { 
    	fmt.Println("------------------------ slice0 -------------------------")
    	sa := make([]int, 10, 20)
    	fmt.Printf("sa address is %p \n", sa)
    	fmt.Println("sa=", sa)
    	testModifyElem2(sa)
    	fmt.Printf("post sa address is %p \n", sa)
    	fmt.Println("post sa=", sa)
    }

运行结果如下：

------------------------ slice0 -------------------------
    sa address is 0xc0000ac000 
    sa= [0 0 0 0 0 0 0 0 0 0]
    s inter address is 0xc0000ac000 
    s= [1 0 0 0 0 0 0 0 0 0]
    s inter address（after append） is 0xc0000ac000 
    s=（after append） [1 0 0 0 0 0 0 0 0 0 11]
    post sa address is 0xc0000ac000 
    post sa= [1 0 0 0 0 0 0 0 0 0]

我们可以看到两点：

1.  函数内部的append不会影响到外部的slice；
2.  如果函数内部的append不会导致扩容，那么slice的地址也不会变化。

这个结论进一步验证了我们的结论。

所以我们的结论就是：值传递。

1.  slice的函数传参或者赋值，其实都是值传递，也就是会发生拷贝。slice内部是持有三个变量，实际存储数据的数组地址、当前slice的len以及slice的容量。
2.  传参时，实际上会拷贝len、cap、以及底层实际存储数据的数组的首地址。
3.  如果函数内部发生了append的操作，函数外部是感知不到的。

当我们调用函数 testMethod(s) 的时候，实际上类似于 testMethod(\*addr, len, cap)。

其实我们在调用append函数的时候，用法都是 `s = append(s, data...)` 。 append函数实际上返回的是一个新的slice对象，然后新的对象的属性；len、cap以及底层数组首地址会拷贝赋值给s。

# slice作为函数入参的各种坑 #

前面一章其实已经列出了slice传参的一些坑。这里再列出一些典型的坑。

Case1: 函数入参是一个slice, 期待函数内部的的修改，比如新增、删除、更改会在外部生效。  
这里的实现有两种方法：传一个slice的指针进去；或者return入参的slice并且赋值给外部的slice。

（1）传指针, 直接看code:

func testSlicePtr(sp *[]int) { 
    	fmt.Printf("sp address is %p \n", *sp)
    	fmt.Println("sp=", *sp)
    	*sp = append(*sp, 10)
    	fmt.Printf("post sp address is %p \n", *sp)
    	fmt.Println("post sp=", *sp)
    }
    
    func main()  { 
    	fmt.Println("------------------------ slice0 -------------------------")
    	slice6 := make([]int, 10, 10)
    	fmt.Printf("slice6 address is %p \n", slice6)
    	fmt.Println("slice6=", slice6)
    	testSlicePtr(&slice6)
    	fmt.Printf("post slice6 address is %p \n", slice6)
    	fmt.Println("post slice6=", slice6)
    }

执行结果是：

------------------------ slice6 -------------------------
    slice6 address is 0xc00001e0a0 
    slice6= [0 0 0 0 0 0 0 0 0 0]
    sp address is 0xc00001e0a0 
    sp= [0 0 0 0 0 0 0 0 0 0]
    post sp address is 0xc0000960a0 
    post sp= [0 0 0 0 0 0 0 0 0 0 10]
    post slice6 address is 0xc0000960a0 
    post slice6= [0 0 0 0 0 0 0 0 0 0 10]

可以看到在testSlicePtr函数内部导致了slice的扩容，扩容之后函数内部slice的地址和函数外部调用函数之后的slice地址一致，数据也一致。说明函数内部的改变是完全与外部一致。

（2）return slice 方式, 代码如下：

func testSliceReturn(sp []int) []int { 
    	fmt.Printf("sp address is %p \n", sp)
    	fmt.Println("sp=", sp)
    	sp = append(sp, 10)
    	fmt.Printf("post sp address is %p \n", sp)
    	fmt.Println("post sp=", sp)
    	return sp
    }
    
    func main()  { 
    	fmt.Println("------------------------ slice7 -------------------------")
    	slice7 := make([]int, 10, 10)
    	fmt.Printf("slice7 address is %p \n", slice7)
    	fmt.Println("slice7=", slice7)
    	slice7 = testSliceReturn(slice7)
    	fmt.Printf("post slice7 address is %p \n", slice7)
    	fmt.Println("post slice7=", slice7)
    }

测试结果：

------------------------ slice7 -------------------------
    slice7 address is 0xc0000b6050 
    slice7= [0 0 0 0 0 0 0 0 0 0]
    sp address is 0xc0000b6050 
    sp= [0 0 0 0 0 0 0 0 0 0]
    post sp address is 0xc00009a140 
    post sp= [0 0 0 0 0 0 0 0 0 0 10]
    post slice7 address is 0xc00009a140 
    post slice7= [0 0 0 0 0 0 0 0 0 0 10]

我们可以看到testSliceReturn内部扩容之后的地址和函数外部return赋值之后的slice7地址一模一样， 通过return方式也可以实现。

Case2 子切片的更改也会改变父切片：  
直接看code:

func main(){ 
    	fmt.Println("------------------------ slice8 -------------------------")
    	slice8 := make([]int, 10, 10)
    	fmt.Printf("slice8 address is %p \n", slice8)
    	fmt.Println("slice8=", slice8)
    	slice8_sub := slice8[2:4]
    	fmt.Printf("slice8_sub address is %p \n", slice8_sub)
    	fmt.Println("slice8_sub=", slice8_sub)
    	fmt.Println("len=", len(slice8_sub), "cap=", cap(slice8_sub))
    	slice8_sub = append(slice8_sub, 111)
    	fmt.Printf("post slice8 address is %p \n", slice8)
    	fmt.Println("post slice8=", slice8)
    	fmt.Printf("post slice8_sub address is %p \n", slice8_sub)
    	fmt.Println("post slice8_sub=", slice8_sub)
    	fmt.Println("post len=", len(slice8_sub), "cap=", cap(slice8_sub))
    	for idx, v := range slice8_sub { 
    		fmt.Println("idx=", idx, "value=", v)
    	}
    }

输出结果是：

------------------------ slice8 -------------------------
    ------------------------ slice8 -------------------------
    slice8 address is 0xc00001e0f0 
    slice8= [0 0 0 0 0 0 0 0 0 0]
    slice8_sub address is 0xc00001e100 
    slice8_sub= [0 0]
    len= 2 cap= 8
    post slice8 address is 0xc00001e0f0 
    post slice8= [0 0 0 0 111 0 0 0 0 0]
    post slice8_sub address is 0xc00001e100 
    post slice8_sub= [0 0 111]
    post len= 3 cap= 8
    idx= 0 value= 0
    idx= 1 value= 0
    idx= 2 value= 111

可以看到子slice的改变也会改变父slice。说明slice的子slice虽然是一个全新的slice。 但是底层数据是公用的，也就是底层存储数组是公用的。

经过前面很多的test case我们需要记住的最重要的一点是：  
**make返回的是slice struct实体(不是指针)，里面维护了slice的len和cap, 然后还要有一个执行底层存储的数组。slice的 传参、赋值都是值拷贝，但是公用底层数组。如果append时候发生了底层数组的扩容，除非重新赋值，不然旧的slice都是指向原来的老数组**

# Slice数据结构 #

切片本身不是动态数组或者数组指针。它内部实现的数据结构通过指针引用底层数组，设定相关属性将数据读写操作限定在指定的区域内。切片本身是一个只读对象，其工作机制类似数组指针的一种封装。

先看源码：runtime/slice.go，数据结构的定义如下：

type slice struct { 
    	array unsafe.Pointer
    	len   int
    	cap   int
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA4NTMyNjE_size_16_color_FFFFFF_t_70]  
切片的结构体由3部分构成，Pointer 是指向一个底层数组的指针，len 代表当前切片实例的长度，cap 是当前切片的容量。cap 总是大于等于 len 的。

下图是一个实例：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA4NTMyNjE_size_16_color_FFFFFF_t_70 1]

# 创建Slice #

make 函数允许在运行期动态指定数组长度，绕开了数组类型必须使用编译期常量的限制。创建切片有两种形式，make 创建切片，空切片。

make函数有三个参数，比如：`make([]int, 5, 10)` 创建了一个长度为5，cap为10的int切片。需要注意的是：

1.  切面已经初始化了5个元素，默认值是int默认值0，所以开始append是从第六个元素开始；
2.  如果slice的元素个数超过了10，就会扩容。

当我们使用make函数创建slice的时候，编译器会默认转换为调用slice.go里面的 `makeslice` 函数。源码如下：

func makeslice(et *_type, len, cap int) unsafe.Pointer { 
    	//根据切片的数据类型，获取切片的最大容量
    	mem, overflow := math.MulUintptr(et.size, uintptr(cap))
    	if overflow || mem > maxAlloc || len < 0 || len > cap { 
    		// NOTE: Produce a 'len out of range' error instead of a
    		// 'cap out of range' error when someone does make([]T, bignumber).
    		// 'cap out of range' is true too, but since the cap is only being
    		// supplied implicitly, saying len is clearer.
    		// See golang.org/issue/4085.
    		mem, overflow := math.MulUintptr(et.size, uintptr(len))
    		if overflow || mem > maxAlloc || len < 0 { 
    			panicmakeslicelen()
    		}
    		panicmakeslicecap()
    	}
    	// 根据切片的容量申请内存
    	return mallocgc(mem, et, true)
    }

还有一个64位的版本 `makeslice64` ，这个函数和 `makeslice` 区别仅仅在于len和cap的长度扩展到64位。

该函数的流程也比较简单，基于slice的数据类型然后检验len、cap的有效性，如果有效，就调用mallocgc申请内存。

举个例子： slice:= make(int\[\], 4, 6) 创建一个长度为4，容量为6的int类型slice，如下图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA4NTMyNjE_size_16_color_FFFFFF_t_70 2]  
我们需要注意的是，内存空间申请了6个int类型大小，但是len等于4，所以后面两个元素对于slice是无法访问的，如果访问会panic。当我们append之后，才能访问。对于len为4的四个元素全部会默认初始化为0。

对于slice我们还有一个需要注意的是 **nil 切片和 空切片。**

nil切片s1和空切片s2的定义如下：

//nil slice
    var s1 []int
    
    // 空切片
    s2 := make([]int, 0)

这两者区别在于：

1.  nil 切片被用在很多标准库和内置函数中，描述一个不存在的切片的时候，就需要用到 nil 切片。比如函数在发生异常的时候，返回的切片就是 nil 切片。nil 切片的指针指向 nil。
2.  空切片一般会用来表示一个空的集合。比如数据库查询，一条结果也没有查到，那么就可以返回一个空切片。
3.  空切片指向的地址不是nil，指向的是一个内存地址，但是它没有分配任何内存空间，即底层元素包含0个元素。但是nil切片指向的是nil

有一点需要特别说明的是，不管是使用 nil 切片还是空切片，对其调用内置函数 append，len 和 cap 的效果都是一样的。

# Slice扩容 #

前面已经聊到，slice其实并不存储元素，而是通过持有底层数组的指针来访问元素。slice已经指定了底层数组的capacity。当我们append数量超过了capacity时候，就需要扩容切片。

还是先看源码：(去除非核心代码)

// growslice handles slice growth during append.
    // It is passed the slice element type, the old slice, and the desired new minimum capacity,
    // and it returns a new slice with at least that capacity, with the old data
    // copied into it.
    // The new slice's length is set to the old slice's length,
    // NOT to the new requested capacity.
    // This is for codegen convenience. The old slice's length is used immediately
    // to calculate where to write new values during an append.
    // TODO: When the old backend is gone, reconsider this decision.
    // The SSA backend might prefer the new length or to return only ptr/cap and save stack space.
    func growslice(et *_type, old slice, cap int) slice { 
    	// 如果新要扩容的容量比原来的容量还要小，这代表要缩容了，那么可以直接报panic了。
    	if cap < old.cap { 
    		panic(errorString("growslice: cap out of range"))
    	}
    
    	if et.size == 0 { 
    		// 如果当前切片的大小为0，还调用了扩容方法，那么就新生成一个新的容量的切片返回。
    		return slice{ unsafe.Pointer(&zerobase), old.len, cap}
    	}
    	
    	// 这里就是扩容的策略
    	newcap := old.cap
    	doublecap := newcap + newcap
    	if cap > doublecap { 
    		newcap = cap
    	} else { 
    		if old.len < 1024 { 
    			newcap = doublecap
    		} else { 
    			// Check 0 < newcap to detect overflow
    			// and prevent an infinite loop.
    			for 0 < newcap && newcap < cap { 
    				newcap += newcap / 4
    			}
    			// Set newcap to the requested cap when
    			// the newcap calculation overflowed.
    			if newcap <= 0 { 
    				newcap = cap
    			}
    		}
    	}
    	
    	// 计算新的切片的容量，长度。
    	var overflow bool
    	var lenmem, newlenmem, capmem uintptr
    	// Specialize for common values of et.size.
    	// For 1 we don't need any division/multiplication.
    	// For sys.PtrSize, compiler will optimize division/multiplication into a shift by a constant.
    	// For powers of 2, use a variable shift.
    	switch { 
    	case et.size == 1:
    		lenmem = uintptr(old.len)
    		newlenmem = uintptr(cap)
    		capmem = roundupsize(uintptr(newcap))
    		overflow = uintptr(newcap) > maxAlloc
    		newcap = int(capmem)
    	case et.size == sys.PtrSize:
    		lenmem = uintptr(old.len) * sys.PtrSize
    		newlenmem = uintptr(cap) * sys.PtrSize
    		capmem = roundupsize(uintptr(newcap) * sys.PtrSize)
    		overflow = uintptr(newcap) > maxAlloc/sys.PtrSize
    		newcap = int(capmem / sys.PtrSize)
    	case isPowerOfTwo(et.size):
    		var shift uintptr
    		if sys.PtrSize == 8 { 
    			// Mask shift for better code generation.
    			shift = uintptr(sys.Ctz64(uint64(et.size))) & 63
    		} else { 
    			shift = uintptr(sys.Ctz32(uint32(et.size))) & 31
    		}
    		lenmem = uintptr(old.len) << shift
    		newlenmem = uintptr(cap) << shift
    		capmem = roundupsize(uintptr(newcap) << shift)
    		overflow = uintptr(newcap) > (maxAlloc >> shift)
    		newcap = int(capmem >> shift)
    	default:
    		lenmem = uintptr(old.len) * et.size
    		newlenmem = uintptr(cap) * et.size
    		capmem, overflow = math.MulUintptr(et.size, uintptr(newcap))
    		capmem = roundupsize(capmem)
    		newcap = int(capmem / et.size)
    	}
    
    	// The check of overflow in addition to capmem > maxAlloc is needed
    	// to prevent an overflow which can be used to trigger a segfault
    	// on 32bit architectures with this example program:
    	//
    	// type T [1<<27 + 1]int64
    	//
    	// var d T
    	// var s []T
    	//
    	// func main() { 
    	// s = append(s, d, d, d, d)
    	// print(len(s), "\n")
    	// }
    	if overflow || capmem > maxAlloc { 
    		panic(errorString("growslice: cap out of range"))
    	}
    
    	var p unsafe.Pointer
    	if et.kind&kindNoPointers != 0 { 
    		// 在老的切片后面继续扩充容量
    		p = mallocgc(capmem, nil, false)
    		// The append() that calls growslice is going to overwrite from old.len to cap (which will be the new length).
    		// Only clear the part that will not be overwritten.
    		// 先将 P 地址加上新的容量得到新切片容量的地址，然后将新切片容量地址后面的 capmem-newlenmem 个 bytes 这块内存初始化。为之后继续 append() 操作腾出空间。
    		memclrNoHeapPointers(add(p, newlenmem), capmem-newlenmem)
    	} else { 
    		// 重新申请新的数组给新切片
    		// 重新申请 capmen 这个大的内存地址，并且初始化为0值
    		p = mallocgc(capmem, et, true)
    		if writeBarrier.enabled { 
    			// Only shade the pointers in old.array since we know the destination slice p
    			// only contains nil pointers because it has been cleared during alloc.
    			bulkBarrierPreWriteSrcOnly(uintptr(p), uintptr(old.array), lenmem)
    		}
    	}
    	// 将 lenmem 这个多个 bytes 从 old.array地址 拷贝到 p 的地址处
    	memmove(p, old.array, lenmem)
    	// 返回最终新切片，容量更新为最新扩容之后的容量
    	return slice{ p, old.len, newcap}
    }

上述就是扩容的实现，主要有两点，一个是扩容时候的策略，还有一个就是扩容是生成全新的内存地址还是在原来的地址后追加。

## 扩容策略 ##

我们先看一个例子来说明扩容策略：

func main(){ 
    	fmt.Println("------------------------ slice9 -------------------------")
    	slice9 := []int{ 10, 20, 30, 40}
    	newslice9 := append(slice9, 50)
    	fmt.Printf("Before slice = %v, Pointer = %p, len = %d, cap = %d\n", slice9, slice9, len(slice9), cap(slice9))
    	fmt.Printf("Before newSlice = %v, Pointer = %p, len = %d, cap = %d\n", newslice9, newslice9, len(newslice9), cap(newslice9))
    	newslice9[1] += 10
    	fmt.Printf("After slice = %v, Pointer = %p, len = %d, cap = %d\n", slice9, slice9, len(slice9), cap(slice9))
    	fmt.Printf("After newSlice = %v, Pointer = %p, len = %d, cap = %d\n", newslice9, newslice9, len(newslice9), cap(newslice9))
    	
    }

输出 结果是：

------------------------ slice9 -------------------------
    Before slice = [10 20 30 40], Pointer = 0xc000016100, len = 4, cap = 4
    Before newSlice = [10 20 30 40 50], Pointer = 0xc00001c0c0, len = 5, cap = 8
    After slice = [10 20 30 40], Pointer = 0xc000016100, len = 4, cap = 4
    After newSlice = [10 30 30 40 50], Pointer = 0xc00001c0c0, len = 5, cap = 8

用图 表示上诉过程：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA4NTMyNjE_size_16_color_FFFFFF_t_70 3]

从图上我们可以很容易的看出，新的切片和之前的切片已经不同了，因为新的切片更改了一个值，并没有影响到原来的数组，新切片指向的数组是一个全新的数组。并且 cap 容量也发生了变化。这之间究竟发生了什么呢？

Go 中切片扩容的策略是这样的：

*  首先判断，如果新申请容量（cap）大于2倍的旧容量（old.cap），最终容量（newcap）就是新申请的容量（cap）
 *  否则判断，如果旧切片的长度小于1024，则最终容量(newcap)就是旧容量(old.cap)的两倍，即（newcap=doublecap）
 *  否则判断，如果旧切片长度大于等于1024，则最终容量（newcap）从旧容量（old.cap）开始循环增加原来的1/4，即（newcap=old.cap,for \{newcap += newcap/4\}）直到最终容量（newcap）大于等于新申请的容量(cap)，即（newcap >= cap）
 *  如果最终容量（cap）计算值溢出，则最终容量（cap）就是新申请容量（cap）

注意：扩容扩大的容量都是针对原来的容量而言的，而不是针对原来数组的长度而言的。

## 扩容前后的地址是否一致 ##

扩容之后的数组不一定是一个新的数组

Case1 非新数组

func main() { 
    	array := [4]int{ 10, 20, 30, 40}
    	slice := array[0:2]
    	newSlice := append(slice, 50)
    	fmt.Printf("Before slice = %v, Pointer = %p, len = %d, cap = %d\n", slice, &slice, len(slice), cap(slice))
    	fmt.Printf("Before newSlice = %v, Pointer = %p, len = %d, cap = %d\n", newSlice, &newSlice, len(newSlice), cap(newSlice))
    	newSlice[1] += 10
    	fmt.Printf("After slice = %v, Pointer = %p, len = %d, cap = %d\n", slice, &slice, len(slice), cap(slice))
    	fmt.Printf("After newSlice = %v, Pointer = %p, len = %d, cap = %d\n", newSlice, &newSlice, len(newSlice), cap(newSlice))
    	fmt.Printf("After array = %v\n", array)
    }

输出是：

Before slice = [10 20], Pointer = 0xc0000c0000, len = 2, cap = 4
    Before newSlice = [10 20 50], Pointer = 0xc0000c0000, len = 3, cap = 4
    After slice = [10 30], Pointer = 0xc0000c0000, len = 2, cap = 4
    After newSlice = [10 30 50], Pointer = 0xc0000c0000, len = 3, cap = 4
    After array = [10 30 50 40]

下图显示了上诉代码执行过程：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA4NTMyNjE_size_16_color_FFFFFF_t_70 4]  
通过打印的结果，我们可以看到，在这种情况下，扩容以后并没有新建一个新的数组，扩容前后的数组都是同一个，这也就导致了新的切片修改了一个值，也影响到了老的切片了。并且 append() 操作也改变了原来数组里面的值。一个 append() 操作影响了这么多地方，如果原数组上有多个切片，那么这些切片都会被影响！无意间就产生了莫名的 bug！

这种情况，由于原数组还有容量可以扩容，所以执行 append() 操作以后，会在原数组上直接操作，所以这种情况下，扩容以后的数组还是指向原来的数组。

这种情况也极容易出现在字面量创建切片时候，第三个参数 cap 传值的时候，如果用字面量创建切片，cap 并不等于指向数组的总容量，那么这种情况就会发生。

Case2 新数组  
情况二其实就是在扩容策略里面举的例子，在那个例子中之所以生成了新的切片，是因为原来数组的容量已经达到了最大值，再想扩容， Go 默认会先开一片内存区域，把原来的值拷贝过来，然后再执行 append() 操作。这种情况丝毫不影响原数组。

所以建议尽量避免情况一，尽量使用情况二，避免 bug 产生。

# Slice 拷贝 #

slice有 两个方法进行复制。 这里只说明：`slicecopy`

func slicecopy(to, fm slice, width uintptr) int { 
    	// 如果源切片或者目标切片有一个长度为0，那么就不需要拷贝，直接 return 
    	if fm.len == 0 || to.len == 0 { 
    		return 0
    	}
    	// n 记录下源切片或者目标切片较短的那一个的长度
    	n := fm.len
    	if to.len < n { 
    		n = to.len
    	}
    	// 如果入参 width = 0，也不需要拷贝了，返回较短的切片的长度
    	if width == 0 { 
    		return n
    	}
    
    	if raceenabled { 
    		callerpc := getcallerpc()
    		pc := funcPC(slicecopy)
    		racewriterangepc(to.array, uintptr(n*int(width)), callerpc, pc)
    		racereadrangepc(fm.array, uintptr(n*int(width)), callerpc, pc)
    	}
    	if msanenabled { 
    		msanwrite(to.array, uintptr(n*int(width)))
    		msanread(fm.array, uintptr(n*int(width)))
    	}
    
    	size := uintptr(n) * width
    	if size == 1 {  // common case worth about 2x to do here
    		// TODO: is this still worth it with new memmove impl?
    		// 如果只有一个元素，那么指针直接转换即可
    		*(*byte)(to.array) = *(*byte)(fm.array) // known to be a byte pointer
    	} else { 
    		// 如果不止一个元素，那么就把 size 个 bytes 从 fm.array 地址开始，拷贝到 to.array 地址之后
    		memmove(to.array, fm.array, size)
    	}
    	return n
    }

在这个方法中，slicecopy 方法会把源切片值(即 fm Slice )中的元素复制到目标切片(即 to Slice )中，并返回被复制的元素个数，copy 的两个类型必须一致。slicecopy 方法最终的复制结果取决于较短的那个切片，当较短的切片复制完成，整个复制过程就全部完成了。

举个例子：

func main() {
    	array := []int{10, 20, 30, 40}
    	slice := make([]int, 6)
    	n := copy(slice, array)
    	fmt.Println(n,slice)
    }

输出是：

4 [10 20 30 40 0 0]

说到拷贝，切片中有一个需要注意的问题。

func main() {
    	slice := []int{10, 20, 30, 40}
    	for index, value := range slice {
    		fmt.Printf("value = %d , value-addr = %x , slice-addr = %x\n", value, &value, &slice[index])
    	}
    }

输出结果：

value = 10 , value-addr = c0000a0438 , slice-addr = c0000ae020
    value = 20 , value-addr = c0000a0438 , slice-addr = c0000ae028
    value = 30 , value-addr = c0000a0438 , slice-addr = c0000ae030
    value = 40 , value-addr = c0000a0438 , slice-addr = c0000ae038

从上面结果我们可以看到，如果用 range 的方式去遍历一个切片，拿到的 Value 其实是切片里面的值拷贝。所以每次打印 Value 的地址都不变。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA4NTMyNjE_size_16_color_FFFFFF_t_70 5]  
于 Value 是值拷贝的，并非引用传递，所以直接改 Value 是达不到更改原切片值的目的的，需要通过 &slice\[index\] 获取真实的地址。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA4NTMyNjE_size_16_color_FFFFFF_t_70]: /images/20211015/9bff945e695040b99d4fb14fa91ea5a3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA4NTMyNjE_size_16_color_FFFFFF_t_70 1]: /images/20211015/e611c7a281534fe784e70531f1cd9478.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA4NTMyNjE_size_16_color_FFFFFF_t_70 2]: /images/20211015/2753019a55b241059bb65c2d307ca097.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA4NTMyNjE_size_16_color_FFFFFF_t_70 3]: /images/20211015/57dfc4c75162493588111bb2a3d400e2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA4NTMyNjE_size_16_color_FFFFFF_t_70 4]: /images/20211015/507f6145847147e384101be7c438c2eb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA4NTMyNjE_size_16_color_FFFFFF_t_70 5]: /images/20211015/cb9a851cc0504660990bc4adc1d36cab.png