golang中數組和切片到底有什么區別？

作者：飯米粒 2022-10-27 19:32:20

數組大家都知道是具有「固定長度及類型的序列集合」,但是golang中又引入了「切片」，語法上看起來還和數組差不多，為什么會引入這些呢？切片和數組到底有什么區別呢？

數組大家都知道是具有「固定長度及類型的序列集合」,但是golang中又引入了「切片」，語法上看起來還和數組差不多，為什么會引入這些呢？切片和數組到底有什么區別呢？接下來咱們來一個一個的看。

數組 array

定義數組

var arr [5]int = [5]int{1,2,3,4，5}

上述語句表示的意思是，我們來定義一個變量arr 為5個長度的int的數組類型，也就是[5]int,同時給賦值上了初始值 1、2、3、4、5，內存分布如圖

緊密挨在一起的數據結構集合

注意

如果定義數組的方法是；

arr := new([4]int)

那么arr的數據類型為*[4]int，而不是[4]int；

不定長數組

當然數組的長度4如果是不固定的，可以用...的方式代替

q := [...]int{1, 2, 3}

數組的循環

數組的循環在golang中有一個特有的語法，就是 for range

var arr [4]int = [4]int{1, 2, 3, 4}
 for i, v := range arr {
  fmt.Printf("數組中的第%v項, 值是%v\n", i, v)
 }
  //輸出結果
  數組中的第0項, 值是1
  數組中的第1項, 值是2
  數組中的第2項, 值是3
  數組中的第3項, 值是4

數組的常用方法

常用方法是「len()」方法和「cap()」方法；

len()方法的作用是獲取數組或者切片的「長度」
cap()方法的作用是獲取數組或者切片的「容量」

但是「在數組中，這兩個值永遠相同」,所以在這里咱們不多做考慮，在后面切片中再詳細闡述。

切片 slice

為什么會有切片？

切片之所以會誕生，是因為golang中數組存在很大的兩個問題

固定的長度，這意味著初始化 array 后，不能再 push 超過 len(array) 長度的元素

array 作為參數在函數之間傳遞時是值傳遞，相當于把數據copy了一份，具有很大的性能浪費

切片數據類型的底層結構

type slice struct {
    array unsafe.Pointer  //指向一個數組的指針
    len int  //當前 slice 的長度
    cap int  //當前 slice 的容量
}

比如我們定義了一個切片

:= make([]int, 3, 5)
 s[0] = 1
 s[1] = 2
 s[2] = 3

那么以上變量在內存中的數據結構如下圖所示

所以由上面的分析可以看出來，「切片是依賴于數組的，而且是一個指向數組的指針」,既然切片是指針類型，那么在作為參數傳遞的時候，肯定是引用類型，不需要重新copy一份而造成空間浪費。

slice 的截取

我們上面說過切片是依賴于數組的，所以切片的截取是基于數組進行截取的，截取這塊我們直接看例子就行，看例子記住一個原則即可「左包含，右不包含」

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]

以上例子都符合上面提到的「左包含，右不包含原則」

s4從下標2開始截取，截取到下標4；
s5省略了第一個參數，表示從下標0開始截取；
s6省略了第二個參數，表示截取到最后一個元素；
s7省略了兩個參數，只填寫了中間的冒號:，表示取全部元素；

切片的長度len()和容量cap()

長度很好理解，簡單理解就是「元素的個數」，容量相對難理解一些「在切片引用的底層數組中從切片的第一個元素到數組最后一個元素的長度就是切片的容量」。

我們還是來直接看例子：

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的元素是39這7個元素；容量也為7，因為s5的底層數組最后一個元素是9，39共7個元素，所以s6的容量為7。
s7更好理解了，長度和容量都是9，大家自己理解一下。

切片的常用方法

make

make方法主要是用于切片的生成，比較簡單,比如下面的例子就是我們來定義一個長度為5，容量為10的切片。

s1 := make([]int,5,10)
fmt.Printf("s1：%v len(s1)：%d cap(s1)：%d\n", s1, len(s1), cap(s1))
// 輸出結果
//s1：[0 0 0 0 0] len(s1)：5 cap(s1)：10

append

append主要是用于切片的追加。我們還是直接看例子。

var s = []int{1, 2, 3, 4}
 fmt.Println(s)
 fmt.Printf("len:%d, cap:%d", len(s), cap(s))
  //輸出結果
  [1 2 3 4]
  len:4, cap:4

我們可以看到定義了一個切片，初始化了4個元素，切片此時的長度和容量都為4。

var s = []int{1, 2, 3, 4}
 s = append(s, 5)  //給切片s追加一個元素 5
 fmt.Println(s)
 fmt.Printf("len:%d, cap:%d\n", len(s), cap(s))
  //輸出結果
  [1 2 3 4 5]
  len:5, cap:8

分析：長度由4變成5，我們很好理解；容量為什么會從4變成8呢？「這個是因為go語言對切片的自動擴容機制，append追加，如果cap不夠的時候，go底層會把底層數組替換，是go語言的一套擴容策略。」簡單說這個擴容機制就是「如果不夠，就在以前的基礎上翻倍，如果超過1M，則+1M」，跟redis的bitmap類型的擴容機制是一樣的。

slice 擴容的"坑"

func main() {
 var s = []int{1, 2, 3}
 modifySlice(s)
 fmt.Println(s) // 打印 [1 2 3]
}

func modifySlice(s []int) {
 s = append(s, 4)
 s[0] = 4
}

這個坑在面試中經常會遇到，當 slice 作為函數參數時，「如果在函數內部發生了擴容，這時再修改 slice 中的值是不起作用的」，因為修改發生在新的 array 內存中，對老的 array 內存不起作用。

如何追加多個元素

:= []int{1, 2, 3, 4}
 s2 := []int{5, 6}
 s3 := append(s1, s2...)  // ...表示拆開，將切片的值作為追加的元素
 fmt.Println(s3)
  //輸出結果
  //[1 2 3 4 5 6]

copy

//定義切片s1
s1 := []int{1, 2, 3}

//第一種方式：直接聲明變量 用=賦值
//s2切片和s1引用同一個內存地址
var s2 = s1

//第二種方式：copy
var s3 = make([]int, 3)
copy(s3, s1)            //使用copy函數將 參數2的元素復制到參數1

s1[0] = 11
fmt.Printf("s1:%v s2:%v s3:%v",s1, s2, s3) //s1和s2是[11 2 3] s3是[1 2 3]

我們發現s1和s2是[11 2 3] s3是[1 2 3]，說明copy方法是復制了一份，開辟了新的內存空間，不再引用s1的內存地址，這就是兩者的區別。

如果您覺得這篇文章還不錯，記得關注點贊哦，您的支持是我創作的最大動力。

責任編輯：武曉燕來源：程序員小飯

切片 golang 數組