Go Slice 擴容的這些坑你踩過嗎?

王中陽Go發表於2023-03-26

前言

之前對Go語言for迴圈做了一次踩坑經驗分享《Go for range 一不小心就掉坑裡了》,大家直呼有用。

今天對切片Slice的append操作也做一次踩坑經驗分享,希望對朋友們有所幫助,有用請三連支援。

知識重溫

切片底層結構定義:包含指向底層陣列的指標長度容量

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

append操作:可以是1個、多個、甚至整個切片(記得後面加...);新增元素時當容量不足,則會自動觸發切片擴容機制,產生切片副本,同時指向底層陣列的指標發生變化

var nums []int
nums = append(nums, 1)
nums = append(nums, 2, 3, 4)
nums2 := []int{5, 6, 7}
nums = append(nums, nums2...)
fmt.Println(nums) //[1 2 3 4 5 6 7]

案例1:傳值+未擴容

先來看看下面會輸出什麼結果?

func main() {
  s1 := make([]int, 0, 5)
  fmt.Println("s1切片: ", s1)
  appendFunc(s1)
  fmt.Println("s1切片: ", s1)
  fmt.Println("s1切片表示式: ", s1[:5])
}

func appendFunc(s2 []int) {
  s2 = append(s2, 1, 2, 3)
  fmt.Println("s2切片: ", s2)
}

輸出結果:

s1切片:  []
s2切片:  [1 2 3]
s1切片:  []
s1切片表示式:  [1 2 3 0 0]

看到這個結果,大家就會有疑問了,明明切片是引用型別,為什麼s2 append了新元素後,s2是有值了但s1卻還是空的,並且對s1用切片表示式卻能獲取到值呢?

原因分析前,我們先來看看s1和s2到底是不是同一個切片,列印地址驗證下

func main() {
  s1 := make([]int, 0, 5)
  fmt.Printf("s1切片地址: %p\n", s1)
  appendFunc(s1)
  //...
}

func appendFunc(s2 []int) {
  s2 = append(s2, 1, 2, 3)
  fmt.Printf("s2切片地址: %p\n", s2)
  //...
}

輸出結果:
s1切片地址: 0xc000018150
s2切片地址: 0xc000018150

看到這就得傻眼了,兩個切片的地址都是同一個,s2修改後s1也應該同步修改,應該都有值啊

我們還得繼續再深究一下,fmt包%p列印的這個地址,到底是誰的地址

//fmt/print.go
func (p *pp) fmtPointer(value reflect.Value, verb rune) {
  var u uintptr
  switch value.Kind() {
  case reflect.Chan, reflect.Func, reflect.Map, reflect.Ptr, reflect.Slice, reflect.UnsafePointer:
    u = value.Pointer()
  default:
    p.badVerb(verb)
    return
  }
  //...
}

//reflect/value.go
func (v Value) Pointer() uintptr {
  k := v.kind()
  switch k {
  //...
  
  case Slice:
    return (*SliceHeader)(v.ptr).Data
  }
  panic(&ValueError{"reflect.Value.Pointer", v.kind()})
}

透過分析fmt包的原始碼,不難發現,列印的地址,其實是切片裡指向底層陣列的指標儲存的地址,並不是兩個切片本身的地址。同時也說明這兩切片是指向同一個底層陣列。

原因正式分析

  1. 傳值操作,s1和s2是兩個不同的切片變數,但是指向底層陣列的指標是同一個;
  2. 長度和容量的變化:s1 Len=0和Cap=5,後來未發生過變化;s2一開始被賦值時 Len=0和Cap=5,在append操作後,Len=3和Cap=5,同時底層陣列值從[0,0,0,0,0]被修改成了[1,2,3,0,0];
  3. 輸出結果,s1由於Len=0所以輸出空[],而s1用切片表示式,是基於底層陣列[1,2,3,0,0]進行切片,所以輸出結果為[1,2,3,0,0]

案例2:傳值+擴容

將案例1,append的元素個數超過切片容量,觸發自動擴容,輸出的結果又會是怎樣的呢?

func main() {
  s1 := make([]int, 0, 5)
  fmt.Println("s1切片: ", s1)
  appendFunc(s1)
  fmt.Println("s1切片: ", s1)
  fmt.Println("s1切片表示式: ", s1[:5])
}

func appendFunc(s2 []int) {
  s2 = append(s2, 1, 2, 3, 4, 5, 6)
  fmt.Println("s2切片: ", s2)
}

輸出結果:

s1切片:  []
s2切片:  [1 2 3 4 5 6]
s1切片:  []
s1切片表示式:  [0 0 0 0 0]

原因分析

  1. 發生擴容後,s2指向的底層陣列會產生副本,導致s1和s2不再指向同一個底層陣列;
  2. 長度和容量的變化:s2 append後Len=6、Cap=10和底層陣列值為[1,2,3,4,5,6,0,0,0,0];s2的操作完全不影響s1的資料,s1仍然是Len=0、Cap=5和底層陣列值為[0,0,0,0,0]
  3. 輸出結果,s2由於Len=6所以輸出[1,2,3,4,5,6],s1由於Len=0所以輸出空[],而s1用切片表示式,是基於底層陣列[0,0,0,0,0]進行切片,所以輸出結果為[0,0,0,0,0]

案例3:傳址+不關心擴容

上面兩個傳值操作的例子,不管擴容與否,都不會影響原切片s1的長度和容量。如果我們期望修改s2的同時也修改原切片s1,則需要用到切片指標,基於地址傳遞進行操作

func main() {
  s1 := make([]int, 0, 5)
  fmt.Println("s1切片: ", s1)
  fmt.Printf("s1切片地址: %p len:%d cap:%d\n", &s1, len(s1), cap(s1))
  appendFunc(&s1)
  fmt.Println("s1切片: ", s1)
  fmt.Println("s1切片表示式: ", s1[:5])
}

func appendFunc(s2 *[]int) {
  fmt.Printf("s2切片地址: %p len:%d cap:%d\n", s2, len(*s2), cap(*s2))
  //*s2 = append(*s2, 1, 2, 3)
  *s2 = append(*s2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
  fmt.Printf("append後s2切片地址: %p len:%d cap:%d\n", s2, len(*s2), cap(*s2))
  fmt.Println("s2切片: ", *s2)
}

輸出結果:

s1切片:  []
s1切片地址: 0xc00000c030 len:0 cap:5
s2切片地址: 0xc00000c030 len:0 cap:5
append後s2切片地址: 0xc00000c030 len:10 cap:10
s2切片:  [1 2 3 4 5 6 7 8 9 10]
s1切片:  [1 2 3 4 5 6 7 8 9 10]
s1切片表示式:  [1 2 3 4 5]

萬變不離其宗,傳址操作,始終操作的是同一個切片變數,append操作後,長度和容量都會同時發生變化,以及如果觸發擴容,那麼指向底層陣列的指標,也都會同時發生變化。

總結

切片傳值操作,append未觸發擴容,會同時修改底層陣列的值,但不會影響原切片的長度和容量;當觸發擴容,那麼會產生副本,後面的修改則會和原底層陣列剝離開,互不影響。

如果期望在修改切片後,對原切片也發生修改,則可以使用傳址操作,始終基於同一個切片變數進行操作。

一起學習

需要簡歷最佳化和就業輔導的朋友可以私信我,也歡迎關注我的公眾號:

我的文章首發在我的公眾號: 程式設計師升職加薪之旅,歡迎大家關注,第一時間閱讀我的文章。

也歡迎大家關注我,點贊、留言、轉發。你的支援,是我更文的最大動力!

相關文章