1. 切片定義

Go 語言切片是對數(shù)組的抽象。 Go 中提供了一種靈活，功能強悍的內(nèi)置類型切片(“動態(tài)數(shù)組”)，與數(shù)組相比切片的長度是不固定的，可以追加元素，在追加時可能使切片的容量增大。

切片（slice）是對數(shù)組的一個連續(xù)片段的引用，所以切片是一個引用類型，這個片段可以是整個數(shù)組，也可以是由起始和終止索引標識的一些項的子集，需要注意的是，終止索引標識的項不包括在切片內(nèi)。

SliceHeader 是切片在 go 的底層結(jié)構(gòu)。

type SliceHeader struct {array unsafe.Pointerlen   intcap   int
}

所有切片的大小相同；

• array: 是指向底層數(shù)組的指針；
• len: 是切片的長度，即切片中當前元素的個數(shù)；
• cap: 是底層數(shù)組的長度，也是切片的最大容量，cap 值永遠大于等于 len 值；

將一個 slice 變量分配給另一個變量只會復制三個機器字。所以 拷貝大切片跟小切片的代價應該是一樣的。

我們其實可以把切片看做是對數(shù)組的一層簡單的封裝，因為在每個切片的底層數(shù)據(jù)結(jié)構(gòu)中，一定會包含一個數(shù)組。數(shù)組可以被叫做切片的底層數(shù)組，而切片也可以被看作是對數(shù)組的某個連續(xù)片段的引用。

Go 語言中切片的內(nèi)部結(jié)構(gòu)包含地址、大小和容量，切片一般用于快速地操作一塊數(shù)據(jù)集合，如果將數(shù)據(jù)集合比作切糕的話，切片就是你要的“那一塊”，切的過程包含從哪里開始（切片的起始位置）及切多大（切片的大小），容量可以理解為裝切片的口袋大小，如下圖所示。

聲明一個未指定大小的數(shù)組來定義切片：

var varName []type

切片不需要說明長度。或使用 make() 函數(shù)來創(chuàng)建切片:

var varName []type = make([]type, len)// 也可以簡寫為varName := make([]type, len)

也可以指定容量，其中 capacity 為可選參數(shù)。

make([]type, length, capacity)

其中 type 是指切片的元素類型， length 指的是為這個類型分配多少個元素， capacity 為預分配的元素數(shù)量，這個值設定后不影響 size，只是能提前分配空間，降低多次分配空間造成的性能問題，在初始化 的時候盡量補全 cap。這里 length 是數(shù)組的長度并且也是切片的初始長度。

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

其中 a 和 b 均是預分配 2 個元素的切片，只是 b 的內(nèi)部存儲空間已經(jīng)分配了 10 個，但實際使用了 2 個元素。容量不會影響當前的元素個數(shù)，因此 a 和 b 取 len 都是 2。

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

Go 編譯器會自動為每個新創(chuàng)建的切片，建立一個底層數(shù)組，默認底層數(shù)組的長度與切片初始元素個數(shù)相同。

2. 切片初始化

1. 直接初始化切片，[] 表示是切片類型，{1,2,3} 初始化值依次是 1,2,3， 其 cap=len=3

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

2. 切片默認指向一段連續(xù)內(nèi)存區(qū)域，可以是數(shù)組，也可以是切片本身。初始化切片 s，是數(shù)組 arr 的引用

s := arr[:]

3. 將 arr 中從下標 startIndex 到 endIndex-1 下的元素創(chuàng)建為一個新的切片

s := arr[startIndex:endIndex]

從數(shù)組生成切片，代碼如下：

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

arr := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
sl := arr[3:7:9]

基于數(shù)組創(chuàng)建的切片，它的起始元素從 low 所標識的下標值開始，切片的長度（len）是 high - low，它的容量是 max - low。而且，由于切片 sl 的底層數(shù)組就是數(shù)組 arr，對切片 sl 中元素的修改將直接影響數(shù)組 arr 變量。比如，如果我們將切片的第一個元素加 10，那么數(shù)組 arr 的第四個元素將變?yōu)?14：

sl[0] += 10
fmt.Println("arr[3] =", arr[3]) // 14

在 Go 語言中，數(shù)組更多是“退居幕后”，承擔的是底層存儲空間的角色。切片就是數(shù)組的“描述符”，也正是因為這一特性，切片才能在函數(shù)參數(shù)傳遞時避免較大性能開銷。因為我們傳遞的并不是數(shù)組本身，而是數(shù)組的“描述符”，而這個描述符的大小是固定的（見上面的三元組結(jié)構(gòu)），無論底層的數(shù)組有多大，切片打開的“窗口”長度有多長，它都是不變的。此外，我們在進行數(shù)組切片化的時候，通常省略 max，而 max 的默認值為數(shù)組的長度。

4. 缺省 endIndex 時將表示一直到 arr 的最后一個元素

s := arr[startIndex:]

5. 缺省 startIndex 時將表示從 arr 的第一個元素開始

s := arr[:endIndex]

6. 通過切片 s 初始化切片 s1

s1 := s[startIndex:endIndex]

7. 通過內(nèi)置函數(shù) make() 初始化切片 s，[]int 標識為其元素類型為 int 的切片，由 make 創(chuàng)建的切片各元素默認為該類型零值。

s :=make([]int, len, cap)

從數(shù)組或切片生成新的切片擁有如下特性：

• 取出的元素數(shù)量為：結(jié)束位置 - 開始位置；

• 取出元素不包含結(jié)束位置對應的索引，切片最后一個元素使用 slice[len(slice)] 獲取；

• 當缺省開始位置時，表示從連續(xù)區(qū)域開頭到結(jié)束位置；

• 當缺省結(jié)束位置時，表示從開始位置到整個連續(xù)區(qū)域末尾；

• 兩者同時缺省時，與切片本身等效；

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

a 是一個擁有 3 個元素的切片，將 a 切片使用 a[:] 進行操作后，得到的切片與 a 切片一致。

• 兩者同時為 0 時，等效于空切片，一般用于切片復位。

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

根據(jù)索引位置取切片 slice 元素值時，取值范圍是（0～len(slice)-1），超界會報運行時錯誤，生成切片時，結(jié)束位置可以填寫 len(slice) 但不會報錯。

3. 數(shù)組和切片聲明差異

數(shù)組類型的值（以下簡稱數(shù)組）的長度是固定的，而切片類型的值（以下簡稱切片）是可變長的。

如果在 [] 運算符里指定了一個值，那么創(chuàng)建的就是數(shù)組而不是切片。只有不指定值的時候，才會創(chuàng)建切片，如下所示。

// 創(chuàng)建有3個元素的整型數(shù)組
array := [3]int{10, 20, 30}// 創(chuàng)建長度和容量都是3的整型切片
slice := []int{10, 20, 30}

4. 字符串和切片轉(zhuǎn)換

s := "hello"
a := []byte(s)	// 將字符串轉(zhuǎn)換為 byte 類型切片
b := []rune(s)	// 將字符串轉(zhuǎn)換為 rune 類型切片

5. len() 和 cap() 函數(shù)

數(shù)組的容量永遠等于其長度，都是不可變的。

切片是可索引的，并且可以由 len() 方法獲取長度。

切片提供了計算容量的方法 cap() 可以測量切片最長可以達到多少。

package mainimport "fmt"func main() {var numbers = make([]int,3,5)printSlice(numbers)
}func printSlice(x []int){fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

輸出結(jié)果為：

len=3 cap=5 slice=[0 0 0]

示例：

func main() {s1 := make([]int, 5)                           // 用make函數(shù)初始化切片時，如果不指明其容量，那么它就會和長度一致fmt.Printf("The length of s1: %d\n", len(s1))   // 5fmt.Printf("The capacity of s1: %d\n", cap(s1)) // 5fmt.Printf("The value of s1: %d\n", s1)         // [0 0 0 0 0]s2 := make([]int, 5, 8)fmt.Printf("The length of s2: %d\n", len(s2))   // 5fmt.Printf("The capacity of s2: %d\n", cap(s2)) // 8fmt.Printf("The value of s2: %d\n", s2)         // [0 0 0 0 0]
}

當我們通過切片表達式基于某個數(shù)組或切片生成新切片的時候，如下

func main() {s3 := []int{1, 2, 3, 4, 5, 6, 7, 8}s4 := s3[3:6]fmt.Printf("The length of s4: %d\n", len(s4))   // 3fmt.Printf("The capacity of s4: %d\n", cap(s4)) // 5fmt.Printf("The value of s4: %d\n", s4)         // [4 5 6]
}

切片的容量代表了它的底層數(shù)組的長度，但這僅限于使用 make 函數(shù)或者切片值字面量初始化切片的情況。

更通用的規(guī)則是：一個切片的容量可以被看作是透過這個窗口最多可以看到的底層數(shù)組中元素的個數(shù)。由于 s4 是通過在 s3 上施加切片操作得來的，所以 s3 的底層數(shù)組就是 s4 的底層數(shù)組。又因為，在底層數(shù)組不變的情況下，切片代表的窗口可以向右擴展，直至其底層數(shù)組的末尾。所以，s4 的容量就是其底層數(shù)組的長度 8 減去上述切片表達式中的那個起始索引 3，即 5。

	s5 := s4[:cap(s4)]fmt.Printf("The length of s5: %d\n", len(s5))   // 5fmt.Printf("The capacity of s5: %d\n", cap(s5)) // 5fmt.Printf("The value of s5: %#v\n", s5)        // []int{4, 5, 6, 7, 8}

6. 空切片與 nil 切片

切片是動態(tài)結(jié)構(gòu)，只能與 nil 判定相等，不能互相判定相等。一個切片在未初始化之前默認為 nil ，長度為 0，創(chuàng)建 nil 切片

// 創(chuàng)建nil整型切片
var varName []int

只要在聲明時不做任何初始化，就會創(chuàng)建一個 nil 切片。

利用初始化，通過聲明一個切片可以創(chuàng)建一個空切片

// 使用make創(chuàng)建空的整型切片
slice := make([]int, 0)// 使用切片字面量創(chuàng)建空的整型切片
slice := []int{}

不管是使用 nil 切片還是空切片，對其調(diào)用內(nèi)置函數(shù) append 、 len 和 cap的效果都是一樣的。

實例如下：

package mainimport "fmt"func main() {var numbers []intprintSlice(numbers)if(numbers == nil){fmt.Printf("切片是空的")}
}func printSlice(x []int){fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

輸出結(jié)果為：

len=0 cap=0 slice=[]
切片是空的

空切片和 nil 切片對比

var s1 []int
var s2 = []int{}

• s1 是聲明，還沒初始化，是 nil 值，len 和 cap 是 0，array 是 nil, 底層沒有分配內(nèi)存空間。和nil 比較返回 true
• s2 初始化了，不是 nil 值，是空切片， 底層分配了內(nèi)存空間，有地址。和 nil 比較返回 false

更推薦第一種寫法

package mainimport "fmt"func main() {
var sl1 []int
var sl2 = []int{}fmt.Printf("%T, %v, %p\n", sl1, sl1, sl1) // []int, [], 0x0
fmt.Printf("%T, %v, %p\n", sl2, sl2, sl2) // []int, [], 某個地址值fmt.Println(sl1 == nil) // true
fmt.Println(sl2 == nil) // falsefmt.Println(len(sl1), cap(sl1)) // 0, 0
fmt.Println(len(sl2), cap(sl2)) // 0, 0// fmt.Println(sl1[0]) 下標越界 panic
// fmt.Println(sl2[0]) 下標越界 panicsl1 = append(sl1, 1) // 可以 append 操作
sl2 = append(sl2, 1) // 可以 append 操作
}

7. 切片截取

可以通過設置下限及上限來設置截取切片 [lower-bound:upper-bound]，實例如下：

package mainimport "fmt"func main() {/* 創(chuàng)建切片 */numbers := []int{0,1,2,3,4,5,6,7,8}   printSlice(numbers)/* 打印原始切片 */fmt.Println("numbers ==", numbers)/* 打印子切片從索引1(包含) 到索引4(不包含)*/fmt.Println("numbers[1:4] ==", numbers[1:4])/* 默認下限為 0*/fmt.Println("numbers[:3] ==", numbers[:3])/* 默認上限為 len(s)*/fmt.Println("numbers[4:] ==", numbers[4:])numbers1 := make([]int,0,5)printSlice(numbers1)/* 打印子切片從索引  0(包含) 到索引 2(不包含) */number2 := numbers[:2]printSlice(number2)/* 打印子切片從索引 2(包含) 到索引 5(不包含) */number3 := numbers[2:5]printSlice(number3)}func printSlice(x []int){fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

8. append() 函數(shù)

Go 語言的內(nèi)建函數(shù) append() 可以為切片動態(tài)添加元素，不過需要注意的是，在使用 append() 函數(shù)為切片動態(tài)添加元素時，如果空間不足以容納足夠多的元素，切片就會進行“擴容”，此時新切片的長度會發(fā)生改變。

切片在擴容時，容量的擴展規(guī)律是按容量的 2 倍數(shù)進行擴充，例如 1、2、4、8、16……

一旦一個切片無法容納更多的元素，Go 語言就會想辦法擴容。但它并不會改變原來的切片，而是會生成一個容量更大的切片，然后將把原有的元素和新元素一并拷貝到新切片中。

在一般的情況下，你可以簡單地認為新切片的容量（以下簡稱新容量）將會是原切片容量（以下簡稱原容量）的 2 倍。但是，當原切片的長度（以下簡稱原長度）大于或等于 1024 時，Go 語言將會以原容量的 1.25 倍作為新容量的基準（以下新容量基準）。新容量基準會被調(diào)整（不斷地與 1.25 相乘），直到結(jié)果不小于原長度與要追加的元素數(shù)量之和（以下簡稱新長度）。最終，新容量往往會比新長度大一些，當然，相等也是可能的。

另外，如果我們一次追加的元素過多，以至于使新長度比原容量的 2 倍還要大，那么新容量就會以新長度為基準。注意，與前面那種情況一樣，最終的新容量在很多時候都要比新容量基準更大一些。

package mainimport "fmt"func main() {var a []inta = append(a, 1)                 // 追加1個元素a = append(a, 1, 2, 3)           // 追加多個元素, 手寫解包方式a = append(a, []int{1, 2, 3}...) // 追加一個切片, 切片需要解包fmt.Println(a)var numbers []intfor i := 0; i < 5; i++ {numbers = append(numbers, i)fmt.Printf("len: %d  cap: %d pointer: %p\n", len(numbers), cap(numbers), numbers)}
}

輸出結(jié)果：

[1 1 2 3 1 2 3]
len: 1  cap: 1 pointer: 0xc0000180d0
len: 2  cap: 2 pointer: 0xc0000180f0
len: 3  cap: 4 pointer: 0xc0000141a0
len: 4  cap: 4 pointer: 0xc0000141a0
len: 5  cap: 8 pointer: 0xc00001a180

從內(nèi)存地址可以看出：

每次進行 append 之后，如果沒有擴容則是在同一個切片上增加元素，如果已經(jīng)擴容，則會返回一個新的切片，因為內(nèi)存地址不一樣

除了在切片的尾部追加，我們還可以在切片的開頭添加元素：

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

在切片開頭添加元素一般都會導致內(nèi)存的重新分配，而且會導致已有元素全部被復制 1 次，因此，從切片的開頭添加元素的性能要比從尾部追加元素的性能差很多。

因為 append 函數(shù)返回新切片的特性，所以切片也支持鏈式操作，我們可以將多個 append 操作組合起來，實現(xiàn)在切片中間插入元素：

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個位置插入切片

每個添加操作中的第二個 append 調(diào)用都會創(chuàng)建一個臨時切片，并將 a[i:] 的內(nèi)容復制到新創(chuàng)建的切片中，然后將臨時創(chuàng)建的切片再追加到 a[:i] 中。

package mainimport "fmt"func main() {var a = []int{1, 2, 3}a = append([]int{0}, a...)          // 在開頭添加1個元素a = append([]int{-3, -2, -1}, a...) // 在開頭添加1個切片fmt.Println(a)                      // [-3 -2 -1 0 1 2 3]var b []intb = append(a[:0], append([]int{10}, b[0:]...)...)      // 在第0個位置插入10b = append(a[:0], append([]int{1, 2, 3}, b[0:]...)...) // 在第0個位置插入切片fmt.Println(b)                                         // [1 2 3 10]
}

問題 2：切片的底層數(shù)組什么時候會被替換？

確切地說，一個切片的底層數(shù)組永遠不會被替換。為什么？雖然在擴容的時候 Go 語言一定會生成新的底層數(shù)組，但是它也同時生成了新的切片。它只是把新的切片作為了新底層數(shù)組的窗口，而沒有對原切片，及其底層數(shù)組做任何改動。

請記住，在無需擴容時，append 函數(shù)返回的是指向原底層數(shù)組的新切片，而在需要擴容時，append 函數(shù)返回的是指向新底層數(shù)組的新切片。所以，嚴格來講，“擴容”這個詞用在這里雖然形象但并不合適。不過鑒于這種稱呼已經(jīng)用得很廣泛了，我們也沒必要另找新詞了。

只要新長度不會超過切片的原容量，那么使用 append 函數(shù)對其追加元素的時候就不會引起擴容。

基于一個已有數(shù)組建立的切片，一旦追加的數(shù)據(jù)操作觸碰到切片的容量上限（實質(zhì)上也是數(shù)組容量的上界)，切片就會和原數(shù)組解除“綁定”，后續(xù)對切片的任何修改都不會反映到原數(shù)組中了。

9. copy() 函數(shù)

Go 語言的內(nèi)置函數(shù) copy() 可以將一個數(shù)組切片復制到另一個數(shù)組切片中，如果加入的兩個數(shù)組切片不一樣大，就會按照其中較小的那個數(shù)組切片的元素個數(shù)進行復制。

copy() 函數(shù)的使用格式如下：

copy(destSlice, srcSlice) int

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

package mainimport "fmt"func main() {a := []int{10, 20, 30, 4, 5}slice2 := []int{5, 4, 3}copy(slice2, a)     // 只會復制 a 的前3個元素到slice2中fmt.Println(slice2) // [10 20 30]slice2 = []int{5, 4, 3}b := []int{0, 0, 0, 0, 0}ret := copy(b, slice2)      // 只會復制slice2的3個元素到b 的前3個位置fmt.Println(b)              // [5 4 3 0 0]fmt.Println("ret is ", ret) // ret is  3
}

9.1 切片索引生成的切片與原來的切片是同一個地址

如果多個切片指向同一底層數(shù)組，那么對其中一個切片的改變影響其它的切片。

package mainimport "fmt"func main() {s1 := []int{1, 2, 3, 4, 5}s2 := s1[0:3]	// 只是基于同一個底層數(shù)組生成了一個新的切片（或者說窗口）// s2 := make([]int, 3)copy(s2, s1)s2 = append(s2, 40)s1[2] = 30fmt.Printf("The length of s1: %d\n", len(s1))   // 5fmt.Printf("The capacity of s1: %d\n", cap(s1)) // 5fmt.Printf("The value of s1: %d\n", s1)         // [1 2 30 40 5]fmt.Printf("The length of s2: %d\n", len(s2))   // 4fmt.Printf("The capacity of s2: %d\n", cap(s2)) // 5fmt.Printf("The value of s2: %d\n", s2)         // [1 2 30 40]fmt.Printf("The address of s1: %p\n", s1) // 0xc00001a330fmt.Printf("The address of s2: %p\n", s2) // 0xc00001a330
}

9.2 使用make 會生成新的切片

package mainimport "fmt"func main() {s1 := []int{1, 2, 3, 4, 5}// s2 := s1[0:3]s2 := make([]int, 3)copy(s2, s1)s2 = append(s2, 40)s1[2] = 30fmt.Printf("The length of s1: %d\n", len(s1))   // 5fmt.Printf("The capacity of s1: %d\n", cap(s1)) // 5fmt.Printf("The value of s1: %d\n", s1)         // [1 2 30 4 5]fmt.Printf("The length of s2: %d\n", len(s2))   // 4fmt.Printf("The capacity of s2: %d\n", cap(s2)) // 6fmt.Printf("The value of s2: %d\n", s2)         // [1 2 3 40]fmt.Printf("The address of s1: %p\n", s1) // 0xc00001a300fmt.Printf("The address of s2: %p\n", s2) // 0xc00001a330
}

10. 切片刪除元素

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

10.1 從開頭位置刪除

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

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

也可以不移動數(shù)據(jù)指針，但是將后面的數(shù)據(jù)向開頭移動，可以用 append 原地完成（所謂原地完成是指在原有的切片數(shù)據(jù)對應的內(nèi)存區(qū)間內(nèi)完成，不會導致內(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個元素

10.2 從中間位置刪除

對于刪除中間的元素，需要對剩余的元素進行一次整體挪動，同樣可以用 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個元素

10.3 從尾部刪除

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

注意：
連續(xù)容器的元素刪除無論在任何語言中，都要將刪除點前后的元素移動到新的位置，隨著元素的增加，這個過程將會變得極為耗時，因此，當業(yè)務需要大量、頻繁地從一個切片中刪除元素時，如果對性能要求較高的話，就需要考慮更換其他的容器了（如雙鏈表等能快速從刪除點刪除元素）。

總結(jié)

以上是生活随笔為你收集整理的Go 学习笔记（11）— 切片定义、切片初始化、数组和切片差异、字符串和切片转换、len()、cap()、空 nil 切片、append()、copy() 函数、删除切片元素的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。