一、概述

切片（Slice）是一個擁有相同類型元素的可變長度的序列。它是基于數(shù)組類型做的一層封裝。它非常靈活，支持自動擴容。

切片是一個引用類型，它的內(nèi)部結(jié)構(gòu)包含地址、長度和容量。切片一般用于快速地操作一塊數(shù)據(jù)集合。

二、切片

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 由三個部分構(gòu)成：指針 、 長度 和 容量 。

指針指向第一個 slice 元素對應(yīng)的底層數(shù)組元素的地址，要注意的是 slice 的第一個元素并不一定就是數(shù)組的第一個元素。

長度對應(yīng) slice 中元素的數(shù)目；長度不能超過容量，容量一般是從 slice 的開始位置到底層數(shù)據(jù)的結(jié)尾位置。

簡單的講，容量就是從創(chuàng)建切片索引開始的底層數(shù)組中的元素個數(shù)，而長度是切片中的元素個數(shù)。

內(nèi)置的 len 和 cap 函數(shù)分別返回 slice 的長度和容量。

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

如果切片操作超出上限將導(dǎo)致一個 panic 異常。

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

2.3 切片表達(dá)式

切片表達(dá)式從字符串、數(shù)組、指向數(shù)組或切片的指針構(gòu)造子字符串或切片。

它有兩種變體：

• 一種指定low和high兩個索引界限值的簡單的形式
• 另一種是除了low和high索引界限值外還指定容量的完整的形式。

簡單切片表達(dá)式

切片的底層就是一個數(shù)組，所以我們可以基于數(shù)組通過切片表達(dá)式得到切片。

切片表達(dá)式中的low和high表示一個索引范圍（左包含，右不包含），也就是下面代碼中從數(shù)組a中選出1<=索引值<4的元素組成切片s，得到的切片長度=high-low，容量等于得到的切片的底層數(shù)組的容量。

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

運行結(jié)果：

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

為了方便起見，可以省略切片表達(dá)式中的任何索引。

省略了low則默認(rèn)為0；省略了high則默認(rèn)為切片操作數(shù)的長度:

a[2:]  // 等同于 a[2:len(a)]
a[:3]  // 等同于 a[0:3]
a[:]   // 等同于 a[0:len(a)]

注意：

對于數(shù)組或字符串，如果0 <= low <= high <= len(a)，則索引合法，否則就會索引越界（out of range）。

對切片再執(zhí)行切片表達(dá)式時（切片再切片），high的上限邊界是切片的容量cap(a)，而不是長度。

常量索引必須是非負(fù)的，并且可以用int類型的值表示;對于數(shù)組或常量字符串，常量索引也必須在有效范圍內(nèi)。

如果low和high兩個指標(biāo)都是常數(shù)，它們必須滿足low <= high。如果索引在運行時超出范圍，就會發(fā)生運行時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

完整切片表達(dá)式

對于數(shù)組，指向數(shù)組的指針，或切片a(注意不能是字符串)支持完整切片表達(dá)式：

a[low : high : max]

上面的代碼會構(gòu)造與簡單切片表達(dá)式a[low: high]相同類型、相同長度和元素的切片。另外，它會將得到的結(jié)果切片的容量設(shè)置為max-low。在完整切片表達(dá)式中只有第一個索引值（low）可以省略；它默認(rèn)為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))
}

運行結(jié)果：

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

完整切片表達(dá)式需要滿足的條件是0 <= low <= high <= max <= cap(a)，其他條件和簡單切片表達(dá)式相同。

2.4 使用make()函數(shù)構(gòu)造切片

上面都是基于數(shù)組來創(chuàng)建的切片，如果需要動態(tài)的創(chuàng)建一個切片，就需要使用內(nèi)置的make()函數(shù)，

格式如下：

make([]T, size, cap)

說明：

• T:切片的元素類型
• size:切片中元素的數(shù)量
• cap:切片的容量

示例：

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

上面代碼中a的內(nèi)部存儲空間已經(jīng)分配了10個，但實際上只用了2個。 容量并不會影響當(dāng)前元素的個數(shù)，所以len(a)返回2，cap(a)則返回該切片的容量。

提示：

使用 make() 函數(shù)生成的切片一定發(fā)生了內(nèi)存分配操作，但給定開始與結(jié)束位置（包括切片復(fù)位）的切片只是將新的切片結(jié)構(gòu)指向已經(jīng)分配好的內(nèi)存區(qū)域，設(shè)定開始與結(jié)束位置，不會發(fā)生內(nèi)存分配操作。

2.5 for range循環(huán)迭代切片

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

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

運行結(jié)果：

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

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

當(dāng)?shù)衅瑫r，for range 會返回兩個值，第一個值是當(dāng)前迭代到的索引位置，第二個值是該位置對應(yīng)元素值的一份副本，如下圖所示。

注意 for range 返回的是每個元素的副本，而不是直接返回對該元素的引用。

示例：

func main(){
	// 創(chuàng)建一個整型切片，并賦值
	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])
	}
}

運行結(jié)果：

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

因為迭代返回的變量是一個在迭代過程中根據(jù)切片依次賦值的新變量，所以 value 的地址總是相同的，要想獲取每個元素的地址，需要使用切片變量和索引值（例如上面代碼中的 &slice[index]）。

如果不需要索引值，也可以使用下劃線_來忽略這個值，

代碼如下所示：

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

運行結(jié)果;

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

for range 總是會從切片頭部開始迭代。如果想對迭代做更多的控制，則可以使用傳統(tǒng)的 for 循環(huán)，

代碼如下所示:

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

運行結(jié)果:

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

for range不僅僅可以用來遍歷切片，它還可以用來遍歷數(shù)組、字符串、map 或者通道等。

2.6 切片的本質(zhì)

切片的本質(zhì)就是對底層數(shù)組的封裝，它包含了三個信息：底層數(shù)組的指針、切片的長度（len）和切片的容量（cap）。

舉個例子，現(xiàn)在有一個數(shù)組a := [8]int{0, 1, 2, 3, 4, 5, 6, 7}，切片s1 := a[:5]，

相應(yīng)示意圖如下:

切片s2 := a[3:6]，相應(yīng)示意圖如下：

2.7 判斷切片是否為空

要檢查切片是否為空，請始終使用len(s) == 0來判斷，而不應(yīng)該使用s == nil來判斷。

三、切片功能操作

3.1 切片不能直接比較

切片之間是不能比較的，我們不能使用==操作符來判斷兩個切片是否含有全部相等元素。 切片唯一合法的比較操作是和nil比較。 一個nil值的切片并沒有底層數(shù)組，一個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來判斷，不應(yīng)該使用s == nil來判斷。

3.2 切片的賦值拷貝

下面的代碼中演示了拷貝前后兩個變量共享底層數(shù)組，對一個切片的修改會影響另一個切片的內(nèi)容，這點需要特別注意。

func main() {
	s1 := make([]int, 3) //[0 0 0]
	s2 := s1             //將s1直接賦值給s2，s1和s2共用一個底層數(shù)組
	s2[0] = 100
	fmt.Println(s1) //[100 0 0]
	fmt.Println(s2) //[100 0 0]
}

由于切片是引用類型，所以s1和s2其實都指向了同一塊內(nèi)存地址。修改s2的同時s1的值也會發(fā)生變化。

3.3 使用copy()函數(shù)復(fù)制切片

Go語言內(nèi)建的copy()函數(shù)可以迅速地將一個切片的數(shù)據(jù)復(fù)制到另外一個切片空間中，copy()函數(shù)的使用格式如下：

copy( destSlice, srcSlice []T) int

• srcSlice: 數(shù)據(jù)來源切片
• destSlice: 目標(biāo)切片

copy()函數(shù)就是將 srcSlice 復(fù)制到 destSlice，目標(biāo)切片必須分配過空間且足夠承載復(fù)制的元素個數(shù)，并且來源和目標(biāo)的類型必須一致，copy() 函數(shù)的返回值表示實際發(fā)生復(fù)制的元素個數(shù)。

示例

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

雖然通過循環(huán)復(fù)制切片元素更直接，不過內(nèi)置的 copy() 函數(shù)使用起來更加方便，copy() 函數(shù)的第一個參數(shù)是要復(fù)制的目標(biāo) slice，第二個參數(shù)是源 slice，兩個 slice 可以共享同一個底層數(shù)組，甚至有重疊也沒有問題。

示例:

func main() {
	// 設(shè)置元素數(shù)量為1000
	const elementCount = 1000
	// 預(yù)分配足夠多的元素切片
	srcData := make([]int, elementCount)
	// 將切片賦值
	for i := 0; i < elementCount; i++ {
		srcData[i] = i
	}
	// 引用切片數(shù)據(jù)
	refData := srcData
	// 預(yù)分配足夠多的元素切片
	copyData := make([]int, elementCount)
	// 將數(shù)據(jù)復(fù)制到新的切片空間中
	copy(copyData, srcData)
	// 修改原始數(shù)據(jù)的第一個元素
	srcData[0] = 999
	// 打印引用切片的第一個元素
	fmt.Println(refData[0])
	// 打印復(fù)制切片的第一個和最后一個元素
	fmt.Println(copyData[0], copyData[elementCount-1])
	// 復(fù)制原始數(shù)據(jù)從4到6(不包含)
	copy(copyData, srcData[4:6])
	for i := 0; i < 5; i++ {
		fmt.Printf("%d ", copyData[i])
	}
}

運行結(jié)果:

999
0 999
4 5 2 3 4 

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

Go語言的內(nèi)建函數(shù)append()可以為切片動態(tài)添加元素。 可以一次添加一個元素，可以添加多個元素，也可以添加另一個切片中的元素（后面加…）。

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()函數(shù)直接使用，無需初始化。

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

沒有必要像下面的代碼一樣初始化一個切片再傳入append()函數(shù)使用。

s := []int{}  // 沒有必要初始化
s = append(s, 1, 2, 3)

var s = make([]int)  // 沒有必要初始化
s = append(s, 1, 2, 3)

每個切片會指向一個底層數(shù)組，這個數(shù)組的容量夠用就添加新增元素。當(dāng)?shù)讓訑?shù)組不能容納新增的元素時，切片就會自動按照一定的策略進(jìn)行“擴容”，此時該切片指向的底層數(shù)組就會更換。“擴容”操作往往發(fā)生在append()函數(shù)調(diào)用時，所以我們通常都需要用原變量接收append函數(shù)的返回值。

示例:

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

運行結(jié)果:

[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

從上面的結(jié)果可以看出：

• append()函數(shù)將元素追加到切片的最后并返回該切片。
• 切片numSlice的容量按照1，2，4，8，16這樣的規(guī)則自動進(jìn)行擴容，每次擴容后都是擴容前的2倍。

append()函數(shù)還支持一次性追加多個元素。

示例

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

3.5 從切片中刪除元素

Go語言并沒有對刪除切片元素提供專用的語法或者接口，需要使用切片本身的特性來刪除元素，根據(jù)要刪除元素的位置有三種情況，分別是從開頭位置刪除、從中間位置刪除和從尾部刪除，其中刪除切片尾部的元素速度最快。

從開頭位置刪除

刪除開頭的元素可以直接移動數(shù)據(jù)指針：

a = []int{1, 2, 3}
a = a[1:] // 刪除開頭1個元素
a = a[N:] // 刪除開頭N個元素

也可以不移動數(shù)據(jù)指針，但是將后面的數(shù)據(jù)向開頭移動，可以用 append 原地完成（所謂原地完成是指在原有的切片數(shù)據(jù)對應(yīng)的內(nèi)存區(qū)間內(nèi)完成，不會導(dǎo)致內(nèi)存空間結(jié)構(gòu)的變化）：

a = []int{1, 2, 3}
a = append(a[:0], a[1:]...) // 刪除開頭1個元素
a = append(a[:0], a[N:]...) // 刪除開頭N個元素

還可以用 copy() 函數(shù)來刪除開頭的元素：

a = []int{1, 2, 3}
a = a[:copy(a, a[1:])] // 刪除開頭1個元素
a = a[:copy(a, a[N:])] // 刪除開頭N個元素

從中間位置刪除

對于刪除中間的元素，需要對剩余的元素進(jì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個元素

刪除開頭的元素和刪除尾部的元素都可以認(rè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)
}

運行結(jié)果:

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

代碼的刪除過程可以使用下圖來描述:

Go語言中刪除切片元素的本質(zhì)是，以被刪除元素為分界點，將前后兩個部分的內(nèi)存重新連接起來。

3.6 切片的擴容策略

可以通過查看$GOROOT/src/runtime/slice.go源碼，其中擴容相關(guān)代碼如下：

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

從上面的代碼可以看出以下內(nèi)容：

• 首先判斷，如果新申請容量（cap）大于2倍的舊容量（old.cap），最終容量（newcap）就是新申請的容量（cap）。
• 否則判斷，如果舊切片的長度小于1024，則最終容量(newcap)就是舊容量(old.cap)的兩倍，即（newcap=doublecap），
• 否則判斷，如果舊切片長度大于等于1024，則最終容量（newcap）從舊容量（old.cap）開始循環(huán)增加原來的1/4，即（newcap=old.cap,for {newcap += newcap/4}）直到最終容量（newcap）大于等于新申請的容量(cap)，即（newcap >= cap）
• 如果最終容量（cap）計算值溢出，則最終容量（cap）就是新申請容量（cap）。

需要注意的是，切片擴容還會根據(jù)切片中元素的類型不同而做不同的處理，比如int和string類型的處理方式就不一樣。

到此這篇關(guān)于Golang切片Slice功能操作詳情的文章就介紹到這了,更多相關(guān)Golang切片內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論