定義

切片本身不是數組，它指向底層的數組或者數組的一部分。因此，可以使用Slice來處理變長數組的應用場景。 Silice 是一種引用類型。

1、定義一個空的Slice

package main

import (
    "fmt"
)

func main() {
    var slice1 []int //定義一個Slice, []裏面什麽也沒有！！
    fmt.Println(slice1)
}

2、 從數組中幹獲取Slice

func main() {
    
    arr := [3]int32{1, 2, 3} // 定義一個數組
 

    slice := arr[0:len(arr)] //從數組中取得Slice，從0開始，取到結束
    fmt.Println(slice)
}

//output
[1 2 3]

3、使用“make”關鍵字創建Slice

make([]T, len, cap)

[]T - 表示定義那種類型的Slice

len - 表示Slice的長度

cap - 表示Slice的容量；可以省略，即cap=len

s1 := make([]int, 3, 5)
fmt.Println(s1)

//output
[0 0 0]

Slice與底層數組的關系圖

通過關系圖，我們可以得出： Slice_a 長度為3，容量為9， Slice_b 長度為2，容量為8

Reslice

有 Slice 再次生成的Slice。它的特點是：

1. 索引以Slice為準。

2. cap不能超過Slice

3. 索引越界不會從新分配內存，而是直接出錯！！

a2 := [5]byte{‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘}
s2 := a2[0:3]
fmt.Println(len(s2), cap(s2)) // output 3, 5

s22 := s2[0:2]
fmt.Println(len(s22), cap(s22)) 
 
// output 2, 5

Append 函數

a3 := make([]int32, 2, 4)
fmt.Printf("%v, %p\n", a3, a3)

a3 = append(a3, 1, 2)
fmt.Printf("%v, %p\n", a3, a3)

a3 = append(a3, 1, 2)
fmt.Printf("%v, %p\n", a3, a3)

//output
[0 0], 0x114821d0
[0 0 1 2], 0x114821d0
[0 0 1 2 1 2], 0x11489c60

copy 函數

copy(src, dst) - 將dest的切片 copy 到 src， 以兩者之中最短的切片長度為準。

a1 := []int32{1, 2}
a2 := []int32{3, 4, 5}
fmt.Println(a1) // output [1 2]

copy(a1, a2)
fmt.Println(a1) // output [3 4]

copy(a1[0:2], a2[1:3]) // // output [4 5]
fmt.Println(a1)

Go - 切片（Slice）