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

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

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

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

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

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

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

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

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

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-

我們?nèi)匀豢梢韵裨L問數(shù)組一樣訪問切片中的元素，但是通過使用切片和append函數(shù)，我們不再需要考慮支持數(shù)組的大小。通過使用len和cap函數(shù)，我們?nèi)匀豢梢耘宄@些事情，但是我們不必太擔心它們。

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

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

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

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

如果在代碼中添加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

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

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

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

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的長度相同，因此我們可以使用該長度初始化切片，然后將每個元素分配給適當?shù)乃饕?。這種方法的缺點是我們必須跟蹤i，以便我們知道將每個值放入哪個索引。

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

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

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

這仍將在幕后構(gòu)造與上一個示例相同的數(shù)組，但是現(xiàn)在，當我們調(diào)用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 能自動擴容，為什么還要關(guān)心切片的容量

你可能要問的下一件事是：“如果append函數(shù)可以為我增加切片的容量，我們?yōu)槭裁催€要告訴程序一個容量？”

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

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

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

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

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個不同的時間分配一個新數(shù)組，此外，最后一個數(shù)組用于支持我們slice的容量為8，大于我們最終需要的容量。 另一方面，我們的第二個示例以相同的容量（5）開始和結(jié)束，并且只需要在keys()函數(shù)開始時分配一次即可。我們還避免浪費任何額外的內(nèi)存。

不要過度優(yōu)化

通常不鼓勵任何人擔心像這樣的次要優(yōu)化，但是在確實很明顯最終大小應該是多少的情況下，強烈建議為切片設置適當?shù)娜萘炕蜷L度。

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

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

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

最新評論