Go语言基础之切片Slice

1. 介绍

1. 切片（slice）是对数组的一个连续片段的引用，其本身并不是数组，它指向底层的数组。切片是一个引用类型。

2. 切片默认指向一段连续内存区域，可以是数组，也可以是切片本身。

3. 一般使用make()创建，使用len()获取元素个数，cap()获取容量；

4. 如果多个slice指向相同的底层数组，其中一个的值改变会影响全部。

切片（Slice）是一个拥有相同类型元素的可变长度的序列。它是基于数组类型做的一层封装。它非常灵活，支持自动扩容。

切片是一个引用类型，它的内部结构包含地址、长度和容量。切片一般用于快速地操作一块数据集合。

2. 声明（创建）

声明新切片

1. 未被初始化的切片为nil

var name []Type

eg:

// 声明字符串切片
var strList []string
// 声明整型切片
var numList []int
// 声明一个空切片
var numListEmpty = []int{}
// 输出3个切片
fmt.Println(strList, numList, numListEmpty)
// 输出3个切片大小
fmt.Println(len(strList), len(numList), len(numListEmpty))
// 切片判定空的结果
fmt.Println(strList == nil)
fmt.Println(numList == nil)
fmt.Println(numListEmpty == nil)

// log
[] [] []
0 0 0
true
true
false

2. 类型推导式声明切片

[]<元素类型>{元素1, 元素2, …}

eg:

创建一个有 3 个整型元素的数组，并返回一个存储在 c 中的切片引用。

c := []int{6, 7, 8}

make 构造切片

1. 动态地创建一个切片，可以使用 make() 内建函数。该方式创建后已对切片进行初始化。
2. 使用 make() 函数生成的切片一定发生了内存分配操作，但给定开始与结束位置（包括切片复位）的切片只是将新的切片结构指向已经分配好的内存区域，设定开始与结束位置，不会发生内存分配操作。

make( []Type, size, cap )

• Type 是指切片的元素类型。

• size 指的是为这个类型分配多少个元素。

• cap 为预分配的元素数量，这个值设定后不影响 size，只是提前分配空间，降低多次分配空间造成性能问题

eg:

a := make([]int, 2)
b := make([]int, 2, 10)
fmt.Println(a, b)
fmt.Println(len(a), len(b), cap(b))
fmt.Println(a == nil)
// log
[0 0] [0 0]
2 2 10
false

make函数时，需要传入一个参数，指定切片的长度，例子中我们使用的是2，这时候切片的容量也是2。当然我们也可以单独指定切片的容量。make([]int, 2, 10) 表示长度是2，容量是10。

切片的容量必须>=长度，我们是不能创建长度大于容量的切片的。

基于数组或切片创建

从数组或切片生成新的切片拥有如下特性：

• 取出的元素数量为：结束位置（取出时不包含结束位置对应的索引） - 开始位置；

• 当缺省开始位置时，表示从开头开始取；

• 当缺省结束位置时，表示截取到末尾；

• 两者同时缺省时，与切片本身等效；

• 两者同时为 0 时，等效于空切片，一般用于切片复位。

• 根据索引位置取切片时，超界会报运行时错误。

slice：表示目标切片对象；
开始位置：对应目标切片对象的索引；
结束位置：对应目标切片的结束索引。

slice [开始位置 : 结束位置]

var a  = [3]int{1, 2, 3}
fmt.Println(a) // [1 2 3]
fmt.Println(a[1:2]) // [2]
fmt.Println(a[:2]) // [1 2]
fmt.Println(a[1:]) // [2 3]
fmt.Println(a[:]) // [1 2 3]
fmt.Println(a[0:0]) //[]

新的切片和原数组或原切片共用的是一个底层数组，所以当修改的时候，底层数组的值就会被改变，所以原切片的值也改变了。

package main

import "fmt"

func main() {
	slice := []int{1, 2, 3, 4, 5}
	newSlice := slice[1:3]
	newSlice[0] = 10
	fmt.Println(slice)
	fmt.Println(newSlice)
}

上面程序直接结果，修改新切片值 也会对原来切片产生影响，这个需要注意

[1 10 3 4 5]
[10 3]

但是如下将程序改成如下：

package main

import "fmt"

func main() {
	s := []int{1, 2, 3, 4, 5}
	newSlice := s[1:3]
	s = append(s,6)
	newSlice[0] = 10
	fmt.Println(s)
	fmt.Println(newSlice)
}

再次执行程序结果如下：

[1 2 3 4 5 6]
[10 3]

因为原有的切片发生了扩容 底层数组被重新创建 ，和原来的切片已经没有关系了 ，这个也需要特别注意。

切片的本质和数组

slice 源码地址在/runtime/slice.go ，带有 T 类型元素的切片由 []T 表示，其中T代表slice中元素的类型。切片在内部可由一个结构体类型表示，形式如下：

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

可见一个slice由三个部分构成：指针、长度和容量。其中：

1. array 指针指向第一个slice元素对应的底层数组元素的地址。

2. len长度对应slice中元素的数目；

3. cap容量一般是从slice的开始位置到底层数组的结尾位置。长度值不能超过容量值。

举个例子，现在有一个数组a := [8]int{0, 1, 2, 3, 4, 5, 6, 7}，切片s1 := a[:5]，相应示意图如下。

切片s2 := a[3:6]，相应示意图如下：

切片可以看做是对数组的封装，每个切片的底层数组结构中一定包含一个数组，切片与数组的关系总结如下：

1. 切片不是数组，但是切片底层指向数组
2. 切片本身长度是不一定的因此不可以比较，数组是可以的。
3. 切片是变长数组的替代方案，可以关联到指向的底层数组的局部或者全部。
4. 切片是引用传递（传递指针地址)，而数组是值传递（拷贝值）
5. 切片可以直接创建，引用其他切片或数组创建
6. 如果多个切片指向相同的底层数组，其中一个值的修改会影响所有的切片

切片的长度和容量

切片拥有自己的长度和容量，我们可以通过使用内置的len()函数求长度，使用内置的cap()函数求切片的容量。

切片的容量是指底层数组的从切片的第一个元素到最后一个元素的数量。直接定义的切片是在底层先生成一个相应长度的数组，再通过切片的表达式 数组[:] 生成。

通过下标越界访问时静态编译不在报错，运行时会报错。

s := make([]int, 5)当使用make函数初始化切片的是，如果不指定切片的容量，那么切片的长度就是切片的容量。对于底层数组容量是k的切片s[i:j]来说，长度：j-i，容量:k-i，s[1:3],长度就是3-1=2，容量是5-1=4

func TestSlice(t *testing.T) {
	a := []int{1, 2, 3, 4}
	b := a[:2]
	c := a[2:]
	t.Log(a, len(a), cap(a))
	t.Log(b, len(b), cap(b))
	t.Log(c, len(c), cap(c))
	t.Log("append data")
	b = append(b, 5)
	t.Log(a, len(a), cap(a))
	t.Log(b, len(b), cap(b))
	t.Log(c, len(c), cap(c))
}

[1 2 3 4] 4 4
 [1 2] 2 4
 [3 4] 2 2
append data
[1 2 5 4] 4 4
[1 2 5] 3 4
[5 4] 2 2

切片的长度是切片中的元素数。切片的容量是从创建切片索引开始的底层数组中元素数。

func main() {
	var x []int
	c := 0
	for i := 0; i < 100000; i++ {
		x = append(x, i)
		if c != cap(x){
			c = cap(x)
			fmt.Printf("index=%d cap=%d\n", i+1, c)
		}
	}
}

执行的结果,容量每次扩容是2倍，当容量达到1024时 会变成1.25,也就是每次按当前大小1/4增长,但是不一定是扩大1.25，会做内存对齐

index=1 cap=1
index=2 cap=2
index=3 cap=4
index=5 cap=8
index=9 cap=16
index=17 cap=32
index=33 cap=64
index=65 cap=128
index=129 cap=256
index=257 cap=512
index=513 cap=1024
index=1025 cap=1280
index=1281 cap=1696
index=1697 cap=2304
index=2305 cap=3072
index=3073 cap=4096
index=4097 cap=5120
index=5121 cap=7168
index=7169 cap=9216
index=9217 cap=12288
index=12289 cap=15360
index=15361 cap=19456
index=19457 cap=24576
index=24577 cap=30720
index=30721 cap=38912
index=38913 cap=49152
index=49153 cap=61440
index=61441 cap=76800
index=76801 cap=96256
index=96257 cap=120832

扩容源码：

3. 切片表达式

切片表达式从字符串、数组、指向数组或切片的指针构造子字符串或切片。它有两种变体：一种指定 low 和 high 两个索引界限值的简单的形式，另一种是除了 low 和 high 索引界限值外还指定容量的完整的形式。

简单切片表达式

切片的底层就是一个数组，所以我们可以基于数组通过切片表达式得到切片。 切片表达式中的low和high表示一个索引范围（左包含，右不包含），也就是下面代码中从数组 a 中选出1<= 索引值 < 4的元素组成切片 s，得到的切片长度 = high-low，容量等于得到的切片的底层数组的容量。

func main() {
	a := [5]int{1, 2, 3, 4, 5}
	s := a[1:3]  
	fmt.Printf("s:%v len(s):%v cap(s):%v\n", s, len(s), cap(s))
}

输出：

s:[2 3] len(s):2 cap(s):4

为了方便起见，可以省略切片表达式中的任何索引。省略了low则默认为 0；省略了high则默认为切片操作数的长度:

a[2:]  
a[:3]  
a[:]

注意：

对于数组或字符串，如果0 <= low <= high <= len(a)，则索引合法，否则就会索引越界（out of range）。

对切片再执行切片表达式时（切片再切片），high的上限边界是切片的容量cap(a)，而不是长度。常量索引必须是非负的，并且可以用 int 类型的值表示; 对于数组或常量字符串，常量索引也必须在有效范围内。如果low和high两个指标都是常数，它们必须满足low <= high。如果索引在运行时超出范围，就会发生运行时panic。

func main() {
	a := [5]int{1, 2, 3, 4, 5}
	s := a[1:3]  
	fmt.Printf("s:%v len(s):%v cap(s):%v\n", s, len(s), cap(s))
	s2 := s[3:4]  
	fmt.Printf("s2:%v len(s2):%v cap(s2):%v\n", s2, len(s2), cap(s2))
}

输出：

s:[2 3] len(s):2 cap(s):4
s2:[5] len(s2):1 cap(s2):1

完整切片表达式

对于数组，指向数组的指针，或切片 a(注意不能是字符串) 支持完整切片表达式：

a[low : high : max]

上面的代码会构造与简单切片表达式a[low: high]相同类型、相同长度和元素的切片。另外，它会将得到的结果切片的容量设置为max-low。在完整切片表达式中只有第一个索引值（low）可以省略；它默认为 0。

func main() {
	a := [5]int{1, 2, 3, 4, 5}
	t := a[1:3:5]
	fmt.Printf("t:%v len(t):%v cap(t):%v\n", t, len(t), cap(t))
}

输出结果：

t:[2 3] len(t):2 cap(t):4

完整切片表达式需要满足的条件是0 <= low <= high <= max <= cap(a)，其他条件和简单切片表达式相同。

4. append 添加元素

介绍

1. 使用 append() 函数为切片添加元素。

2. 如果最终长度未超过追加到slice的容量则返回原始slice，如果超过追加到的slice的容量则将重新分配内容地址并拷贝原始数据。

3. 如果空间不足以容纳足够多的元素，切片就会进行“扩容”，此时新切片的长度会发生改变。容量的扩展规律是按容量的 2 倍数进行扩充，例如 1、2、4、8、16……。

添加元素

尾部追加

var a []int
a = append(a, 1) // 追加1个元素
a = append(a, 1, 2, 3) // 追加多个元素, 手写解包方式
a = append(a, []int{1,2,3}...) // 追加一个切片, 切片需要解包

开头添加

切片开头添加元素一般都会导致内存的重新分配，而且会导致已有元素全部被复制 1 次，因此，从切片的开头添加元素的性能要比从尾部追加元素的性能差很多。

var a = []int{1,2,3}
a = append([]int{0}, a...) // 在开头添加1个元素
a = append([]int{-3,-2,-1}, a...) // 在开头添加1个切片

链式操作

因为 append 函数返回新切片的特性，所以切片也支持链式操作，我们可以将多个 append 操作组合起来。

var a []int
a = append(a[:i], append([]int{x}, a[i:]...)...) // 在第i个位置插入x
a = append(a[:i], append([]int{1,2,3}, a[i:]...)...) // 在第i个位置插入切片

注意

注意： 通过 var 声明的零值切片可以在append()函数直接使用，无需初始化。

var s []int
s = append(s, 1, 2, 3)

没有必要像下面的代码一样初始化一个切片再传入append()函数使用。

s := []int{}  
s = append(s, 1, 2, 3)

var s = make([]int)  
s = append(s, 1, 2, 3)

每个切片会指向一个底层数组，这个数组的容量够用就添加新增元素。当底层数组不能容纳新增的元素时，切片就会自动按照一定的策略进行 “扩容”，此时该切片指向的底层数组就会更换。“扩容” 操作往往发生在append()函数调用时，所以我们通常都需要用原变量接收 append 函数的返回值。

5. 切片的遍历

切片的遍历方式和数组是一致的，支持索引遍历和for range遍历。

func main() {
	s := []int{1, 3, 5}
	for i := 0; i < len(s); i++ {
		fmt.Println(i, s[i])
	}
	for index, value := range s {
		fmt.Println(index, value)
	}
}

6. 切片删除元素

介绍

1. Go语言并没有对删除切片元素提供专用的语法或者接口，需要使用切片本身的特性来删除元素

2. 根据要删除元素的位置有三种情况：

   • 从开头位置删除
   • 从中间位置删除
   • 从尾部删除（速度最快）

3. 删除开头的元素和删除尾部的元素都可以认为是删除中间元素操作的特殊情况。

4. Go语言中删除切片元素的本质是，以被删除元素为分界点，将前后两个部分的内存重新连接起来。

5. 连续容器的元素删除无论在任何语言中，都要将删除点前后的元素移动到新的位置，随着元素的增加，这个过程将会变得极为耗时，因此，当业务需要大量、频繁地从一个切片中删除元素时，如果对性能要求较高的话，就需要考虑更换其他的容器了（如双链表 list 等能快速从删除点删除元素）。

删除

从开头删除

删除开头的元素可以直接移动数据指针。

a := []int{1, 2, 3}
 // 删除开头1个元素
a = a[1:] // [2,3]

也可以不移动数据指针，但是将后面的数据向开头移动，可以用 append 原地完成（所谓原地完成是指在原有的切片数据对应的内存区间内完成，不会导致内存空间结构的变化）

a := []int{1, 2, 3}
a = append(a[:0], a[1:]...) // 删除开头1个元素
a = append(a[:0], a[N:]...) // 删除开头N个元素

还可以用 copy() 函数来删除开头的元素：

a := []int{1, 2, 3}
a = a[:copy(a, a[1:])] // 删除开头1个元素
a = a[:copy(a, a[N:])] // 删除开头N个元素

从中间位置删除

删除中间的元素，需要对剩余的元素进行一次整体挪动，同样可以用 append 或 copy 原地完成：

a = []int{1, 2, 3, ...}
a = append(a[:i], a[i+1:]...) // 删除中间1个元素
a = append(a[:i], a[i+N:]...) // 删除中间N个元素
a = a[:i+copy(a[i:], a[i+1:])] // 删除中间1个元素
a = a[:i+copy(a[i:], a[i+N:])] // 删除中间N个元素

从尾部删除

a = []int{1, 2, 3}
a = a[:len(a)-1] // 删除尾部1个元素
a = a[:len(a)-N] // 删除尾部N个元素

7. 切片的拷贝（copy）

首先我们来看一个问题：

func main() {
	a := []int{1, 2, 3, 4, 5}
	b := a
	fmt.Println(a) //[1 2 3 4 5]
	fmt.Println(b) //[1 2 3 4 5]
	b[0] = 1000
	fmt.Println(a) //[1000 2 3 4 5]
	fmt.Println(b) //[1000 2 3 4 5]
}

由于切片是引用类型，所以a和b其实都指向了同一块内存地址。修改b的同时a的值也会发生变化。

Go语言内建的copy()函数可以迅速地将一个切片的数据复制到另外一个切片空间中。

copy()函数的使用格式如下：

copy(destSlice, srcSlice []T)

其中：

• srcSlice: 数据来源切片
• destSlice: 目标切片

举个例子：

func main() {
	// copy()复制切片
	a := []int{1, 2, 3, 4, 5}
	c := make([]int, 5, 5)
	copy(c, a)     //使用copy()函数将切片a中的元素复制到切片c，再无引用关联
	fmt.Println(a) //[1 2 3 4 5]
	fmt.Println(c) //[1 2 3 4 5]
	c[0] = 1000
	fmt.Println(a) //[1 2 3 4 5]
	fmt.Println(c) //[1000 2 3 4 5]
}

介绍

1. 内置函数 copy() 可以将一个数组切片复制到另一个数组切片中。

2. 如果加入的两个数组切片不一样大，就会按照其中较小的那个数组切片的元素个数进行复制。

3. 目标切片必须分配过空间且足够承载复制的元素个数，并且来源和目标的类型必须一致，copy() 函数的返回值表示实际发生复制的元素个数。

// 将 srcSlice 复制到 destSlice
copy( destSlice, srcSlice []T) int

示例

切片大小不一致

slice1 := []int{1, 2, 3, 4, 5}
slice2 := []int{5, 4, 3}
copy(slice2, slice1) // 只会复制slice1的前3个元素到slice2中
fmt.Println(slice2)
copy(slice1, slice2) // 只会复制slice2的3个元素到slice1的前3个位置
fmt.Println(slice1)

// log
[1 2 3]
[1 2 3 4 5]

复制对原值影响

func main() {
	// 设置元素数量为1000
	const elementCount = 1000
	// 预分配足够多的元素切片
	srcData := make([]int, elementCount)
	// 将切片赋值
	for i := 0; i < elementCount; i++ {
		srcData[i] = i
	}
	// 引用切片数据
	refData := srcData
	// 预分配足够多的元素切片
	copyData := make([]int, elementCount)
	// 将数据复制到新的切片空间中
	copy(copyData, srcData)
	// 修改原始数据的第一个元素
	srcData[0] = 999
	// 打印引用切片的第一个元素
	fmt.Println(refData[0])
	// 打印复制切片的第一个和最后一个元素
	fmt.Println(copyData[0], copyData[elementCount-1])
	// 复制原始数据从4到6(不包含)
	copy(copyData, srcData[4:6])
	for i := 0; i < 5; i++ {
		fmt.Printf("%d ", copyData[i])
	}
}
// log
999
0 999
4 5 2 3 4 

8. nil和空切片

要检查切片是否为空，请始终使用len(s) == 0来判断，而不应该使用s == nil来判断。

nil slice表示数组不存在，empty slice表示集合为空。对slice为空的判断建议len函数。

var s []int         //nil值
var t = []int{}     //空值
a,_:= json.Marshal(s)
fmt.Println(string(a))

b,_:=json.Marshal(t)
fmt.Println(string(b))

需要注意的是分别对nil和空slice做json序列化是不同的， nil slice会变成null，empty是[]

null
[]

9. 多维切片

类似于数组，切片可以有多个维度。

sliceName 为切片的名字
sliceType为切片的类型，每个[]代表着一个维度，切片有几个维度就需要几个[]

var sliceName [][]...[]sliceType

package main

import (
    "fmt"
)

func main() {  
     pls := [][]string {
            {"C", "C++"},
            {"JavaScript"},
            {"Go", "Rust"},
            }
    for _, v1 := range pls {
        for _, v2 := range v1 {
            fmt.Printf("%s ", v2)
        }
        fmt.Printf("\n")
    }
}

输出：

C C++  
JavaScript  
Go Rust

总结

切片不能直接比较

切片之间是不能比较的，我们不能使用==操作符来判断两个切片是否含有全部相等元素。 切片唯一合法的比较操作是和nil比较。 一个nil值的切片并没有底层数组，一个nil值的切片的长度和容量都是 0。但是我们不能说一个长度和容量都是 0 的切片一定是nil，例如下面的示例：

var s1 []int         
s2 := []int{}        
s3 := make([]int, 0)

所以要判断一个切片是否是空的，要是用len(s) == 0来判断，不应该使用s == nil来判断。

1. 切片是引用类型，数组和切片有着紧密的关联，slice的底层是引用一个数组对象,可以理解为切片是对数组的封装

2. 一个slice由三个部分构成：指针、长度和容量。指针指向第一个slice元素对应的底层数组元素的地址。

3. 切片的长度是变化的，而数组的长度是固定不变的。

4. 多个不同slice之间可以共享底层的数据

参考感谢
数组，切片，以及 Map · 语雀 (yuque.com)
Go语言基础之切片 · 语雀 (yuque.com)
切片 · 语雀 (yuque.com)
Go基础——Slice · 语雀 (yuque.com)
array 数组、slice 切片、list 列表、map 集合 · 语雀 (yuque.com)
GoLang - 复合数据类型 · 语雀 (yuque.com)