前言

Go 語言提供了很多方便的數(shù)據(jù)類型，其中包括 slice。然而，由于 slice 的特殊性質(zhì)，在使用過程中易犯一些錯誤，如果不注意，可能導致程序出現(xiàn)意外行為。本文將詳細介紹 使用 slice 時易犯的一些錯誤，幫助讀者更好的使用 Go 的 slice，避免犯錯誤。

slice 作為函數(shù) / 方法的參數(shù)進行傳遞的陷阱

slice 作為參數(shù)進行傳遞，有一些地方需要注意，先說結(jié)論：

1、在函數(shù)里修改切片元素的值，原切片的值也會被改變；

若想修改新切片的值，而不影響原切片的值，可以對原切片進行深拷貝：

通過 copy(dst, src []Type) int 函數(shù)將原切片的元素拷貝到新切片中：此函數(shù)在拷貝時，會基于兩個切片中，最小長度為基礎(chǔ)去拷貝，也就是初始化新切片時，長度必須大于等于原切片的長度。

2、在函數(shù)里通過 append 方法，對切片執(zhí)行追加元素的操作，可能會引起切片擴容，導致內(nèi)存分配的問題，可能會對程序的性能 造成影響；

為避免切片擴容，導致內(nèi)存分配，對程序的性能造成影響，在初始化切片時，應該根據(jù)使用場景，指定一個合理 cap 參數(shù)。

3、在函數(shù)里通過 append 函數(shù)，對切片執(zhí)行追加元素的操作，原切片里不存在新元素。

若想實現(xiàn)執(zhí)行 append 函數(shù)之后，原切片也能得到新元素；需將函數(shù)的參數(shù)類型由 切片類型 改成 切片指針類型。

通過例子來感受一下上面結(jié)論的由來：

package main

import "fmt"

func main() {
   s := []int{0, 2, 3}
   fmt.Printf("切片的長度：%d, 切片的容量：%d, 切片的元素：%v\n", len(s), cap(s), s) // 3 3 [0, 2, 3]
   sliceOperation(s)
   fmt.Printf("切片的長度：%d, 切片的容量：%d, 切片的元素：%v\n", len(s), cap(s), s) // 3 3 [1, 2, 3]
}

func sliceOperation(s []int) {
   s[0] = 1
   s = append(s, 4)
   fmt.Printf("切片的長度：%d, 切片的容量：%d, 切片的元素：%v\n", len(s), cap(s), s) // 4 6 [1, 2, 3]
}

首先定義并初始化切片 s，切片里有三個元素；

調(diào)用 sliceOperation 函數(shù)，將切片作為參數(shù)進行傳遞；

在函數(shù)里修改切片的第一個元素的值為 1，然后通過 append 函數(shù)插入元素 4，此時函數(shù)里的切片 由于容量不夠，s 的容量被擴大了，變成 原 cap * 2 = 3 * 2 = 6；

打印結(jié)果已注釋在代碼里，通過打印結(jié)果可知：

• 在函數(shù)里修改切片的第一個元素的值，原切片元素的值也會改變；
• 在函數(shù)里通過 append 函數(shù)，向切片追加元素 4，原切片并沒有此元素；
• 函數(shù)里的切片擴容了，原切片卻沒有。

由于切片是引用類型，因此在函數(shù)修改切片元素的值，原切片的元素值也會改變。

有的人可能會產(chǎn)生以下兩個疑問：

1、既然切片是引用類型，為什么通過 append 追加元素，原切片 s 卻沒有新元素？

2、為什么函數(shù)里的切片擴容了，原切片卻沒有？

在探究這兩個問題之前，我們需要了解切片的數(shù)據(jù)結(jié)構(gòu)：

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

切片包含三個字段：array (指針類型，指向一個數(shù)組)、len (切片的長度)、cap (切片的容量)。

知道了切片的數(shù)據(jù)結(jié)構(gòu)，我們通過圖片來直觀地看看切片 s：

切片 s 沒有被修改之前，在內(nèi)存中是以上圖所描述的形式存在，array 指針變量指向數(shù)組 [0, 2, 3]，長度為 3，容量為 3。

在執(zhí)行 sliceOperation 函數(shù)之后，原切片 s 和 sliceOperation 函數(shù)里的切片 s 如上圖所示。

通過上上圖和上圖對比可知，底層數(shù)組 [0, 2, 3] 的第一個元素的值被修改為 1，然后追加元素 4，此時函數(shù)里的切片發(fā)生變化，長度 3 → 4，容量 3 → 6 變成原來的兩倍，底層數(shù)組的長度也由 3 → 6。

由于原切片s的長度為3，array 指針所指向的區(qū)域只有 [1, 2, 3]，這也是為什么在函數(shù)里新增了 元素 4，在原切片 s 里看不到的原因。

第一個問題解決了，我們來思考第二個問題的原因：

在 Go 中，函數(shù) / 方法的參數(shù)傳遞方式為值傳遞，main 函數(shù)將 s 傳遞過來，sliceOperation 函數(shù)用 s 去接收，此時的s為新的切片，只不過它們所指向的底層數(shù)組為同一個，長度和容量也是一樣。而擴容操作是在新切片上進行的，因此原切片不受影響。

slice 通過 make 函數(shù)初始化，后續(xù)操作不當所造成的陷阱

使用 make 函數(shù)初始化切片后，如果在后續(xù)操作中沒有正確處理切片長度，容易造成以下陷阱：

越界訪問：如果訪問超出切片實際長度的索引，則會導致 index out of range 錯誤，例如：

func main() {
   s := make([]int, 0, 4)
   s[0] = 1 // panic: runtime error: index out of range [0] with length 0
}

通過 make([]int, 0, 4) 初始化切片，雖說容量為 4，但是長度為 0，如果通過索引去賦值，會發(fā)生panic；為避免 panic，可以通過 s := make([]int, 4) 或 s := make([]int, 4, 4) 對切片進行初始化。

切片初始化不當，通過 append 函數(shù)追加新元素的位置可能于預料之外

func main() {
   s := make([]int, 4)
   s = append(s, 1)
   fmt.Println(s[0]) // 0

   s2 := make([]int, 0, 4)
   s2 = append(s2, 1)
   fmt.Println(s2[0]) // 1
}

通過打印結(jié)果可知，對于切片 s，元素 1 沒有被放置在第一個位置，而對于切片 s2，元素 1 被放置在切片的第一個位置。這是因為通過 make([]int, 4) 和 make([]int, 0, 4) 初始化切片，底層所指向的數(shù)組的值是不一樣的：

• 第一種初始化的方式，切片的長度和容量都為 4，底層所指向的數(shù)組長度也是 4，數(shù)組的值為 [0, 0, 0, 0]，每個位置的元素被賦值為零值，s = append(s, 1) 執(zhí)行后，s 切片的值為 [0, 0, 0, 0, 1]；
• 第二種初始化的方式，切片的長度為 0，容量為 4，底層所指向的數(shù)組長度為 0，數(shù)組的值為 []，s2 = append(s2, 1) 執(zhí)行后，s2 切片的值為 [1]；
• 通過 append 向切片追加元素，會執(zhí)行尾插操作。如果我們需要初始化一個空切片，然后從第一個位置開始插入元素，需要避免 make([]int, 4) 這種初始化的方式，否則添加的結(jié)果會在預料之外。

性能陷阱

內(nèi)存泄露

內(nèi)存泄露是指程序分配內(nèi)存后不再使用該內(nèi)存，但未將其釋放，導致內(nèi)存資源被浪費。

切片引用切片場景：如果一個切片有大量的元素，而它只有少部分元素被引用，其他元素存在于內(nèi)存中，但是沒有被使用，則會造成內(nèi)存泄露。代碼示例如下：

  var s []int

  func main() {
     sliceOperation()
     fmt.Println(s)
  }

  func sliceOperation() {
     a := make([]int, 0, 10)
     a = append(a, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
     s = a[0:4]
  }

上述代碼中，切片 a 的元素有 10 個，而切片 s 是基于 a 創(chuàng)建的，它底層所指向的數(shù)組與 a 所指向的數(shù)組是同一個，只不過范圍為前四個元素，而后六個元素依然存在于內(nèi)存中，卻沒有被使用，這樣會造成內(nèi)存泄露。為了避免內(nèi)存泄露，我們可以對代碼進行改造： s = a[0:4] → s = append(s, a[0:4]...)，通過 append 進行元素追加，這樣切片 a 底層的數(shù)組沒有被引用，后面會被 gc。

擴容

擴容陷阱在前面的例子也提到過，通過?append?方法，對切片執(zhí)行追加元素的操作，可能會引起切片擴容，導致內(nèi)存分配的問題。

  func main() {
     s := make([]int, 0, 4)
     fmt.Printf("切片的長度：%d, 切片的容量：%d\n", len(s), cap(s)) // 4 4
     s = append(s, 1, 2, 3, 4, 5)
     fmt.Printf("切片的長度：%d, 切片的容量：%d\n", len(s), cap(s)) // 5 8
  }

切片擴容，可能會對程序的性能 造成影響；為避免此情況的發(fā)生，應該根據(jù)使用場景，估算切片的容量，指定一個合理?cap?參數(shù)。