gopl-zh.github.com/ch4/ch4-02-1.md

122 lines
5.6 KiB
Markdown
Raw Normal View History

2015-12-28 06:49:32 +00:00
### 4.2.1. append函數
2015-12-29 03:22:08 +00:00
內置的append函數用於向slice追加元素
```Go
var runes []rune
for _, r := range "Hello, 世界" {
runes = append(runes, r)
}
fmt.Printf("%q\n", runes) // "['H' 'e' 'l' 'l' 'o' ',' ' ' '世' '界']"
```
2016-01-06 08:11:13 +00:00
在循環中使用append函數構建一個由九個rune字符構成的slice當然對應這個特殊的問題我們可以通過Go語言內置的[]rune("Hello, 世界")轉換操作完成。
2015-12-29 03:22:08 +00:00
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
}
```
2016-01-18 03:22:04 +00:00
每次調用appendInt函數必須先檢測slice底層數組是否有足夠的容量來保存新添加的元素。如果有足夠空間的話直接擴展slice依然在原有的底層數組之上將新添加的y元素複製到新擴展的空間併返迴slice。因此輸入的x和輸出的z共享相同的底層數組。
2015-12-29 03:22:08 +00:00
如果沒有足夠的增長空間的話appendInt函數則會先分配一個足夠大的slice用於保存新的結果先將輸入的x複製到新的空間然後添加y元素。結果z和輸入的x引用的將是不同的底層數組。
2016-01-06 13:17:08 +00:00
雖然通過循環複製元素更直接不過內置的copy函數可以方便地將一個slice複製另一個相同類型的slice。copy函數的第一個參數是要複製的目標slice第二個參數是源slice目標和源的位置順序和`dst = src`賦值語句是一致的。兩個slice可以共享同一個底層數組甚至有重疊也沒有問題。copy函數將返迴成功複製的元素的個數我們這里沒有用到等於兩個slice中較小的長度所以我們不用擔心覆蓋會超出目標slice的范圍。
2015-12-29 03:22:08 +00:00
2016-01-06 13:17:08 +00:00
爲了提高內存使用效率新分配的數組一般略大於保存x和y所需要的最低大小。通過在每次擴展數組時直接將長度翻倍從而避免了多次內存分配也確保了添加單個元素操的平均時間是一個常數時間。這個程序演示了效果
2015-12-29 03:22:08 +00:00
```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所示。
![](../images/ch4-02.png)
2016-01-06 13:17:08 +00:00
在下一次迭代時i=4現在沒有新的空餘的空間了因此appendInt函數分配一個容量爲8的底層數組將x的4個元素[0 1 2 3]複製到新空間的開頭然後添加新的元素i新元素的值是4。新的y的長度是5容量是8後面有3個空閒的位置三次迭代都不需要分配新的空間。當前迭代中y和x是對應不同底層數組的view。這次操作如圖4.3所示。
2015-12-29 03:22:08 +00:00
![](../images/ch4-03.png)
2016-01-06 13:17:08 +00:00
內置的append函數可能使用比appendInt更複雜的內存擴展策略。因此通常我們併不知道append調用是否導致了內存的重新分配因此我們也不能確認新的slice和原始的slice是否引用的是相同的底層數組空間。同樣我們不能確認在原先的slice上的操作是否會影響到新的slice。因此通常是將append返迴的結果直接賦值給輸入的slice變量
2015-12-29 03:22:08 +00:00
```Go
runes = append(runes, r)
```
2016-01-06 13:17:08 +00:00
更新slice變量不僅對調用append函數是必要的實際上對應任何可能導致長度、容量或底層數組變化的操作都是必要的。要正確地使用slice需要記住盡管底層數組的元素是間接訪問的但是slice對應結構體本身的指針、長度和容量部分是直接訪問的。要更新這些信息需要像上面例子那樣一個顯式的賦值操作。從這個角度看slice併不是一個純粹的引用類型它實際上是一個類似下面結構體的聚合類型
2015-12-29 03:22:08 +00:00
```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
}
```
爲了避免重複,和前面相同的代碼併沒有顯示。