Go 數組比切片好在哪？

大家好，我是煎魚。

前段時間有播放一條快訊，就是 Go1.17 會正式支持切片（Slice）轉換到數據（Array），不再需要用以前那種騷辦法了，安全了許多。

但是也有同學提出了新的疑惑，在 Go 語言中，數組其實是用的相對較少的，甚至會有同學認爲在 Go 裏可以把數組給去掉。

數組相較切片到底有什麼優勢，我們又應該在什麼場景下使用呢？

這是一個我們需要深究的問題，因此今天就跟大家一起來一探究竟，本文會先簡單介紹數組和切片是什麼，再進一步對數組的使用場景剖析。

一起愉快地開始吸魚之路。

數組是什麼

Go 語言中有一種基本數據類型，叫數組。其格式爲：[n]T。是一個包含 N 個類型 T 的值的數組。

基本聲明格式爲：

var a [10]int

代表的是聲明瞭一個變量 a 是一個包含 10 個整數的數組。數組的長度是其類型的一部分，所以數組不能被隨意調整大小。

在使用例子上：

func main() {
 var a [2]string
 a[0] = "腦子進"
 a[1] = "煎魚了"
 fmt.Println(a[0], a[1])
 fmt.Println(a)

 primes := [6]int{2, 3, 5, 7, 11, 13}
 fmt.Println(primes)
}

輸出結果：

腦子進 煎魚了
[腦子進 煎魚了]
[2 3 5 7 11 13]

在賦值和訪問上，數組可以針對不同的索引，進行單獨操作。在內存佈局上，數組的索引 0 和 1... 是會在相鄰區域，可直接訪問。

切片是什麼

爲什麼數組在業務代碼似乎用的很少。因爲 Go 語言有一個切片的數據類型：

基本聲明格式爲：

var a []T

代表的是變量 a 是帶有類型元素的切片 T。通過指定兩個索引（下限和上限）並用冒號隔開來形成切片：

a[low : high]

在使用例子上：

func main() {
 primes := [3]string{"煎魚", "搞", "Go"}

 var s []string = primes[1:3]
 fmt.Println(s)
}

輸出結果：

[搞 Go]

切片支持動態的擴縮容，不需要用戶側去關注，非常便利。更重要的一點是，切片的底層數據結構中本身就包含了數組：

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

也就很多人笑稱：在 Go 語言中數組已經可以下崗了，用切片就完事了...

你怎麼看待這個說法的呢，快速思考你心中的答案。

數組的優勢

在風塵僕僕介紹完數組和切片的基本場景後，在數組的優勢方面，先了解一下官方的自述：

Arrays are useful when planning the detailed layout of memory and sometimes can help avoid allocation, but primarily they are a building block for slices.

非常粗暴間接：在規劃內存的詳細布局時，數組是很有用的，有時可以幫助避免分配，但主要是它們是分片的構建塊。

我們再進一步解讀，看看官方這股 “密文” 具體指的是什麼，我們將該密文解讀爲以下內容進行講解：

• 可比較。

• 編譯安全。

• 長度是類型。

• 規劃內存佈局。

• 訪問速度。

可比較

數組是固定長度的，它們之間是可以進行比較的，數組是值對象（不是引用或指針類型），你不會遇到 interface 等比較的誤判：

func main() {
 a1 := [3]string{"腦子", "進", "煎魚了"}
 a2 := [3]string{"煎魚", "進", "腦子了"}
 a3 := [3]string{"腦子", "進", "煎魚了"}

 fmt.Println(a1 == a2, a1 == a3)
}

輸出結果：

false true

另一方面，切片不可以直接比較，也不能用於判斷：

func main() {
 a1 := []string{"腦子", "進", "煎魚了"}
 a2 := []string{"煎魚", "進", "腦子了"}
 a3 := []string{"腦子", "進", "煎魚了"}

 fmt.Println(a1 == a2, a1 == a3)
}

輸出結果：

# command-line-arguments
./main.go:10:17: invalid operation: a1 == a2 (slice can only be compared to nil)
./main.go:10:27: invalid operation: a1 == a3 (slice can only be compared to nil)

同時數組可以作爲 map 的 k（鍵），而切片不行，切片並沒有實現平等運算符（equality operator），需要考慮的問題有非常多，例如：

• 涉及淺層與深層比較。

• 指針與值比較。

• 如何處理遞歸類型。

平等是爲結構體和數組定義的，所以這類類型可以作爲 map 鍵使用。切片沒有平等的定義，有着非常根本的差距。

數組的可比較和平等，切片做不到。

編譯安全

數組可以提供更高的編譯時安全，可以在編譯時檢查索引範圍。如下：

s := make([]int, 3)
s[3] = 3 // "Only" a runtime panic: runtime error: index out of range

a := [3]int{}
a[3] = 3 // Compile-time error: invalid array index 3 (out of bounds for 3-element array)

這個編譯檢查的幫助雖 “小”，但其實非常有意義。我是日常看到各大切片越界的告警，感覺都能背下來了...

萬一這個越界是在 hot path 上，影響大量用戶，分分鐘背個事故，再來個 3.25，豈不夢中驚醒？

數組的編譯安全，切片做不到。

長度是類型

數組的長度是數組類型聲明的一部分，因此長度不同的數組是不同的類型，兩個就不是一個 “東西”。

當然，這是一把雙刃劍。其優勢在於：可用於顯式指定所需數組的長度。

例如：你在業務代碼中想編寫一個使用 IPv4 地址的函數。可以聲明 type [4]byte。使用數組有以下意識：

• 有了編譯時的保證，也就是達到傳遞給你的函數的值將恰好具有 4 個字節，不多也不少的效果。

• 如果長度不對，也就可以認爲是無效的 IPv4 地址，非常方便。

同時數組的長度，也可以用做記錄目的：

• MD5 類型，在 crypto/md5包中，md5.Sum 方法返回類型爲的值，[Size]byte 其中 md5.Size 一個常量爲 16：MD5 校驗和的長度。

• IPv4 類型，所聲明的 [4]byte 正確記錄了有 4 個字節。

• RGB 類型，所聲明的 [3]byte 告訴有對每個顏色成分 1 個字節。

在特定業務場景上，使用數組更好。

規劃內存佈局

數組可以更好地控制內存佈局，因爲不能直接在帶有切片的結構中分配空間，所以可以使用數組來解決。

例如：

type Foo struct {
    buf [64]byte
}

不知道你是否有在一些 Go 圖形庫上見過這種不明所以的操作，例子如下：

type TGIHeader struct {
    _        uint16 // Reserved
    _        uint16 // Reserved
    Width    uint32
    Height   uint32
    _        [15]uint32 // 15 "don't care" dwords
    SaveTime int64
}

因爲業務需求，我們需要實現一個格式，其中格式是 "TGI"（理論上的 Go Image），頭包含這樣的字段：

• 有 2 個保留字（每個 16 位）。

• 有 1 個字的圖像寬度。

• 有 1 個字的圖像高度。

• 有 15 個業務 "不在乎" 的字節。

• 有 1 個保存時間，圖像的保存時間爲 8 字節，是自 1970 年 1 月 1 日 UTC 以來的納秒數。

這麼一看，也就不難理解數組的在這個場景下的優勢了。定長，可控的內存，在計劃內存佈局時非常有用。

訪問速度

使用數組時，其訪問（單個）數組元素比訪問切片元素更高效，時間複雜度是 O（1）。例如：

 var a [2]string
 a[0] = "腦子進"
 a[1] = "煎魚了"
 fmt.Println(a[0], a[1])

切片就沒那麼方便了，訪問某個位置上的索引值，需要：

 var a []int{0, 1, 2, 3, 4, 5}  
  number := numbers[1:3]

相對複雜些的，刪除指定索引位上的值，可能還有小夥伴糾結半天，甚至在找第三方開源庫想快速實現。

無論在訪問速度和開發效率上，數組都佔一定的優勢，這是切片所無法直接對比的。

總結

經過一輪的探討，我們對 Go 語言的數組有了更深入的理解。總結如下：

• 數組是值對象，可以進行比較，可以將數組用作 map 的映射鍵。而這些，切片都不可以，不能比較，無法作爲 map 的映射鍵。

• 數組有編譯安全的檢查，可以在早起就避免越界行爲。切片是在運行時會出現越界的 panic，階段不同。

• 數組可以更好地控制內存佈局，若拿切片替換，會發現不能直接在帶有切片的結構中分配空間，數組可以。

• 數組在訪問單個元素時，性能比切片好。

• 數組的長度，是類型的一部分。在特定場景下具有一定的意義。

• 數組是切片的基礎，每個數組都可以是一個切片，但並非每個切片都可以是一個數組。如果值是固定大小，可以通過使用數組來獲得較小的性能提升（至少節省 slice 頭佔用的空間）。

與你心目中的數組的優勢是否一致呢，歡迎大家在評論區進行討論和交流。

我是煎魚，咱們下期再見：）

參考

• In GO programming language what are the benefits of using Arrays over Slices?

• Why have arrays in Go?

本文由 Readfog 進行 AMP 轉碼，版權歸原作者所有。
來源：https://mp.weixin.qq.com/s/zp1vdhGukEYKpzAdPt--Mw