站長資訊網
數組與切片的區別：1、切片是指針類型，數組是值類型；2、數組的賦值形式為值傳遞，切片的賦值形式為引用傳遞；3、數組的長度是固定的，而切片長度可以任意調整（切片是動態的數組）；4、數組的長度是固定的，而切片長度可以任意調整（切片是動態的數組）。
本教程操作環境：windows7系統、GO 1.18版本、Dell G3電腦。
Go語言中的數組大概相當與C/C++中的數組，固定大小，不能夠動態擴展大小，而切片大概相當與C++中的Vector，可以動態擴展大小，當大小超過容量時，重新分配一塊內存，然后將數據復制到新的內存區域。下面我們通過幾個問題來更好理解golang 的數組和切片，一起來看看吧。
一、數組
Go的切片是在數組之上的抽象數據類型，因此在了解切片之前必須要先理解數組。
1、數組的三種申明方式
- var identifier [len]type
- var identifier = [len]type{value1, value2, … , valueN}
- var identifier = […]type{value1, value2, … , valueN}
相對應的：
- identifier := [len]type{}
- identifier := [len]type{value1, value2, … , valueN}
- identifier := […]type{value1, value2, … , valueN}
例子：
var iarray1 [5]int32 var iarray2 [5]int32 = [5]int32{1, 2, 3, 4, 5} iarray3 := [5]int32{1, 2, 3, 4, 5} iarray4 := [5]int32{6, 7, 8, 9, 10} iarray5 := [...]int32{11, 12, 13, 14, 15} iarray6 := [4][4]int32{{1}, {1, 2}, {1, 2, 3}} fmt.Println(iarray1) fmt.Println(iarray2) fmt.Println(iarray3) fmt.Println(iarray4) fmt.Println(iarray5) fmt.Println(iarray6)
登錄后復制
結果：
[0 0 0 0 0] [1 2 3 4 5] [1 2 3 4 5] [6 7 8 9 10] [11 12 13 14 15] [[1 0 0 0] [1 2 0 0] [1 2 3 0] [0 0 0 0]]
登錄后復制
我們看數組 iarray1，只聲明，并未賦值，Go語言幫我們自動賦值為0。再看 iarray2 和 iarray3 ，我們可以看到，Go語言的聲明，可以表明類型，也可以不表明類型，var iarray3 = [5]int32{1, 2, 3, 4, 5} 也是完全沒問題的。
2、數組的容量和長度
數組的容量和長度是一樣的。cap() 函數和 len() 函數均輸出數組的容量（即長度）
3、類型
數組是值類型，將一個數組賦值給另一個數組時，傳遞的是一份拷貝。而切片是引用類型，切片包裝的數組稱為該切片的底層數組。看下面的例子：
//a是一個數組，注意數組是一個固定長度的，初始化時候必須要指定長度，不指定長度的話就是切片了 a := [3]int{1, 2, 3} //b是數組，是a的一份拷貝 b := a //c是切片，是引用類型，底層數組是a c := a[:] for i := 0; i < len(a); i++ { a[i] = a[i] + 1 } //改變a的值后，b是a的拷貝，b不變，c是引用，c的值改變 fmt.Println(a) //[2,3,4] fmt.Println(b) //[1 2 3] fmt.Println(c) //[2,3,4]
登錄后復制
二、切片
Go語言中，切片是長度可變、容量固定的相同的元素序列。Go語言的切片本質是一個數組。容量固定是因為數組的長度是固定的，切片的容量即隱藏數組的長度。長度可變指的是在數組長度的范圍內可變。
1、切片的四種創建方式
- var slice1 = make([]int,5,10)
- var slice2 = make([]int,5)
- var slice3 = []int{}
- var slice4 = []int{1,2,3,4,5}
相對應的：
- slice1 := make([]int,5,10)
- slice2 := make([]int,5)
- slice3 := []int{}
- slice4 := []int{1,2,3,4,5}
以上對應的輸出
[0 0 0 0 0] [0 0 0 0 0] [] [1 2 3 4 5]
登錄后復制
從3)、4)可見，創建切片跟創建數組唯一的區別在于 Type 前的“ [] ”中是否有數字，為空，則代表切片，否則則代表數組。因為切片是長度可變的
2、隱藏數組
Go的切片是在數組之上的抽象數據類型，所以創建的切片始終都有一個數組存在。
舉例說明：
slice0 := []string{"a", "b", "c", "d", "e"} slice1 := slice0[2 : len(slice0)-1] slice2 := slice0[:3] fmt.Println(slice0, slice1, slice2) slice2[2] = "8" fmt.Println(slice0, slice1, slice2)
登錄后復制
輸出：
[a b c d e] [c d] [a b c] [a b 8 d e] [8 d] [a b 8]
登錄后復制
也說明，切片slice0 、 slice1 和 slice2是同一個底層數組的引用，所以slice2改變了，其他兩個都會變
3、append追加切片
內置函數append可以向一個切片后追加一個或多個同類型的其他值。如果追加的元素數量超過了原切片容量，那么最后返回的是一個全新數組中的全新切片。如果沒有超過，那么最后返回的是原數組中的全新切片。無論如何，append對原切片無任何影響。
舉例說明：
slice1 := make([]int, 2, 5) fmt.Println(len(slice1), cap(slice1)) for k := range slice1{ fmt.Println(&slice1[k]) } slice1 = append(slice1,4) fmt.Println(len(slice1), cap(slice1)) for k := range slice1{ fmt.Println(&slice1[k]) } slice1 = append(slice1,5,6,7) fmt.Println(len(slice1), cap(slice1)) for k := range slice1{ fmt.Println(&slice1[k]) }
登錄后復制
輸出：
2 5 //長度和容量 0xc420012150 0xc420012158 3 5 //第一次追加，未超出容量，所以內存地址未發生改變 0xc420012150 0xc420012158 0xc420012160 6 10 //第二次追加，超過容量，內存地址都發生了改變,且容量也發生了改變,且是原來的2倍 0xc4200100f0 0xc4200100f8 0xc420010100 0xc420010108 0xc420010110 0xc420010118
登錄后復制
再看一個例子：
slice1 := make([]int, 2, 5) slice2 := slice1[:1] fmt.Println(len(slice1), cap(slice1)) for k := range slice1{ fmt.Println(&slice1[k]) } fmt.Println(len(slice2), cap(slice2)) for k := range slice2{ fmt.Println(&slice2[k]) } slice2 = append(slice2,4,5,6,7,8) fmt.Println(len(slice1), cap(slice1)) for k := range slice1{ fmt.Println(&slice1[k]) } fmt.Println(len(slice2), cap(slice2)) for k := range slice2{ fmt.Println(&slice2[k]) }
登錄后復制
以上輸出：
2 5 //slice1的長度和容量 0xc4200700c0 0xc4200700c8 1 5 //slice2的長度和容量 0xc4200700c0 2 5 //slice2追加后，slice1的長度和容量、內存都未發生改變 0xc4200700c0 0xc4200700c8 6 10 //slice2追加后，超過了容量，所以slice2的長度和容量、內存地址都發生改變。 0xc42007e000 0xc42007e008 0xc42007e010 0xc42007e018 0xc42007e020 0xc42007e028
登錄后復制
三、GO中數組與切片的區別
下面的主要看一些實際的例子來說明數組和切片的區別。
1、數組與切片的賦值形式
例子1
arr1 := [3] int {1,2,3} arr2 := arr1 for k := range arr1 { fmt.Printf("%v ",&arr1[k]); } fmt.Println(""); for k := range arr2 { fmt.Printf("%v ",&arr2[k]); } fmt.Println("n================="); slice1 := [] int{1,2,3} slice2 := slice1 for k := range slice1 { fmt.Printf("%v ",&slice1[k]); } fmt.Println(""); for k := range slice2 { fmt.Printf("%v ",&slice2[k]); } 輸出結果： 0xc420014140 0xc420014148 0xc420014150 0xc420014160 0xc420014168 0xc420014170 ================= 0xc4200141a0 0xc4200141a8 0xc4200141b0 0xc4200141a0 0xc4200141a8 0xc4200141b0
登錄后復制
從這個例子中可以看出，數組的賦值是值的拷貝，是一個全新的數組。而切片的賦值是引用。下面再來看一個例子。
例子2:
arr1 := [3] int {1,2,3} arr2 := arr1 fmt.Printf("%v %v ",arr1,arr2); arr1[0] = 11 arr2[1] = 22 fmt.Printf("n%v %v ",arr1,arr2); fmt.Println("n================"); slice1 := [] int{1,2,3} slice2 := slice1 fmt.Printf("%v %v ",slice1,slice2); slice1[0] = 11 slice2[1] = 22 fmt.Printf("n%v %v ",slice1,slice2); 輸出結果： [1 2 3] [1 2 3] [11 2 3] [1 22 3] ================ [1 2 3] [1 2 3] [11 22 3] [11 22 3]
登錄后復制
這個例子再一次說明：數組是賦值是copy，而切片僅是引用。例子1和例子2中的切片的聲明用到了隱藏數組。再來看下例子3，使用非隱藏數組的情況。
例子3:
arr1 := [5] int {1,2,3} slice1 := arr1[0:3] slice2 := slice1[0:4] fmt.Printf("len: %d cap: %d %vn",len(arr1),cap(arr1),arr1); //打印出非隱藏數組 for k := range arr1 { fmt.Printf("%v ",&arr1[k]); } fmt.Println(""); fmt.Printf("len: %d cap: %d %vn",len(slice1),cap(slice1),slice1); //打印切片1 for k := range slice1 { fmt.Printf("%v ",&slice1[k]); } fmt.Println(""); fmt.Printf("len: %d cap: %d %vn",len(slice2),cap(slice2),slice2); //打印切片2 for k := range slice2 { fmt.Printf("%v ",&slice2[k]); } fmt.Println("n================="); arr1[0] = 11 //非隱藏數組、切片1、切片2各自發生更改 slice1[1] = 22 slice2[2] = 33 fmt.Printf("len: %d cap: %d %vn",len(arr1),cap(arr1),arr1); //再次打印非隱藏數組 for k := range arr1 { fmt.Printf("%v ",&arr1[k]); } fmt.Println(""); fmt.Printf("len: %d cap: %d %vn",len(slice1),cap(slice1),slice1); //再此打印切片1 for k := range slice1 { fmt.Printf("%v ",&slice1[k]); } fmt.Println(""); fmt.Printf("len: %d cap: %d %vn",len(slice2),cap(slice2),slice2); //再次打印切片2 for k := range slice2 { fmt.Printf("%v ",&slice2[k]); } 輸出結果： len: 5 cap: 5 [1 2 3 0 0]0xc420012150 0xc420012158 0xc420012160 0xc420012168 0xc420012170 len: 3 cap: 5 [1 2 3]0xc420012150 0xc420012158 0xc420012160 len: 4 cap: 5 [1 2 3 0]0xc420012150 0xc420012158 0xc420012160 0xc420012168 ================= len: 5 cap: 5 [11 22 33 0 0] 0xc420012150 0xc420012158 0xc420012160 0xc420012168 0xc420012170 len: 3 cap: 5 [11 22 33] 0xc420012150 0xc420012158 0xc420012160 len: 4 cap: 5 [11 22 33 0] 0xc420012150 0xc420012158 0xc420012160 0xc42001216
登錄后復制
綜上三個例子，可以看出切片是數組的引用，這里包括對隱藏數組、非隱藏數組引用。
2、數組作為參數，被函數調用
func Connect() { arr1 := [5] int {1,2,3} fmt.Printf("%v ",arr1); for k := range arr1 { fmt.Printf("%v ",&arr1[k]); } fmt.Println(""); f1(arr1) fmt.Println(""); f2(&arr1) } func f1(arr [5]int) { fmt.Printf("%v ",arr); for k := range arr { fmt.Printf("%v ",&arr[k]); } } func f2(arr *[5]int) { fmt.Printf("%v ",arr); for k := range arr { fmt.Printf("%v ",&arr[k]); } } 輸出結果： [1 2 3 0 0] 0xc420012150 0xc420012158 0xc420012160 0xc420012168 0xc420012170 [1 2 3 0 0] 0xc4200121b0 0xc4200121b8 0xc4200121c0 0xc4200121c8 0xc4200121d0 &[1 2 3 0 0] 0xc420012150 0xc420012158 0xc420012160 0xc420012168 0xc420012170
登錄后復制
從上面的例子可以看出，數組在參數中，可以使用值傳遞和引用傳遞。值傳遞會拷貝新數組，引用傳遞則使用原數組。
func Connect() { slice1 := [] int {1,2,3} fmt.Printf("%v ",slice1); for k := range slice1 { fmt.Printf("%v ",&slice1[k]); } fmt.Println(""); f1(slice1) } func f1(slice []int) { fmt.Printf("%v ",slice); for k := range slice { fmt.Printf("%v ",&slice[k]); } } 輸出結果： [1 2 3] 0xc420014140 0xc420014148 0xc420014150 [1 2 3] 0xc420014140 0xc420014148 0xc42001415
登錄后復制
從這個例子中可以看出，切片在參數中傳遞本身就引用。
總結：
-
切片是指針類型，數組是值類型
-
數組的賦值形式為值傳遞，切片的賦值形式為引用傳遞
-
數組的長度是固定的，而切片長度可以任意調整（切片是動態的數組）
-
數組只有長度一個屬性，而切片比數組多了一個容量（cap)屬性
【
