golang slice总结

概述

一、什么是slice

二、slice的声明

三、slice的初始化、创建

make方式创建

创建一个包含指定长度的切片

创建一个指定长度和容量的切片

创建一个空切片

创建一个长度和容量都为 0 的切片

new方式创建

短声明初始化切片

通过一个数组来创建切片

声明一个 nil 切片

四、nil切片和空切片的区别

空切片（Empty Slice）

nil 切片（nil Slice）

共同点

注意事项和易错点

五、常见导致panic的slice操作

索引越界

切片越界

小结

六、slice的相关操作

slice底层数组指针的获取方式

方式1、unsafe.SliceData

方式2、%p

方式3、reflect

slice的长度

slice的容量

slice的遍历

基于索引的遍历

使用range实现遍历

slice的截取

slice的追加

内置append函数

append不扩容的情况

append扩容的情况

append的返回值很重要

slice的拷贝

浅拷贝

深拷贝

内置copy函数

内置copy函数实现深拷贝

内置append函数实现深拷贝

七、slice在函数调用时是header传递

总结

概述

本文主要是对slice的总结，从slice的基本概念、创建方式、常用操作，自己经历过的坑点易错点，以及append的机制，slice的header传递，尽可能用最简单的代码说明问题，本文的代码是基于golang 1.22.1版本验证。

一、什么是slice

切片是用来描述底层数组的连续片段的数据结构，本身并不保存数组数据，而只是保存数组连续片段的描述信息，通过结构体里的array段指针引用底层数组，长度和容量属性限制底层数组的读写片段。

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

描述切片的数据结构由指向数组的指针、长度和容量三部分组成：

array 指针指向通过slice访问底层数组的的的第一个元素的指针，这里的被指位置不一定是数组的第一个元素，在对slice进行切片操作时，会移动这个指针。
len 长度代表切片当前包含的元素数量，len的大小不能超过cap的大小。
cap 容量表示底层数组从切片开始位置到数组末尾的元素个数,即当前切片的容量，cap总是大于或者等于len。

为什么指针的类型是 unsafe.Pointer 呢？

这是因为在底层实现中，Go 语言的切片并不直接指向底层数组的数据，而是通过指针间接引用。unsafe.Pointer 类型是 Go 语言中用于处理底层指针的一种特殊类型，它可以指向任意类型的数据，包括未导出的结构体和数组。这种设计的目的是为了支持切片的动态扩展和收缩。当切片需要扩容时，底层的数组可能会被重新分配内存，新的数组可能位于内存的不同位置。使用指针可以更灵活地引用底层数组，而不受具体类型的限制。需要注意的是，由于 unsafe之所以叫unsafe包，是因为这里面的大部分操作绕开里golang的data type system的约束，直接操作内存单元，是比较危险，容易引起程序运行安全的操作，unsafe.Pointer 类型可以指向任意类型的数据，因此在使用时需要特别小心，避免造成内存访问越界或者类型不匹配的问题。通常情况下，开发者应该尽量避免直接使用 unsafe.Pointer，除非是在必要的情况下进行底层操作。

二、slice的声明

var slicename []T //slicevar slicename []T //slice

其中，slicename是切片的变量名，T 是切片中元素的类型 ,注意中括号里并没有数值n。

区分数组的声明

var arrayname [n]T //array

三、slice的初始化、创建

make方式创建

golang提供了内置的函数make创建

func make([]T, len, cap) []T

T 表示切片中元素的类型。
len 表示切片的长度，即切片中包含的元素个数。
cap 表示切片的容量，即底层数组的长度,这个参数可选

make函数调用后，它其实分配了一个T类型的数组，并返回一个slice指向该数组

创建一个包含指定长度的切片

当cap参数未指定时cap的值与len的值相同

s := make([]int, 5) // 创建一个包含 5 个整数的切片，初始值为对应类型的零值 
//[0 0 0 0 0] cap(s)= 5 len(s)= 5

创建一个指定长度和容量的切片

s := make([]int, 5, 10) // 创建一个包含 5 个整数的切片，并且底层数组的长度为 10 
//[0 0 0 0 0] cap(s)= 10 len(s)= 5

创建一个空切片

s :=make([]int, 0) // 创建一个空切片，长度为 0
//[] cap(s)= 0 len(s)= 0

创建一个长度和容量都为 0 的切片

s := make([]int, 0, 0) // 创建一个长度和容量都为 0 的切片 
//[] cap(s)= 0 len(s)= 0

new方式创建

golang的内置函数new是用来分配内存，并返回指向该类型的零值的指针，而slice本身是一个包含指针、长度和容量的复合类型，使用new来创建slice不是很合适，这种方式还会涉及到unsafe包的使用，它绕过了Go的类型安全，并且需要手动管理内存，这很容易引发错误和内存泄漏。因此，在实际开发中，最好避免使用这种方法，而是使用make函数来创建slice，对于new不展开介绍

短声明初始化切片

s := []int{1, 2, 3, 4, 5} //[1 2 3 4 5] cap(s)= 5 len(s)= 5

通过一个数组来创建切片

arr := [5]int{1, 2, 3, 4, 5}
s := arr[:]
//[1 2 3 4 5]     cap(s)= 5  len(s)= 5

s1 := arr[:]
s2 := arr[0:]
s3 := arr[:5]
// 以上 s s1 s2 s3都是相等的 都是[1 2 3 4 5]

s4 := arr[:0]
//而s4是创建一个空的slice

声明一个 nil 切片

var s []int // 这是一个 nil 切片 //[] cap(s)= 0 len(s)= 0

四、nil切片和空切片的区别

在 Go 中，空切片（empty slice）和 nil 切片（nil slice）是两种不同的概念，

它们有着共同点和某些不同的含义和用途：

空切片（Empty Slice）

空切片是一个长度为 0 的切片，但其底层数组已经被分配了。
可以通过 make 函数创建一个空切片，也可以通过切片字面量 []T{} 创建。
空切片可以被使用，可以进行追加元素、遍历等操作，但不会引发 panic，因为底层数组已经被分配。
通常用于表示一个空的集合或者没有元素的情况。
encoding/json编码时空切片会被编码为 JSON 数组 []，表示一个空的数组。当你有一个空的切片时，你期望它在 JSON 中被表示为一个空数组，这与空的集合或序列的语义一致。

示例：

// 使用 make 函数创建空切片
emptySlice := make([]int, 0)

// 使用切片字面量创建空切片
emptySlice2 := []int{}

fmt.Println("emptySlice ", emptySlice, " address of underlying array:", unsafe.SliceData(emptySlice), "\nlen=", len(emptySlice), "\ncap=", cap(emptySlice))
fmt.Println("emptySlice2 ", emptySlice2, " address of underlying array:", unsafe.SliceData(emptySlice2), "\nlen=", len(emptySlice2), "\ncap=", cap(emptySlice2))

运行结果：

nil 切片（nil Slice）

nil 切片是一个指向 nil 的切片引用，即没有指向任何底层数组。
一个 nil 切片的长度和容量都是 0，并且它的指针为 nil。
可以将一个切片赋值为 nil，或者声明一个没有初始化的切片，它们都会被视为 nil 切片。
encoding/json编码时nil 切片会被编码为 JSON 的 null 值，表示不存在的值。当你有一个 nil 切片时，JSON 编码将把它解释为一个缺失值，这在某些情况下可能会引起问题，特别是在期望一个数组而不是 null 值的情况下

示例：

// 声明一个未初始化的切片，会被初始化为 nil 切片
var nilSlice []int
fmt.Println("nilSlice ", nilSlice, " address of underlying array:", unsafe.SliceData(nilSlice), "\nlen=", len(nilSlice), "\ncap=", cap(nilSlice))

运行结果：

共同点

nil切片和空切片在进行如下操作：len(), cap(), append(), and for .. range loop时的行为和结果都是一致,都不会引发panic，都表示空的集合或序列（有的地方说对nil进行这些操作会引发panic，应该是跟go的版本不同）但是对nil slice的索引还是会抛出panic的，多一嘴：对nil map进行append操作会引发panic

注意事项和易错点

使用空切片和 nil 切片的场景不同，需要根据实际情况进行选择。如果需要表示一个空的集合或者没有元素的情况，应该使用空切片；如果需要表示一个未初始化或者未指定的切片，可以使用 nil 切片。
在函数返回值中，通常使用 nil 切片来表示某些特定条件下的空值。
当需要传递一个切片作为函数参数，并且可能为空时，建议使用 nil 切片而不是空切片，以便明确表明该切片是未初始化的。
在判断切片是否为空时，应该使用 len(slice) == 0 来判断，而不是 slice == nil，因为后者只能用于判断切片是否为 nil。

对于 JSON 编码，需要注意的是:
当你希望表示一个空的切片时，使用空切片 [];
当你希望表示一个不存在的切片时，使用nil切片nil。

五、常见导致panic的slice操作

索引越界

当访问slice的元素时，如果使用的索引超出了slice的有效范围（即小于0或大于等于slice的长度）,程序会触发运行时panic，常见的是因为忽略slice或者array的起始索引是0，最后一个是len(slice)-1导致的。

这种panic提示一般是这样的：

panic: runtime error: index out of range ** with length **

fruits := []string{"apple", "orange", "grape"} 
fmt.Println("my favorite fruit is:", fruits[len(fruits)]) 
// panic: runtime error: index out of range [3] with length 3

注意索引index是小于等于len(slice)-1，而不是容量cap(slice)-1

numbers := make([]int, 3, 5) 
numbers[3] = 5 
//panic: runtime error: index out of range [3] with length 3

切片越界

在通过切片操作（slice[low:high]）创建新的slice时，如果low或high超出了原slice的界限，也会触发panic。

这样panic提示一般是这样的：

panic: runtime error: slice bounds out of range **

slice := []int{1, 2, 3} 
newSlice := slice[4:] 
// low超出原slice的界限，会触发panic

小结

在某些情况下，对slice的底层数组进行不安全的操作（比如直接修改slice的结构体字段或使用unsafe包进行底层操作），可能会导致slice处于不一致的状态，进而引发panic。这种情况较为罕见，通常发生在底层编程或处理复杂数据结构的场景中，Go语言本身对slice操作有严格的类型检查和边界检查，因此大多数常见的错误在编译时就能被捕获。然而，由于运行时动态分配内存和扩展slice的特性，上述提到的几种情况仍可能导致运行时panic。为了避免这些问题，需要仔细检查slice的索引和切片操作，确保它们始终在有效范围内。

六、slice的相关操作

slice底层数组指针的获取方式

为了调试方面、以及更好地说明slice的操作机制，有时候需要看到slice底层数组的位置

这里有三种方式可提供：

方式1、unsafe.SliceData

golang的标准库src\unsafe\unsafe.go里提供了一个很好的获取slice底层数组地址的函数

s0 := make([]int, 2, 3)
fmt.Println("\n\n", s0, "\n address :", unsafe.SliceData(s0), "\n len:", len(s0), "\n cap:", cap(s0))

输出结果：

方式2、%p

slice是个包含底层数组指针，len,cap的值，是个值，和其他变量一样，获取slice的地址可以用&，同时%p在fmt文档中介绍，也有着特殊的作用，参考fmt的the documentation，可以看到

%p可以打印slice底层数组的第一个元素的地址，也就是slice底层数组的地址

示例：

s0 := make([]int, 2, 3)

fmt.Printf("the address of the 0th element of the slice s0 :%p\n", s0)

输出结果：

方式3、reflect

示例：

s0 := make([]int, 2, 3)

fmt.Printf("underlying array of slice addr=%#v\n", *((*reflect.SliceHeader)(unsafe.Pointer(&s0))))

输出结果：

slice的长度

内置的len函数

示例：

s0 := []int{10, 20, 30, 40, 50}
fmt.Println("length of s0:", len(s0))

运行结果：

slice的容量

内置的cap函数

示例：

s0 := []int{10, 20, 30, 40, 50}
fmt.Println("capcity of s0:", cap(s0))

运行结果：

slice的遍历

基于索引的遍历

s0 := []int{10, 20, 30, 40, 50}

for i := 0; i < len(s0); i++ {
	fmt.Println(i, s0[i])
}

使用range实现遍历

s0 := []int{10, 20, 30, 40, 50}

for index, value := range s0 {
	fmt.Println(index, value)
}

slice的截取

如图，通过对slice的截取运算，并不会重新分配内存片段，而是通过指针的移动实现，新旧切片指向底层数组的指针仍然指向同一个内存片段

示例：

var ptr *int // 声明一个int类型的指针 
fmt.Printf("\n pointer occupy size: %d bytes\n", unsafe.Sizeof(ptr)) 

s0 := []int{10, 20, 30, 40, 50} 
fmt.Println("\n\n", s0, "\n address :", unsafe.SliceData(s0), "\n len:", len(s0), "\n cap:", cap(s0)) 

s1 := s0[2:4] 
fmt.Println("\n\n", s1, "\n address :", unsafe.SliceData(s1), "\n len:", len(s1), "\n cap:", cap(s1))

运行结果：

slice的追加

内置append函数

func append(slice []Type, elems ...Type) []Type

slice 是Type类型的目标切片
elems 是要追加到切片末尾的元素，也是Type类型
append() 函数返回一个新的切片，依然是Type类型，其中包含了原始切片的所有元素以及追加的元素

append不扩容的情况

示例：

s0 := make([]int, 3, 5)

fmt.Println("before append:s0 slice:", s0, " address of of the underlying array:", unsafe.SliceData(s0), " len(s0):", len(s0), "cap(s0):", cap(s0))

s0 = append(s0, 1, 2)

fmt.Println("after append:s0 slice:", s0, " address of of the underlying array:", unsafe.SliceData(s0), " len(s0):", len(s0), "cap(s0):", cap(s0))

运行结果：

追加前后underlying array没有变化，还是指向同一个底层数组

append扩容的情况

示例：

s0 := make([]int, 3, 5)

fmt.Println("before append:s0 slice:", s0, " address of of the underlying array:", unsafe.SliceData(s0), " len(s0)=", len(s0), "cap(s0)=", cap(s0))

s0 = append(s0, 1, 2, 3)

fmt.Println("after append:s0 slice:", s0, " address of of the underlying array:", unsafe.SliceData(s0), " len(s0)=", len(s0), "cap(s0)=", cap(s0))

运行结果：

append的返回值很重要

一个slice传递给append函数，append会接受这个slice的一个副本，然后append内部对这个副本操作，注意这个副本包含了跟原始slice实参同一个底层数组的引用，

如果不扩容，append返回这个副本的值，依然指向同原始slice实参同一个底层数组，容量没变，如果只是更改值，长度不变，如果是追加元素不扩容，则长度会变化，容量不变
如果需要扩容，append函数内部会先算出一个合理的新的容量值，新建一个这个容量值的数组，然后将老元素拷贝到这个数组里，再将新元素追加到这个数组的后面，然后将计算后新的长度和新的容量作为新slice的len和cap，然后将这个新数组的地址作为slice的指针段，然后返回新的slice，之前的副本的slice里的指针被GC收回
注意如果append内部在需要扩容的情况下，不返回这个新的slice，append的操作可能就被阉割隐匿了，是无效的；如果返回了，需要注意的是这个新的切片是否重新赋值给原始的切片变量，如果赋值给一个新的切片变量值，则是两个变量如下面的情况：
slice := make([]init,3,5)

slice = append(slice,1,2,3)
//返回给调用者的同一个变量


sliceNew := append(slice,1,2,3)
//返回给新的切片变量

//上面两种情况是两个不同的切片

append扩容依据及实现步骤：

检测切片容量：切片的扩容与不扩容的依据主要取决于当前切片的长度（len）和容量（cap）以及要追加的元素数量，当向切片追加元素时，如果追加后的长度（len(slice) + 追加元素数量）超过了当前容量（cap(slice)），切片就会发生扩容；如果追加后的长度不超过当前容量，切片就不会发生扩容，而是直接将新元素添加到切片的末尾，然后更新切片长度。
如果容量不够：如果切片的容量不足以容纳新元素，append 将会执行扩容操作：
选择新容量：Go 将根据一定的策略选择一个新的容量。一般来说，新容量会比当前容量大，并且通常会选择一个相对较大的值，以减少后续的扩容次数，现有的选择新容量的依据是：原 slice 的容量小于 1024，则新 slice 的容量将扩大为原来的 2 倍；如果原 slice 的容量大于 1024，则新的 slice 的容量将扩大为原来的 1.25 倍；但不同版本可能会有不同的扩容策略，具体可参考src\runtime\slice.go里的growslice函数
分配新内存：一旦确定了新的容量，Go 将分配一个新的数组，其长度为新容量，然后将当前切片的所有元素复制到新的数组中，将新元素追加到新数组的末尾。
更新切片：最后，Go 更新原始切片的指向新数组的指针，并更新切片的长度，
返回更新后的切片。

注：

由于底层数组的更改，append 操作可能会导致原始切片的引用失效，因此通常情况下，我们会将结果分配给原始切片变量，以确保更新后的切片引用得到正确的处理。
slice =append(slice,10)
直接调用slice =append(slice,10)的时候也许会记得，将结果返回给原始变量，但是append在某个如change函数内部调用，而调用change函数时，往往忘记返回而造成错误，如
func addItemToSlice(s []int) {
	s = append(s, 10)
}

slice的拷贝

浅拷贝

简单地将一个切片赋值给另一个变量并不会创建一个新的、独立的副本。相反，两个变量引用同一个底层数组，这意味着一个切片中的更改会反映在另一个切片中，

如果只是将src slice新赋值给一个新的dst变量，并不会创建一个新的，独立的副本，尽管两个变量都有这个各自的slice header，但是这两个值保存的内容是一样的，所以两个slice的array pointer是一样的，指向了一个底层数组，这种方式，修改一个 slice 的元素会影响到另一个 slice。

示例：

src := []int{10, 20, 30, 40, 50}
dst := src

fmt.Println("src slice:", src, " address of of the underlying array:", unsafe.SliceData(src), " len(src):", len(src), "cap(src):", cap(src))
fmt.Println("dst slice:", dst, " address of of the underlying array:", unsafe.SliceData(dst), " len(dst):", len(dst), "cap(dst):", cap(dst)

运行结果：

深拷贝

深拷贝后源切片和目的切片的指针部分指向了独立的两个underlying array，修改其中一个切片，不会对另一个切片产生影响

内置copy函数

func copy(dst, src []Type) int

dst 是目标 slice

src 是源 slice

Type 是 slice 中元素的类型。

int是返回的实际复制的元素

这个函数copy多少元素取决于源切片和目的切片长度的较小的值min(len(dst), len(src))，

如果目标切片为空或nil，则不会进行任何复制，需要注意的反而是src为nil的情况。

示例：

var src []int
dst := make([]int, len(src))

copy(dst, src)
fmt.Println(src == nil, dst == nil) // true false

fmt.Println("src slice:", src, " address of of the underlying array:", unsafe.SliceData(src), " len(src):", len(src), "cap(src):", cap(src))
fmt.Println("dst slice:", dst, " address of of the underlying array:", unsafe.SliceData(dst), " len(dst):", len(dst), "cap(dst):", cap(dst))

运行结果：

想实现src=nil的时候，拷贝后dst=nil

则可以加个判断

var src []int
dst := make([]int, len(src))

if src == nil {
    dst = nil
} else {
	copy(dst, src)
}
fmt.Println(src == nil, dst == nil) // true false

内置copy函数实现深拷贝

我们想用内置copy函数实现深拷贝的话，需要新建目的切片的时候要用dst := make([]int, len(src))这种方式。

示例：

src := []int{10, 20, 30, 40, 50}
dst := make([]int, len(src))

copy(dst, src)

fmt.Println("src slice:", src, " address of of the underlying array:", unsafe.SliceData(src), " len(src):", len(src), "cap(src):", cap(src))
fmt.Println("dst slice:", dst, " address of of the underlying array:", unsafe.SliceData(dst), " len(dst):", len(dst), "cap(dst):", cap(dst))

运行结果：

内置append函数实现深拷贝

示例：

src := []int{10, 20, 30, 40, 50}
dst := append([]int{}, src...)

fmt.Println("src slice:", src, " address of of the underlying array:", unsafe.SliceData(src), " len(src):", len(src), "cap(src):", cap(src))
fmt.Println("dst slice:", dst, " address of of the underlying array:", unsafe.SliceData(dst), " len(dst):", len(dst), "cap(dst):", cap(dst))
}

运行结果

七、slice在函数调用时是header传递

我们平时在开发中遇到的值传递和引用传递的特点是：

值传递的特点是：当使用值传递时，函数会接收参数的副本，而不是参数本身，意味着函数内部对参数的修改不会影响到原始实参的值
引用传递的特点是：函数会接收参数的引用（即内存地址），而不是参数的副本，意味着在函数内部对参数的修改会影响到原始数据

严格意义上将golang的函数传递是值传递，参数在传递给函数时，会复制一份副本传递给函数，只不过有的是普通的变量的副本，有的是包含了指针的变量的副本，而golang语言内部的、自动的、隐式的、引用或者解引用的对调用者不可见，往往给调用者造成困扰。

在我们给slice的函数传递方式定义为值传递或者引用传递之前，不妨先看两个示例：

change示例：

func change(s []int) {
	s[0] = 1
	fmt.Println("in change ", s)
}

func main() {

	s0 := []int{10, 20, 30, 40, 50}

	fmt.Println("before change ", s0)
	change(s0)
	fmt.Println("after chang ", s0)

}

运行结果：

上述的change示例，似乎slice是引用传递的结果，然后再看一个示例：

addItemToSlice示例

func addItemToSlice(s []int) {
	s = append(s, 10)

}

func main() {

	s0 := []int{10, 20, 30, 40, 50}

	fmt.Println("before change ", s0)
	addItemToSlice(s0)
	fmt.Println("after chang ", s0)

}

运行结果：

上述addItemToSlice示例，似乎是值传递的结果

分析：

slice的传递机制是这样的：前面说过slice是一个特殊的结构体

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

change函数接收了slice s0的一个副本，这个change内部对副本里指向的底层数组里元素更改，然后长度和容量没变化，函数返回，副本回收，原始实参s0的底层数组与副本指向是一样的，所以更改有效了。

addItemToSlice函数接收了slice s0的一个副本，这个addItemToSlice内部调用了append函数，并append函数对s0进行了扩容,新建了一个更大容量的slice,但是这个append并没有将这个新的slice f返回，而传递给addItemToSlice的slice副本，在函数调用完也就被GC回收了，所以更改是无效的。具体解释也可以参考本文章的append返回值很重要这一节对append函数的解释

总结

slice的函数传递时究竟是值传递还是引用传递，都是受限制，从语义上很容易误导，不能只从语义上简单归类于是值传递或者引用传递，否则会造成值传递不更改Slice，引用传递更改slice的错误结论，关键的是append函数是否将新的slice作为返回值返回给调用者，并且注意是否将这个新的切片返回给原来的切片变量，还是返回给了一个新的切片变量。

规避这种误导的最好方式slice在函数传递时是header传递或者是slice header传递，在channel的传递时亦是如此。