mirror of
https://github.com/gopl-zh/gopl-zh.github.com.git
synced 2024-11-24 15:18:57 +00:00
122 lines
5.6 KiB
Markdown
122 lines
5.6 KiB
Markdown
### 4.2.1. append函數
|
||
|
||
內置的append函數用於向slice追加元素：
|
||
|
||
```Go
|
||
var runes []rune
|
||
for _, r := range "Hello, 世界" {
|
||
runes = append(runes, r)
|
||
}
|
||
fmt.Printf("%q\n", runes) // "['H' 'e' 'l' 'l' 'o' ',' ' ' '世' '界']"
|
||
```
|
||
|
||
在循環中使用append函數構建一個由九個rune字符構成的slice，當然對應這個特殊的問題我們可以通過Go語言內置的[]rune("Hello, 世界")轉換操作完成。
|
||
|
||
append函數對於理解slice底層是如何工作的非常重要，所以讓我們仔細査看究竟是發生了什麽。下面是第一個版本的appendInt函數，專門用於處理[]int類型的slice：
|
||
|
||
```Go
|
||
gopl.io/ch4/append
|
||
|
||
func appendInt(x []int, y int) []int {
|
||
var z []int
|
||
zlen := len(x) + 1
|
||
if zlen <= cap(x) {
|
||
// There is room to grow. Extend the slice.
|
||
z = x[:zlen]
|
||
} else {
|
||
// There is insufficient space. Allocate a new array.
|
||
// Grow by doubling, for amortized linear complexity.
|
||
zcap := zlen
|
||
if zcap < 2*len(x) {
|
||
zcap = 2 * len(x)
|
||
}
|
||
z = make([]int, zlen, zcap)
|
||
copy(z, x) // a built-in function; see text
|
||
}
|
||
z[len(x)] = y
|
||
return z
|
||
}
|
||
```
|
||
|
||
每次調用appendInt函數，必鬚先檢測slice底層數組是否有足夠的容量來保存新添加的元素。如果有足夠空間的話，直接擴展slice（依然在原有的底層數組之上），將新添加的y元素複製到新擴展的空間，併返迴slice。因此，輸入的x和輸出的z共享相同的底層數組。
|
||
|
||
如果沒有足夠的增長空間的話，appendInt函數則會先分配一個足夠大的slice用於保存新的結果，先將輸入的x複製到新的空間，然後添加y元素。結果z和輸入的x引用的將是不同的底層數組。
|
||
|
||
雖然通過循環複製元素更直接，不過內置的copy函數可以方便地將一個slice複製另一個相同類型的slice。copy函數的第一個參數是要複製的目標slice，第二個參數是源slice，目標和源的位置順序和`dst = src`賦值語句是一致的。兩個slice可以共享同一個底層數組，甚至有重疊也沒有問題。copy函數將返迴成功複製的元素的個數（我們這里沒有用到），等於兩個slice中較小的長度，所以我們不用擔心覆蓋會超出目標slice的范圍。
|
||
|
||
爲了提高內存使用效率，新分配的數組一般略大於保存x和y所需要的最低大小。通過在每次擴展數組時直接將長度翻倍從而避免了多次內存分配，也確保了添加單個元素操的平均時間是一個常數時間。這個程序演示了效果：
|
||
|
||
```Go
|
||
func main() {
|
||
var x, y []int
|
||
for i := 0; i < 10; i++ {
|
||
y = appendInt(x, i)
|
||
fmt.Printf("%d cap=%d\t%v\n", i, cap(y), y)
|
||
x = y
|
||
}
|
||
}
|
||
```
|
||
|
||
每一次容量的變化都會導致重新分配內存和copy操作：
|
||
|
||
```
|
||
0 cap=1 [0]
|
||
1 cap=2 [0 1]
|
||
2 cap=4 [0 1 2]
|
||
3 cap=4 [0 1 2 3]
|
||
4 cap=8 [0 1 2 3 4]
|
||
5 cap=8 [0 1 2 3 4 5]
|
||
6 cap=8 [0 1 2 3 4 5 6]
|
||
7 cap=8 [0 1 2 3 4 5 6 7]
|
||
8 cap=16 [0 1 2 3 4 5 6 7 8]
|
||
9 cap=16 [0 1 2 3 4 5 6 7 8 9]
|
||
```
|
||
|
||
讓我們仔細査看i=3次的迭代。當時x包含了[0 1 2]三個元素，但是容量是4，因此可以簡單將新的元素添加到末尾，不需要新的內存分配。然後新的y的長度和容量都是4，併且和x引用着相同的底層數組，如圖4.2所示。
|
||
|
||
|
||
|
||
在下一次迭代時i=4，現在沒有新的空餘的空間了，因此appendInt函數分配一個容量爲8的底層數組，將x的4個元素[0 1 2 3]複製到新空間的開頭，然後添加新的元素i，新元素的值是4。新的y的長度是5，容量是8；後面有3個空閒的位置，三次迭代都不需要分配新的空間。當前迭代中，y和x是對應不同底層數組的view。這次操作如圖4.3所示。
|
||
|
||
|
||
|
||
內置的append函數可能使用比appendInt更複雜的內存擴展策略。因此，通常我們併不知道append調用是否導致了內存的重新分配，因此我們也不能確認新的slice和原始的slice是否引用的是相同的底層數組空間。同樣，我們不能確認在原先的slice上的操作是否會影響到新的slice。因此，通常是將append返迴的結果直接賦值給輸入的slice變量：
|
||
|
||
```Go
|
||
runes = append(runes, r)
|
||
```
|
||
|
||
更新slice變量不僅對調用append函數是必要的，實際上對應任何可能導致長度、容量或底層數組變化的操作都是必要的。要正確地使用slice，需要記住盡管底層數組的元素是間接訪問的，但是slice對應結構體本身的指針、長度和容量部分是直接訪問的。要更新這些信息需要像上面例子那樣一個顯式的賦值操作。從這個角度看，slice併不是一個純粹的引用類型，它實際上是一個類似下面結構體的聚合類型：
|
||
|
||
```Go
|
||
type IntSlice struct {
|
||
ptr *int
|
||
len, cap int
|
||
}
|
||
```
|
||
|
||
我們的appendInt函數每次隻能向slice追加一個元素，但是內置的append函數則可以追加多個元素，甚至追加一個slice。
|
||
|
||
```Go
|
||
var x []int
|
||
x = append(x, 1)
|
||
x = append(x, 2, 3)
|
||
x = append(x, 4, 5, 6)
|
||
x = append(x, x...) // append the slice x
|
||
fmt.Println(x) // "[1 2 3 4 5 6 1 2 3 4 5 6]"
|
||
```
|
||
|
||
通過下面的小脩改，我們可以可以達到append函數類似的功能。其中在appendInt函數參數中的最後的“...”省略號表示接收變長的參數爲slice。我們將在5.7節詳細解釋這個特性。
|
||
|
||
```Go
|
||
func appendInt(x []int, y ...int) []int {
|
||
var z []int
|
||
zlen := len(x) + len(y)
|
||
// ...expand z to at least zlen...
|
||
copy(z[len(x):], y)
|
||
return z
|
||
}
|
||
```
|
||
|
||
爲了避免重複，和前面相同的代碼併沒有顯示。
|