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值的切片的长度和容量都是0。

可是咱们不能说一个长度和容量都是0的切片一定是nil，例如下面的示例：

var s1 []int         //len(s1)=0;cap(s1)=0;s1==nil
s2 := []int{}        //len(s2)=0;cap(s2)=0;s2!=nil
s3 := make([]int, 0) //len(s3)=0;cap(s3)=0;s3!=nil

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

3.2 切片的赋值仿制

下面的代码中演示了仿制前后两个变量同享底层数组，对一个切片的修正会影响另一个切片的内容，这点需求特别留意。

func main() {
	s1 := make([]int, 3) //[0 0 0]
	s2 := s1             //将s1直接赋值给s2，s1和s2共用一个底层数组
	s2[0] = 100
	fmt.Println(s1) //[100 0 0]
	fmt.Println(s2) //[100 0 0]
}

由于切片是引证类型，所以s1和s2其实都指向了同一块内存地址。修正s2的同时s1的值也会产生变化。

3.3 运用copy()函数仿制切片

Go言语内建的copy()函数能够迅速地将一个切片的数据仿制到另外一个切片空间中，copy()函数的运用格式如下：

copy( destSlice, srcSlice []T) int

srcSlice: 数据来历切片
destSlice: 方针切片

copy()函数便是将 srcSlice 仿制到 destSlice，方针切片有必要分配过空间且满足承载仿制的元素个数，而且来历和方针的类型有必要一致，copy() 函数的回来值表明实际产生仿制的元素个数。

示例

func main(){
	slice1 := []int{1, 2, 3, 4, 5}
	slice2 := []int{5, 4, 3}
	//copy(slice2, slice1) // 只会仿制slice1的前3个元素到slice2中
	copy(slice1, slice2) // 只会仿制slice2的3个元素到slice1的前3个方位
	for _, value := range slice1 {
		fmt.Printf("%d \t", value)
	}
	//for _, value := range slice2 {
	//	fmt.Printf("%d \t", value)
	//}
}

尽管经过循环仿制切片元素更直接，不过内置的 copy() 函数运用起来愈加便利，copy() 函数的第一个参数是要仿制的方针 slice，第二个参数是源 slice，两个 slice 能够同享同一个底层数组，甚至有堆叠也没有问题。

示例

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])
	}
}

运转成果

999
0 999
4 5 2 3 4

3.4 append()方法为切片添加元素

Go言语的内建函数append()能够为切片动态添加元素。能够一次添加一个元素，能够添加多个元素，也能够添加另一个切片中的元素（后面加…）。

func main(){
	var s []int
	s = append(s, 1)        // [1]
	s = append(s, 2, 3, 4)  // [1 2 3 4]
	s2 := []int{5, 6, 7}  
	s = append(s, s2...)    // [1 2 3 4 5 6 7]
}

留意：经过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函数的回来值。

示例

func main() {
	//append()添加元素和切片扩容
	var numSlice []int
	for i := 0; i < 10; i++ {
		numSlice = append(numSlice, i)
		fmt.Printf("%v  len:%d  cap:%d  ptr:%p\n", numSlice, len(numSlice), cap(numSlice), numSlice)
	}
}

运转成果

[0]  len:1  cap:1  ptr:0xc00009e058
[0 1]  len:2  cap:2  ptr:0xc00009e0a0
[0 1 2]  len:3  cap:4  ptr:0xc00009c140
[0 1 2 3]  len:4  cap:4  ptr:0xc00009c140
[0 1 2 3 4]  len:5  cap:8  ptr:0xc0000b2100
[0 1 2 3 4 5]  len:6  cap:8  ptr:0xc0000b2100
[0 1 2 3 4 5 6]  len:7  cap:8  ptr:0xc0000b2100
[0 1 2 3 4 5 6 7]  len:8  cap:8  ptr:0xc0000b2100
[0 1 2 3 4 5 6 7 8]  len:9  cap:16  ptr:0xc0000d0080
[0 1 2 3 4 5 6 7 8 9]  len:10  cap:16  ptr:0xc0000d0080

从上面的成果能够看出：

append()函数将元素追加到切片的终究并回来该切片。
切片numSlice的容量依照1，2，4，8，16这样的规矩主动进行扩容，每次扩容后都是扩容前的2倍。

append()函数还支撑一次性追加多个元素。

示例

var citySlice []string
// 追加一个元素
citySlice = append(citySlice, "北京")
// 追加多个元素
citySlice = append(citySlice, "上海", "广州", "深圳")
// 追加切片
a := []string{"成都", "重庆"}
citySlice = append(citySlice, a...)
fmt.Println(citySlice) //[北京 上海 广州 深圳 成都 重庆]

3.5 从切片中删去元素

Go言语并没有对删去切片元素供给专用的语法或许接口，需求运用切片本身的特性来删去元素，依据要删去元素的方位有三种情况，别离是从最初方位删去、从中心方位删去和从尾部删去，其间删去切片尾部的元素速度最快。

从最初方位删去

删去最初的元素能够直接移动数据指针：

a = []int{1, 2, 3}
a = a[1:] // 删去最初1个元素
a = a[N:] // 删去最初N个元素

也能够不移动数据指针，可是将后面的数据向最初移动，能够用 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个元素

删去最初的元素和删去尾部的元素都能够以为是删去中心元素操作的特殊情况，下面来看一个示例。

示例

删去切片指定方位的元素

func main(){
	seq := []string{"a", "b", "c", "d", "e"}
	// 指定删去方位
	index := 2
	// 查看删去方位之前的元素和之后的元素
	fmt.Println(seq[:index], seq[index+1:])
	// 将删去点前后的元素连接起来
	seq = append(seq[:index], seq[index+1:]...)
	fmt.Println(seq)
}

运转成果

[a b] [d e]
[a b d e]

代码的删去过程能够运用下图来描述。

Go言语中删去切片元素的实质是，以被删去元素为分界点，将前后两个部分的内存从头连接起来。

3.6 切片的扩容战略

能够经过查看$GOROOT/src/runtime/slice.go源码，其间扩容相关代码如下：

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
		}
	}
}

从上面的代码能够看出以下内容：

首先判别，假如新请求容量（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）。

需求留意的是，切片扩容还会依据切片中元素的类型不同而做不同的处理，比方int和string类型的处理方式就不相同。

附参考文章链接

www.liwenzhou.com/posts/Go/06…

c.biancheng.net/view/27.htm…

Golang切片和功能操作详解

一、概述

二、切片

2.1 切片的界说

2.2 切片的长度和容量

2.3 切片表达式

简略切片表达式

完好切片表达式

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

2.5 for range循环迭代切片

2.6 切片的实质

2.7 判别切片是否为空

三、切片功用操作

3.1 切片不能直接比较

3.2 切片的赋值仿制

3.3 运用copy()函数仿制切片

3.4 append()方法为切片添加元素

3.5 从切片中删去元素

从最初方位删去

从中心方位删去

从尾部删去

3.6 切片的扩容战略

相关文章

你好， 2023，最该问自己的7个问题

C++ 基础相关:构造函数相关话题

在Jetpack Compose中实现嵌套吸顶效果的方案

在 KubeSphere 中开启新一代云原生数仓 Databend

作者信息