兄弟連go教程（17）資料 - Slice

需要說明，slice 並不是陣列或陣列指標。它通過內部指標和相關屬性引⽤用陣列⽚片段，以
實現變⻓長⽅方案。

runtime.h
struct Slice
{ // must not move anything
byte* array; // actual data
uintgo len; // number of elements
uintgo cap; // allocated number of elements
};

•引⽤用型別。但⾃自⾝身是結構體，值拷⻉貝傳遞。
•屬性 len 表⽰示可⽤用元素數量，讀寫操作不能超過該限制。
•屬性 cap 表⽰示最⼤大擴張容量，不能超出陣列限制。
•如果 slice == nil，那麼 len、cap 結果都等於 0。
d

ata := [...]int{0, 1, 2, 3, 4, 5, 6}
slice := data[1:4:5] // [low : high : max]
+- low high -+ +- max len = high - low
| | | cap = max - low
+---+---+---+---+---+---+---+ +---------+---------+---------+
data | 0 | 1 | 2 | 3 | 4 | 5 | 6 | slice | pointer | len = 3 | cap = 4 |
+---+---+---+---+---+---+---+ +---------+---------+---------+
|<--- len ---->| | |
| | |
|<----- cap ------->| |
| |
+-------<<<-------- slice.array pointer ---<<<-----+

建立表示式使⽤用的是元素索引號，⽽而⾮非數量。

data := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
expression slice len cap comment
------------+----------------------+------+-------+---------------------
data[:6:8] [0 1 2 3 4 5] 6 8 省略 low.
data[5:] [5 6 7 8 9] 5 5 省略 high、max。
data[:3] [0 1 2] 3 10 省略 low、max。
data[:] [0 1 2 3 4 5 6 7 8 9] 10 10 全部省略。

讀寫操作實際⺫⽬目標是底層陣列，只需注意索引號的差別。

data := [...]int{0, 1, 2, 3, 4, 5}
s := data[2:4]
s[0] += 100
s[1] += 200
fmt.Println(s)
fmt.Println(data)

輸出：

[102 203]
[0 1 102 203 4 5]

可直接建立 slice 物件，⾃自動分配底層陣列。

s1 := []int{0, 1, 2, 3, 8: 100} // 通過初始化表示式構造，可使⽤用索引號。
fmt.Println(s1, len(s1), cap(s1))
s2 := make([]int, 6, 8) // 使⽤用 make 建立，指定 len 和 cap 值。
fmt.Println(s2, len(s2), cap(s2))
s3 := make([]int, 6) // 省略 cap，相當於 cap = len。
fmt.Println(s3, len(s3), cap(s3))

輸出：

[0 1 2 3 0 0 0 0 100] 9 9
[0 0 0 0 0 0] 6 8
[0 0 0 0 0 0] 6 6

使⽤用 make 動態建立 slice，避免了陣列必須⽤用常量做⻓長度的⿇麻煩。還可⽤用指標直接訪問
底層陣列，退化成普通陣列操作。

s := []int{0, 1, 2, 3}

p := &s[2] // *int, 獲取底層陣列元素指標。
*p += 100
fmt.Println(s)

輸出：

[0 1 102 3]

至於 [][]T，是指元素型別為 []T 。

data := [][]int{
[]int{1, 2, 3},
[]int{100, 200},
[]int{11, 22, 33, 44},
}

可直接修改 struct array/slice 成員。

d := [5]struct {
x int
}{}
s := d[:]
d[1].x = 10
s[2].x = 20
fmt.Println(d)
fmt.Printf("%p, %p\n", &d, &d[0])

輸出:

[{0} {10} {20} {0} {0}]
0x20819c180, 0x20819c180

1 . reslice
所謂 reslice，是基於已有 slice 建立新 slice 物件，以便在 cap 允許範圍內調整屬性。

s := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
s1 := s[2:5] // [2 3 4]
s2 := s1[2:6:7] // [4 5 6 7]
s3 := s2[3:6] // Error

+---+---+---+---+---+---+---+---+---+---+
data | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |
+---+---+---+---+---+---+---+---+---+---+
0 2 5
+---+---+---+---+---+---+---+---+
s1 | 2 | 3 | 4 | | | | | | len = 3, cap = 8
+---+---+---+---+---+---+---+---+
0 2 6 7
+---+---+---+---+---+
s2 | 4 | 5 | 6 | 7 | | len = 4, cap = 5
+---+---+---+---+---+
0 3 4 5
+---+---+---+
s3 | 7 | 8 | X | error: slice bounds out of range
+---+---+---+

新物件依舊指向原底層陣列。

s := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
s1 := s[2:5] // [2 3 4]
s1[2] = 100
s2 := s1[2:6] // [100 5 6 7]
s2[3] = 200
fmt.Println(s)

輸出：

[0 1 2 3 100 5 6 200 8 9]

2 .append

向 slice 尾部新增資料，
向 slice 尾部新增資料，返回新的 slice 物件。

s := make([]int, 0, 5)
fmt.Printf("%p\n", &s)
s2 := append(s, 1)
fmt.Printf("%p\n", &s2)
fmt.Println(s, s2)

輸出：

0x210230000
0x210230040
[] [1]

簡單點說，就是在 array[slice.high] 寫資料。

data := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

s := data[:3]
s2 := append(s, 100, 200) // 新增多個值。
fmt.Println(data)
fmt.Println(s)
fmt.Println(s2)

輸出：

[0 1 2 100 200 5 6 7 8 9]
[0 1 2]
[0 1 2 100 200]

一旦超出原 slice.cap 限制，就會重新分配底層陣列，即便原陣列並未填滿。

data := [...]int{0, 1, 2, 3, 4, 10: 0}
s := data[:2:3]
s = append(s, 100, 200) // ⼀一次 append 兩個值，超出 s.cap 限制。
fmt.Println(s, data) // 重新分配底層陣列，與原陣列⽆無關。
fmt.Println(&s[0], &data[0]) // ⽐比對底層陣列起始指標。

輸出：

[0 1 100 200] [0 1 2 3 4 0 0 0 0 0 0]
0x20819c180 0x20817c0c0

從輸出結果可以看出，append 後的 s 重新分配了底層陣列，並複製資料。如果只追加⼀一
個值，則不會超過 s.cap 限制，也就不會重新分配。
通常以 2 倍容量重新分配底層陣列。在⼤大批量新增資料時，建議⼀一次性分配⾜足夠⼤大的空
間，以減少記憶體分配和資料複製開銷。或初始化⾜足夠⻓長的 len 屬性，改⽤用索引號進⾏行操
作。及時釋放不再使⽤用的 slice 物件，避免持有過期陣列，造成 GC ⽆無法回收。

s := make([]int, 0, 1)
c := cap(s)
for i := 0; i < 50; i++ {
s = append(s, i)
if n := cap(s); n > c {
fmt.Printf("cap: %d -> %d\n", c, n)
c = n
}
}

輸出:

cap: 1 -> 2
cap: 2 -> 4

cap: 4 -> 8
cap: 8 -> 16
cap: 16 -> 32
cap: 32 -> 64

3. copy
函式 copy 在兩個 slice 間複製資料，複製⻓長度以 len ⼩小的為準。兩個 slice 可指向同⼀一
底層陣列，允許元素區間重疊。
d

ata := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
s := data[8:]
s2 := data[:5]
copy(s2, s) // dst:s2, src:s
fmt.Println(s2)
fmt.Println(data)

輸出：

[8 9 2 3 4]
[8 9 2 3 4 5 6 7 8 9]

應及時將所需資料 copy 到較⼩小的 slice，以便釋放超⼤大號底層陣列記憶體。

尹成老師

QQ77025077 

微信18510341407

所有視訊在尹成學院

www.yinchengxueyuan.com

尹成百度雲請聯絡QQ475318423