索引：https://waterflow.link/articles/1666277946416
在go中切片的底層是陣列，所以切片的資料連續存盤在陣列的資料結構中，如果底層的陣列滿了，切片還需要添加元素的話，底層陣列就需要擴容，如果底層陣列幾乎為空時，就會縮容，
在切片內部其包含一個指向底部陣列的指標、切片的長度、切片的容量，長度是指切片包含的元素樹，容量底層陣列中的元素數，
我們先看個例子：
s := make([]int, 2, 4)
我們初始化一個長度為2，容量為4的切片，長度是必選的，容量可選，當不指定容量時，容量和長度相同，也就是底層陣列的長度，
因為長度為2，所以go只初始化了2個元素，我們可以列印下看下結果：
package main
import "fmt"
func main() {
s := make([]int, 2, 4)
fmt.Printf("s：%v，len(s)：%d，cap(s)：%d\n",
s, len(s), cap(s))
}
go run 4.go
s：[0 0]，len(s)：2，cap(s)：4
下面我們把s[1]設定為1，所以s的第二個元素會被更新為1，s的長度和容量不會變化
我們看下執行結果：
package main
import "fmt"
func main() {
s := make([]int, 2, 4)
s[1] = 1
fmt.Printf("s：%v，len(s)：%d，cap(s)：%d\n",
s, len(s), cap(s))
}
go run 4.go
s：[0 1]，len(s)：2，cap(s)：4
但是當我們設定s[2] = 1時會報錯，像下面這樣：
go run 4.go
panic: runtime error: index out of range [2] with length 2
但是我們的容量是4，也就是底層陣列還有2個空閑元素，那我們該如何給剩下的元素賦值呢？
我們可以使用go的內置函式append，他可以將元素追加到切片的末尾，它可以追加一個元素到切片末尾：
s = append(s, 1)
也可以追加多個元素到切片末尾：
s = append(s, 1, 2)
s = append(s, []int{1, 2}...)
還有一種比較特殊的情況，將字串追加到位元組切片末尾：
s = append([]byte("hello"), "world"...)
現在我們執行append(s, 2)，將元素2追加到s[1]后面，我們會得到下面的結果
切片的長度變成了3，容量還是4:
package main
import "fmt"
func main() {
s := make([]int, 2, 4)
s[1] = 1
s = append(s, 2)
fmt.Printf("s：%v，len(s)：%d，cap(s)：%d\n",
s, len(s), cap(s))
}
go run 4.go
s：[0 1 2]，len(s)：3，cap(s)：4
現在我們如果直接添加3個元素進去，像下面這樣：
s = append(s, 1, 2, 3)
我們會得到下面的結果：
package main
import "fmt"
func main() {
s := make([]int, 2, 4)
s[1] = 1
s = append(s, 2)
s = append(s, 1, 2, 3)
fmt.Printf("s：%v，len(s)：%d，cap(s)：%d\n",
s, len(s), cap(s))
}
go run 4.go
s：[0 1 2 1 2 3]，len(s)：6，cap(s)：8
我們發現現在元素的長度變成了6個，這個很好理解，因為我們總共添加了6個元素，但是切片的容量為什么會是8呢？
這是因為當我們添加第5個元素時，發現已經超過切片的容量了，這個時候會觸發擴容，會將容量加倍，然后復制所有元素創建另一個陣列，然后會把剩下的2和3插進去，
擴容機制：如果不到1024個元素，會成倍擴容；超過1024個元素，按25%擴容
切片中還提供了一種半開區間的賦值方式，保留第一個索引，排除第二個索引，像下面這樣：
package main
import "fmt"
func main() {
s := make([]int, 2, 4)
s[1] = 1
s = append(s, 2)
s = append(s, 1, 2, 3)
fmt.Printf("s：%v，len(s)：%d，cap(s)：%d\n",
s, len(s), cap(s))
s2 := s[1:2] // 這里重新賦值給s2
fmt.Printf("s2：%v，len(s2)：%d，cap(s2)：%d\n",
s2, len(s2), cap(s2))
}
go run 4.go
s：[0 1 2 1 2 3]，len(s)：6，cap(s)：8
s2：[1]，len(s2)：1，cap(s2)：7
切片s和s2此時是參考同一個底層陣列的，但是由于s2是從1開始，所以容量變成了7
這時如果我們修改了s2[0]或者s[1]，實際上他們指向的是底層陣列的同一個元素，所以s2[0]或者s[1]都會被修改掉，
package main
import "fmt"
func main() {
s := make([]int, 2, 4)
s[1] = 1
s = append(s, 2)
s = append(s, 1, 2, 3)
s2 := s[1:2]
s2[0] = 8 // 這里
fmt.Printf("修改倆切片指向的同一個元素：s：%v，len(s)：%d，cap(s)：%d)----s2：%v，len(s2)：%d，cap(s2)：%d\n",
s, len(s), cap(s), s2, len(s2), cap(s2))
}
go run 4.go
修改倆切片指向的同一個元素：s：[0 8 2 1 2 3]，len(s)：6，cap(s)：8)----s2：[8]，len(s2)：1，cap(s2)：7
接著我們繼續往s2中插入一個元素，看看會發生什么：
package main
import "fmt"
func main() {
s := make([]int, 2, 4)
s[1] = 1
s = append(s, 2)
s = append(s, 1, 2, 3)
s2 := s[1:2]
s2[0] = 8
// 插入元素6
s2 = append(s2, 6)
fmt.Printf("往s2插入一個元素：s：%v，len(s)：%d，cap(s)：%d----s2：%v，len(s2)：%d，cap(s2)：%d\n",
s, len(s), cap(s), s2, len(s2), cap(s2))
}
go run 4.go
往s2插入一個元素：s：[0 8 6 1 2 3]，len(s)：6，cap(s)：8----s2：[8 6]，len(s2)：2，cap(s2)：7
我們可以看到s2[1]的元素寫進去了，長度變為2，但是s2的長度并沒有變化，s2[2]的元素卻被修改為了6，這是因為往s2插入元素時并沒有超過s2的容量，所以還是共用同一個底層陣列，
那現在我們繼續往s2中添加6個元素，看看超出容量后的底層陣列會是什么樣的：
package main
import "fmt"
func main() {
s := make([]int, 2, 4)
s[1] = 1
s = append(s, 2)
s = append(s, 1, 2, 3)
s2 := s[1:2]
s2[0] = 8
s2 = append(s2, 6)
// 繼續插入6個元素
s2 = append(s2, 7)
s2 = append(s2, 8)
s2 = append(s2, 9)
s2 = append(s2, 10)
s2 = append(s2, 11)
s2 = append(s2, 12)
fmt.Printf("繼續往s2插入6個元素：s：%v，len(s)：%d，cap(s)：%d----s2：%v，len(s2)：%d，cap(s2)：%d\n",
s, len(s), cap(s), s2, len(s2), cap(s2))
}
go run 4.go
繼續往s2插入6個元素：s：[0 8 6 7 8 9]，len(s)：6，cap(s)：8----s2：[8 6 7 8 9 10 11 12]，len(s2)：8，cap(s2)：14
我們來分析下上面的例子：
- 當我們往s2插入7的時候，此時s2的長度變為3，容量還是7，s[3]對應也被修改，
- 當我們往s2插入8的時候，此時s2的長度變為4，容量還是7，s[4]對應也被修改，
- 當我們往s2插入9的時候，此時s2的長度變為5，容量還是7，s[5]對應也被修改，
- 當我們往s2插入10的時候，此時s2的長度變為6，容量還是7，s[6]對應也被修改，
- 當我們往s2插入11的時候，此時s2的長度變為7，容量還是7，因為s切片長度為6，所以沒有變化，
- 當我們往s2插入12的時候，此時s2超過s2的容量引發擴容，底層陣列被復制，s2指向一個新的容量為14的陣列，因為s長度小于容量，所以還是指向原來的陣列，
我們可以通過下面的圖片，增加更清晰的認識，
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/518692.html
標籤：Go