來做一個快速測驗-以下代碼輸出什么？

vals := make([]int, 5)
for i := 0; i  5; i++ {
 vals = append(vals, i)
}
fmt.Println(vals)

Run it on the Go Playground → https://play.golang.org/p/7PgUqBdZ6Z

如果猜到了[0 0 0 0 0 0 1 2 3 4]，那么你是正確的。 等一下為什么不是[0 1 2 3 4]？

如果答錯了，也不擔心。從其他語言過渡到Go時，這是一個相當普遍的錯誤，在本文中，我們將介紹為什么輸出不符合你的預期以及如何利用Go的細微差別來提高代碼效率。

Slices vs Arrays

在Go中，既有數組又有切片。切片和數組之間有很多區別，數組的長度是其類型的一部分，所以數組不能改變大小，而切片可以具有動態大小，因為切片是數組的包裝。這是什么意思？假設我們有一個數組var a [10]int。此數組的大小固定，無法更改。如果我們調用len(a)，它將始終返回10，因為該大小10是該類型[10]int的一部分。如果你在數組中需要10個以上的項，則必須創建一個類型完全不同的新對象，例如var b [11] int，然后將所有值從a復制到b。

雖然在特定情況下使用具有固定大小的數組很有價值，但通常來說這并不是開發人員想要的。相反，我們希望使用與Go中的數組類似的東西，但是具有隨著時間增加長度的能力。一種簡單的方法是創建一個比需要的數組大得多的數組，然后將該數組的子集當作使用的數組。下面的代碼顯示了一個示例。

var vals [20]int
for i := 0; i  5; i++ {
 vals[i] = i * i
}
subsetLen := 5

fmt.Println("The subset of our array has a length of:", subsetLen)

// Add a new item to our array
vals[subsetLen] = 123
subsetLen++
fmt.Println("The subset of our array has a length of:", subsetLen)

Run it on the Go Playground → https://play.golang.org/p/Np6-NEohm2

上面代碼中，我們將一個數組其大小設置為20，但是由于我們僅使用一個子集，因此我們的代碼可以假裝數組的長度為5，然后在向數組中添加新項后為6。

（很粗略地說）這就是切片的工作方式。它們包裝一個具有設定大小的數組，就像上一個示例中的數組具有20的設定大小一樣。它們還跟蹤程序可使用的數組子集-length屬性，它類似于上一示例中的subsetLen變量。

切片還具有一個容量，類似于上一個示例中數組（20）的總長度。這很有用，因為它告訴你子集可以增長多大之后才能不再適合支撐切片的底層數組。當發生這種情況時，將會分配一個新的數組來支撐切片，但是所有這些邏輯都隱藏在append函數的后面。

簡而言之，將slice與append函數結合在一起可以為我們提供一種與數組非常相似的類型，但是隨著時間的增長，它可以處理更多元素。

讓我們再次看一下前面的示例，但是這次我們將使用切片而不是數組。

var vals []int
for i := 0; i  5; i++ {
 vals = append(vals, i)
 fmt.Println("The length of our slice is:", len(vals))
 fmt.Println("The capacity of our slice is:", cap(vals))
}

// Add a new item to our array
vals = append(vals, 123)
fmt.Println("The length of our slice is:", len(vals))
fmt.Println("The capacity of our slice is:", cap(vals))

// Accessing items is the same as an array
fmt.Println(vals[5])
fmt.Println(vals[2])

Run it on the Go Playground →https://play.golang.org/p/M_qaNGVbC-

我們仍然可以像訪問數組一樣訪問切片中的元素，但是通過使用切片和append函數，我們不再需要考慮支持數組的大小。通過使用len和cap函數，我們仍然可以弄清楚這些事情，但是我們不必太擔心它們。

考慮到這一點，讓我們回顧一下文章開頭的測驗代碼，看看出了什么問題。

vals := make([]int, 5)
for i := 0; i  5; i++ {
 vals = append(vals, i)
}
fmt.Println(vals)

調用make時，我們最多可以傳入3個參數。第一個是我們要分配的類型，第二個是類型的長度，第三個是類型的容量（此參數是可選的）。

通過make([] int, 5)，我們告訴程序要創建一個長度為5的切片，并且容量默認為提供的長度-在這里是5。雖然這看起來似乎是我們最初想要的，但這里的重要區別是我們告訴切片要將長度和容量都設置為5，make 將切片初始化為[0 ,0 ,0 ,0 ,0]然后繼續調用append函數，因此它將增加容量并在切片的末尾開始添加新元素。

如果在代碼中添加Println()語句，可以看到容量的變化。

vals := make([]int, 5)
fmt.Println("Capacity was:", cap(vals))
for i := 0; i  5; i++ {
 vals = append(vals, i)
 fmt.Println("Capacity is now:", cap(vals))
}

fmt.Println(vals)

Run it on the Go Playground →https://play.golang.org/p/d6OUulTYM7

結果，我們最終得到了輸出[0 0 0 0 0 0 0 1 2 3 4]而不是期望的[0 1 2 3 4]。 我們該如何解決？嗯，有幾種方法可以做到這一點，我們將介紹其中兩種，你可以擇最適合自己情況的一種。

不使用 append, 直接用索引寫入

第一個解決方法是保持make調用不變，并明確聲明要將每個元素設置為的索引。

vals := make([]int, 5)
for i := 0; i  5; i++ {
 vals[i] = i
}
fmt.Println(vals)

Run it on the Go Playground → https://play.golang.org/p/d6OUulTYM7

我們設置的值恰好與我們要使用的索引相同，但是您也可以獨立跟蹤索引。 例如，如果您想獲取map的key，則可以使用以下代碼:

package main

import "fmt"

func main() {
 fmt.Println(keys(map[string]struct{}{
  "dog": struct{}{},
  "cat": struct{}{},
 }))
}

func keys(m map[string]struct{}) []string {
 ret := make([]string, len(m))
 i := 0
 for key := range m {
  ret[i] = key
  i++
 }
 return ret
}

Run it on the Go Playground → https://play.golang.org/p/kIKxkdX35B

這之所以行之有效，是因為我們知道返回的切片的確切長度將與map的長度相同，因此我們可以使用該長度初始化切片，然后將每個元素分配給適當的索引。這種方法的缺點是我們必須跟蹤i，以便我們知道將每個值放入哪個索引。

這導致我們進入第二種方法

使用0作為長度，并指定容量

我們更新make調用，在切片類型之后為其提供兩個參數。首先，新切片的長度將設置為0，因此我們沒有在切片中添加任何新元素。第二個參數是新切片的容量，將被設置為map參數的長度，因為我們知道切片最終的長度就是 map 的長度。

這仍將在幕后構造與上一個示例相同的數組，但是現在，當我們調用append時，它將知道將元素放置在切片的開頭，因為切片的長度為0。

package main

import "fmt"

func main() {
 fmt.Println(keys(map[string]struct{}{
  "dog": struct{}{},
  "cat": struct{}{},
 }))
}

func keys(m map[string]struct{}) []string {
 ret := make([]string, 0, len(m))
 for key := range m {
  ret = append(ret, key)
 }
 return ret
}

Run it on the Go Playground →https://play.golang.org/p/h5hVAHmqJm

使用 append 能自動擴容，為什么還要關心切片的容量

你可能要問的下一件事是：“如果append函數可以為我增加切片的容量，我們為什么還要告訴程序一個容量？”

事實是，在大多數情況下，無需太擔心這一點。如果它使您的代碼復雜得多，只需使用var vals []int初始化切片，然后讓append函數處理繁重的工作。但是針對知道切片最終長度的情況，我們可以在初始化切片時聲明其容量，從而使程序不必執行不必要的內存分配。

請在Go Playground上運行以下代碼。每當容量增加時，我們的程序就需要執行另一次內存分配：

package main

import "fmt"

func main() {
 fmt.Println(keys(map[string]struct{}{
  "dog":    struct{}{},
  "cat":    struct{}{},
  "mouse":   struct{}{},
  "wolf":   struct{}{},
  "alligator": struct{}{},
 }))
}

func keys(m map[string]struct{}) []string {
 var ret []string
 fmt.Println(cap(ret))
 for key := range m {
  ret = append(ret, key)
  fmt.Println(cap(ret))
 }
 return ret
}

Run it on the Go Playground → https://play.golang.org/p/fDbAxtAjLF

現在將切片預設容量后將其與上面相同的代碼進行比較：

package main

import "fmt"

func main() {
 fmt.Println(keys(map[string]struct{}{
  "dog":    struct{}{},
  "cat":    struct{}{},
  "mouse":   struct{}{},
  "wolf":   struct{}{},
  "alligator": struct{}{},
 }))
}

func keys(m map[string]struct{}) []string {
 ret := make([]string, 0, len(m))
 fmt.Println(cap(ret))
 for key := range m {
  ret = append(ret, key)
  fmt.Println(cap(ret))
 }
 return ret
}

Run it on the Go Playground → https://play.golang.org/p/nwT8X9-7eQ

在第一個代碼示例中，我們的容量從0開始，然后增加到1、2、4，最后是8，這意味著我們必須在5個不同的時間分配一個新數組，此外，最后一個數組用于支持我們slice的容量為8，大于我們最終需要的容量。 另一方面，我們的第二個示例以相同的容量（5）開始和結束，并且只需要在keys()函數開始時分配一次即可。我們還避免浪費任何額外的內存。

不要過度優化

通常不鼓勵任何人擔心像這樣的次要優化，但是在確實很明顯最終大小應該是多少的情況下，強烈建議為切片設置適當的容量或長度。

它不僅有助于提高應用程序的性能，而且還可以通過明確說明輸入大小和輸出大小之間的關系來幫助理清代碼。

本文并不是要對切片或數組之間的差異進行詳盡的討論，而只是要簡要介紹容量和長度如何影響切片以及它們在不同解決方案中的作用。

以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支持腳本之家。