Go必知必會：數組和切片詳解
在 Go 語言的豐富數據類型中，數組和切片是處理有序數據集合的強大工具。它們允許開發者以連續的內存塊來存儲和管理相同類型的多個元素。無論是在處理大量數據時的性能優化，還是在實現算法時對數據結構的需求，數組和切片都扮演著至關重要的角色。
Go 語言中的數組
數組是存放元素的容器，Go 語言中數組的長度是數組類型的一部分，定義數組時必須指定存放元素的類型和容量（長度）。
定義
var a1 [3]bool
var a2 [4]int
fmt.Printf("a1:%T\na2:%T\n", a1, a2)打印結果：
圖片
數組初始化
默認值
定義數組時不進行初始化，默認元素都是零值：bool 類型的 false、整型和浮點類型的 0、字符串的空串" "。
var a1 [3]bool
var a2 [4]int
// 如果不初始化：默認元素都是零值（布爾值：false 整型和浮點類型：0 字符串：""）
fmt.Println(a1, a2)打印結果：
圖片
初始化方式 1
最簡單的初始化方式，在大括號中定義好和長度一致的值。
var a1 [3]bool
a1 = [3]bool{true,false,false}
fmt.Println(a1)打印結果：
圖片
初始化方式 2：根據初始值自動判斷數組的長度
在中括號中寫明長度，當定義的數值個數比長度小時，會用默認值補齊，比如：0、false、""。
a8 := [10]int{0, 1, 2, 3, 4, 5, 6, 7} //7后面會用0補齊
fmt.Println(a8)打印結果：[0 1 2 3 4 5 6 7 0 0]。
[...]的用法
[...]設置數組長度時，會根據初始值自動判斷數組的長度。
aa := [...]int{0, 1, 2, 3, 4, 5, 6, 7} //[...]根據初始值自動判斷數組的長度
fmt.Println(aa)打印結果：[0 1 2 3 4 5 6 7]。
初始化方式 3：根據索引初始化
指定索引對應的值，未指定索引的值會用默認值填充，比如：0、false、""。
a3 := [5]int{0: 1, 4: 2} //根據索引初始化
fmt.Println(a3)打印結果：[1 0 0 0 2]。
取值
遍歷數組
for i 循環遍歷數組
citys := [...]string{"北京", "上海", "深圳"} //索引從0到2
// 根據索引遍歷
for i := 0; i < len(citys); i++ {
fmt.Println(citys[i])
}打印結果：
圖片
for range 遍歷
for range 遍歷更簡單：
citys := [...]string{"北京", "上海", "深圳"} //索引從0到2
for i, city := range citys {
fmt.Printf("key值：%d 城市為：%v\n", i, city)
}打印結果：
圖片
多維數組
定義
我們以二維數組舉例，比如我們需要定義[[1 2 3][4 5 6]]這樣的二維數組，需要怎么定義呢？
示例如下：
- 下面代碼中的第一個長度單位[2]表示二維數組的有幾個元素。
- 第二個長度單位[3]表示子集數組中有幾個元素。
- 初始化的時候：變量 = 數組類型{}。
//定義多維數組
var a11 [2][3]int
//初始化多維數組
a11 = [2][3]int{
[3]int{1, 2, 3},
[3]int{4, 5, 6}, //注意：最后這個也要加逗號分隔
}
fmt.Println(a11)打印結果：
圖片
取值
多維數組的遍歷
//定義多維數組
var a11 [2][3]int
//初始化多維數組
a11 = [2][3]int{
[3]int{1, 2, 3},
[3]int{4, 5, 6}, //注意：最后這個也要加逗號分隔
}
//雙重for range遍歷取值
for _, v1 := range a11 {
fmt.Println(v1)
for _, v2 := range v1 {
fmt.Println(v2)
}
}打印結果：
圖片
數組特點：值類型 不是引用類型
我們發現把 b1 賦值給 b2，再修改 b2 的值，b1 的值并沒有改變。我認為這是數組和切片最大的區別，建議大家再對比學習一下切片的知識點。
b1 := [3]int{1, 2, 3}
b2 := b1
b2[0] = 100
fmt.Println(b1,b2)打印結果：
圖片
總結：說明 Go 的數組是值類型，不是引用類型：b2:=b1 的操作，給 b2 開辟了新的內存空間，而不是引用 b1 的內存地址。
數組實戰
求數組 cArray[1，3，5，7，8]所有元素之和
cArray := [...]int{1, 3, 5, 7, 8}
r := 0
for _, i2 := range cArray {
r += i2
}
fmt.Printf("相加結果為：%v", r)打印結果：相加結果為：24。
求出 cArray 數組中，和為 8 的下標，比如[0 3]和[1 2]
for i := 0; i < len(cArray); i++ {
for j := 0; j < i; j++ {
if cArray[i]+cArray[j] == 8 {
fmt.Printf("符合的下標為：%v,%v \n", j, i)
}
}
}打印結果：
圖片
Go 語言中的切片
切片區別于數組，是引用類型， 不是值類型。數組是固定長度的，而切片長度是可變的，我的理解是：切片是對數組一個片段的引用。
定義
var s1 []int //定義一個存放int類型元素的切片
var s2 []string //定義一個存放string類型元素的切片
fmt.Println(s1, s2)
fmt.Println(s1 == nil) //true 為空 沒有開辟內存空間
fmt.Println(s2 == nil) //true打印結果：
圖片
解析: 說明我們已經聲明成功了，但是并沒有開辟內存空間，因為s1、s2的值為nil。
聲明并初始化
我們可以在聲明的同時初始化：
var s1 = []int{1, 2, 3}
var s2 = []string{"北苑", "長陽", "望京"}
fmt.Println(s1, s2)
fmt.Println(s1 == nil) //false
fmt.Println(s2 == nil) //false打印結果：
圖片
解析：初始化成功，s1 s2的值都不等于nil。
長度和容量
分別使用len()、cap()獲得切片的長度和容量：
fmt.Printf("len(s1):%d cap(s1):%d\n", len(s1), cap(s1))
fmt.Printf("len(s2):%d cap(s2):%d\n", len(s2), cap(s2))打印結果：
圖片
解析：和我們預期的一致，長度和容量都為3。
由數組得到切片
開篇我已經提到數組和切片的關系，這里再進一步講一下：
- 切片的本質是操作數組，只是數組是固定長度的，而切片的長度可變的。
- 切片是引用類型，可以理解為引用數組的一個片段；而數組是值類型，把數組A賦值給數組B，會為數組B開辟新的內存空間，修改數組B的值并不會影響數組A。
- 而切片作為引用類型，指向同一個內存地址，是會互相影響的。
//定義一個數組
a1 := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9}
s3 := a1[0:4] //基于一個數組切割 [0:4]左包含 右不包含 即為[1,2,3,4]
fmt.Println(s3)打印結果：
圖片
注意：a1[0:4] 基于一個數組切割 [0:4]左包含 右不包含 即為[1,2,3,4]。
更多切割方式舉例
a1 := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9}
s4 := a1[2:4] //[3 4]
s5 := a1[:4] //[1 2 3 4]
s6 := a1[2:] //[3 4 5 6 7 8 9]
s7 := a1[:] //[1 2 3 4 5 6 7 8 9]
fmt.Println(s4)
fmt.Println(s5)
fmt.Println(s6)
fmt.Println(s7)打印結果：
圖片
解析：都符合上面提到的左包含，右不包含原則 s4從下標2開始截取，截取到下標4 s5省略了第一個參數，表示從下標0開始截取 s6省略了第二個參數，表示截取到最后一個元素 s7省略了兩個參數，只填寫了中間的冒號:，表示取全部元素。
切片的長度和容量
切片的長度很好理解，就是元素的個數。
切片的容量我們重點理解一下：在切片引用的底層數組中從切片的第一個元素到數組最后一個元素的長度就是切片的容量。
我來畫個圖：
圖片
再舉個栗子
我們看下面這個栗子就很好理解啦：
a1 := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9}
s5 := a1[:4] //[1 2 3 4]
s6 := a1[2:] //[3 4 5 6 7 8 9]
s7 := a1[:] //[1 2 3 4 5 6 7 8 9]
fmt.Printf("len(s5):%d cap(s5):%d\n", len(s5), cap(s5)) //4 9
fmt.Printf("len(s6):%d cap(s6):%d\n", len(s6), cap(s6)) //7 7
fmt.Printf("len(s7):%d cap(s7):%d\n", len(s7), cap(s7)) //9 9打印結果：
圖片
解析：a1是數組長度為9，容量也為9，值是從1~9。
s5/s6/s7都是切割數組a1得到的切片。
s5的長度為4，因為只有1 2 3 4這4個元素，容量為9，因為s5切片是從數組起始位置開始切割的：第一個元素是1，而s5底層數組a1最后一個元素是9，1~9共9個元素，所以s5的容量為9。
s6的長度為7，因為s6的元素是3到9共7個元素，所以s6的容量為7。
S7更好理解了，長度和容量都是9，小伙伴們自己理解一下。
切片再切片
我們可以對切片進行再切片操作。
比如，我們針對上面的數據再次切片進行測試
s8 :=s6[3:]
//s8的值為：6 7 8 9
fmt.Printf("len(s8):%d cap(s8):%d\n", len(s8), cap(s8)) //4 4打印結果：
解析：我們知道可以對切片進行再次切片就可以，至于長度和容器大家搞明白上面的栗子，這個輸出結果就是意料之中的了。
slice是引用類型
我們舉個栗子來證明切片是引用類型。
//定義數組
a1 := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9}
//由數組切割成切片s6
s6 := a1[2:] //[3 4 5 6 7 8 9]
//切片再次切片，賦值給s8
s8 :=s6[3:] //[6 7 8 9]
//修改原始數組，把下標為2的值由3改為333
a1[2] = 333
//打印s6，發現s6中的3也變成了333
fmt.Println("s6:", s6) //[333 4 5 6 7 8 9]
//因為s8基于s6切片而成，我們測試一下切片再切片的引用傳的
fmt.Println("s8:", s8) //[6 7 8 9]
//我們把原始數組下標為5的值由6改為666
a1[5] = 666
//打印s8切片，得到結果6也變成了666
fmt.Println("s8:", s8) //[666 7 8 9]打印結果：
解析：由此我們可以明確的知道切片是引用類型，當底層數組改變時，不管是切片，還是切片再切片，值都會改變。因為他們使用的是一個內存塊，引用的一個內存地址。
本文轉載自微信公眾號「王中陽Go」，作者「王中陽Go」，可以通過以下二維碼關注。
轉載本文請聯系「王中陽Go」公眾號。
