Golang切片Slice功能操作详情_Golang_

一、概述

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

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

二、切片

2.1 切片的定义

声明切片类型的基本语法如下：

var name []T

说明

• name:表示变量名
• T:表示切片中的元素类型

示例：

func main() { // 声明切片类型 var a []string //声明一个字符串切片 var b = []int{} //声明一个整型切片并初始化 var c = []bool{false, true} //声明一个布尔切片并初始化 var d = []bool{false, true} //声明一个布尔切片并初始化 fmt.Println(a) //[] fmt.Println(b) //[] fmt.Println(c) //[false true] fmt.Println(a == nil) //true fmt.Println(b == nil) //false fmt.Println(c == nil) //false // fmt.Println(c == d) //切片是引用类型，不支持直接比较，只能和nil比较 }

2.2 切片的长度和容量

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

指针指向第一个 slice 元素对应的底层数组元素的地址，要注意的是 slice 的第一个元素并不一定就是数组的第一个元素。

长度对应 slice 中元素的数目；长度不能超过容量，容量一般是从 slice 的开始位置到底层数据的结尾位置。

简单的讲，容量就是从创建切片索引开始的底层数组中的元素个数，而长度是切片中的元素个数。

内置的 len 和 cap 函数分别返回 slice 的长度和容量。

s := make([]string, 3, 5) fmt.Println(len(s)) // 3 fmt.Println(cap(s)) // 5

如果切片操作超出上限将导致一个 panic 异常。

s := make([]int, 3, 5) fmt.Println(s[10]) //panic: runtime error: index out of range [10] with length 3

2.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] // s := a[low:high] 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[2:len(a)] a[:3] // 等同于 a[0:3] a[:] // 等同于 a[0:len(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] // s := a[low:high] fmt.Printf("s:%v len(s):%v cap(s):%v\n", s, len(s), cap(s)) s2 := s[3:4] // 索引的上限是cap(s)而不是len(s) 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)，其他条件和简单切片表达式相同。

2.4 使用make()函数构造切片

上面都是基于数组来创建的切片，如果需要动态的创建一个切片，就需要使用内置的make()函数，

格式如下：

make([]T, size, cap)

说明：

• T:切片的元素类型
• size:切片中元素的数量
• cap:切片的容量

示例：

func main() { a := make([]int, 2, 10) fmt.Println(a) //[0 0] fmt.Println(len(a)) //2 fmt.Println(cap(a)) //10 }

上面代码中a的内部存储空间已经分配了10个，但实际上只用了2个。 容量并不会影响当前元素的个数，所以len(a)返回2，cap(a)则返回该切片的容量。

提示：

使用 make() 函数生成的切片一定发生了内存分配操作，但给定开始与结束位置（包括切片复位）的切片只是将新的切片结构指向已经分配好的内存区域，设定开始与结束位置，不会发生内存分配操作。

2.5 for range循环迭代切片

for range可以用来迭代切片里的每一个元素，如下所示：

func main(){ // 创建一个整型切片，并赋值 slice := []int{10, 20, 30, 40} // 迭代每一个元素，并显示其值 for index, value := range slice { fmt.Printf("Index: %d Value: %d\n", index, value) } }

运行结果：

Index: 0 Value: 10
Index: 1 Value: 20
Index: 2 Value: 30
Index: 3 Value: 40

• index：表示每一个元素的索引
• value：表示每一个元素的值

当迭代切片时，for range 会返回两个值，第一个值是当前迭代到的索引位置，第二个值是该位置对应元素值的一份副本，如下图所示。

注意 for range 返回的是每个元素的副本，而不是直接返回对该元素的引用。

示例：

func main(){ // 创建一个整型切片，并赋值 slice := []int{10, 20, 30, 40} // 迭代每个元素，并显示值和地址 for index, value := range slice { fmt.Printf("Value: %d Value-Addr: %X ElemAddr: %X\n", value, &value, &slice[index]) } }

运行结果：

Value: 10 Value-Addr: C00009E058 ElemAddr: C00009C120
Value: 20 Value-Addr: C00009E058 ElemAddr: C00009C128
Value: 30 Value-Addr: C00009E058 ElemAddr: C00009C130
Value: 40 Value-Addr: C00009E058 ElemAddr: C00009C138

因为迭代返回的变量是一个在迭代过程中根据切片依次赋值的新变量，所以 value 的地址总是相同的，要想获取每个元素的地址，需要使用切片变量和索引值（例如上面代码中的 &slice[index]）。

如果不需要索引值，也可以使用下划线_来忽略这个值，

代码如下所示：

func main(){ // 创建一个整型切片，并赋值 slice := []int{10, 20, 30, 40} // 迭代每个元素，并显示其值 for _, value := range slice { fmt.Printf("Value: %d\n", value) } }

运行结果;

Value: 10
Value: 20
Value: 30
Value: 40

for range 总是会从切片头部开始迭代。如果想对迭代做更多的控制，则可以使用传统的 for 循环，

代码如下所示:

func main(){ // 创建一个整型切片，并赋值 slice := []int{10, 20, 30, 40} // 从第三个元素开始迭代每个元素 for index := 2; index < len(slice); index++ { fmt.Printf("Index: %d Value: %d\n", index, slice[index]) } }

运行结果:

Index: 2 Value: 30
Index: 3 Value: 40

for range不仅仅可以用来遍历切片，它还可以用来遍历数组、字符串、map 或者通道等。

2.6 切片的本质

切片的本质就是对底层数组的封装，它包含了三个信息：底层数组的指针、切片的长度（len）和切片的容量（cap）。

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

相应示意图如下:

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

2.7 判断切片是否为空

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

三、切片功能操作

3.1 切片不能直接比较

切片之间是不能比较的，我们不能使用==操作符来判断两个切片是否含有全部相等元素。 切片唯一合法的比较操作是和nil比较。 一个nil值的切片并没有底层数组，一个nil<

提示： 本文由神整理自网络，如有侵权请联系本站删除！
本站声明：
1、本站所有资源均来源于互联网，不保证100%完整、不提供任何技术支持；
2、本站所发布的文章以及附件仅限用于学习和研究目的;不得将用于商业或者非法用途；否则由此产生的法律后果，本站概不负责！