09-引用類型-1-切片

• ​​一 切片建立​​
• ​​二 切片常見操作​​

• ​​2.1 切片常見内置函數​​
• ​​2.2 切片的一些簡便操作​​
• ​​2.3 切片的截取​​
• ​​2.4 字元串轉切片​​

• ​​三 切片存儲結構​​
• ​​四 切片作為函數參數​​

一 切片建立

切片(slice)解決了數組長度不能擴充，以及基本類型數組傳遞時産生副本的問題。

常用建立方式：

var s1 []int                // 和聲明數組一樣，隻是沒有長度，但是這樣做沒有意義，因為底層的數組指針為nil
s2 := []byte {'a','b','c'}
fmt.Println(s1)                //輸出 []
fmt.Print(s2)                //輸出 [97 98 99]      

使用make函數建立：

slice1 := make([]int,5)        // 建立長度為5，容量為5，初始值為0的切片
slice2 := make([]int,5,7)    // 建立長度為5，容量為7，初始值為0的切片
slice3 := []int{1,2,3,4,5}    // 建立長度為5，容量為5，并已經初始化的切片      

從數組建立：slice可以從一個數組再次聲明。slice通過array[i:j]來擷取，其中i是數組的開始位置，j是結束位置，但不包含array[j]，它的長度是j-i:

// 聲明一個含有10個元素元素類型為byte的數組
var arr = [10]byte {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}

// 聲明兩個含有byte的slice
ar a, b []byte

// a指向數組的第3個元素開始，并到第五個元素結束，現在a含有的元素: ar[2]、ar[3]和ar[4]
a = arr[2:5]        
// b是數組arr的另一個slicre,b的元素是：ar[3]和ar[4]
b = arr[3:5]      

注意：聲明數組時，方括号内寫明了數組的長度或使用…自動計算長度，而聲明slice時，方括号内沒有任何字元。

從切片建立：

oldSlice := []int{1,2,3}
newSlice := oldSlice[:6]    //基于切片前6個元素建立，沒有的預設0      

注意：如果選擇的舊切片長度超出了舊切片的cap()值（切片存儲長度），則不合法。

二 切片常見操作

2.1 切片常見内置函數

切片常用内置函數：

len()     傳回切片長度
cap()     傳回切片底層數組容量
append()    對切片追加元素
func copy(dst, src []Type) int
        将src中資料拷貝到dst中，傳回拷貝的元素個數      

切片空間與元素個數：

slice1 := make([]int, 5, 10)
fmt.Println(len(slice1))            // 5
fmt.Println(cap(slice1))            // 10
fmt.Println(slice1)                    // [0 0 0 0 0]      

切片操作

//切片增加
slice1 = append(slice1,1,2)
fmt.Println(slice1)                        //輸出[0 0 0 0 0 1 2]

//切片增加一個新切片
sliceTemp := make([]int,3)
slice1 = append(slice1,sliceTemp...)
fmt.Println(slice1)                        //輸出[0 0 0 0 0 1 2 0 0 0]

//切片拷貝
s1 := []int{1,3,6,9}
s2 := make([]int, 10)    //必須給與充足的空間
num := copy(s2, s1)

fmt.Println(s1)            //[1 3 6 9]
fmt.Println(s2)            //[1 3 6 9 0 0 0 0 0 0]
fmt.Println(num)        //4

//切片中删除元素
s1 := []int{1,3,6,9}
index := 2                    //删除該位置元素
s1 = append(s1[:index], s1[index+1:]...)
fmt.Println(s1)                //[1 3 9]

// 切片拷貝
s1 := []int{1,2,3,4,5}
s2 := []int{6,7,8}
copy(s1,s2)                //複制s2前三個元素到slice1前3位置
copy(s2,s1)                    //複制s1前三個元素到slice2      

注意：沒有…會編譯錯誤，預設第二個參數後是元素值，傳入切片需要展開。如果追加的長度超過目前已配置設定的存儲空間，切片會自動配置設定更大的記憶體。

2.2 切片的一些簡便操作

• slice的預設開始位置是0，ar[:n]等價于ar[0:n]
• slice的第二個序列預設是數組的長度，ar[n:]等價于ar[n:len(ar)]
• 如果從一個數組裡面直接擷取slice，可以這樣ar[:]，因為預設第一個序列是0，第二個是數組的長度，即等價于ar[0:len(ar)]
• 切片的周遊可以使用for循環，也可以使用range函數

// 聲明一個數組
var array = [10]byte{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
// 聲明兩個slice
var aSlice, bSlice []byte

// 示範一些簡便操作
aSlice = array[:3] // 等價于aSlice = array[0:3] aSlice包含元素: a,b,c
aSlice = array[5:] // 等價于aSlice = array[5:10] aSlice包含元素: f,g,h,i,j
aSlice = array[:] // 等價于aSlice = array[0:10] 這樣aSlice包含了全部的元素

// 從slice中擷取slice
aSlice = array[3:7] // aSlice包含元素: d,e,f,g，len=4，cap=7
bSlice = aSlice[1:3] // bSlice 包含aSlice[1], aSlice[2] 也就是含有: e,f
bSlice = aSlice[:3] // bSlice 包含 aSlice[0], aSlice[1], aSlice[2] 也就是含有: d,e,f
bSlice = aSlice[0:5] // 對slice的slice可以在cap範圍内擴充，此時bSlice包含：d,e,f,g,h
bSlice = aSlice[:] // bSlice包含所有aSlice的元素: d,e,f,g      

2.3 切片的截取

• ​

  ​s[n]​

  ​：切片s中索引為位置為n的項
• ​

  ​s[:]​

  ​​：從切片s的索引位置0到​

  ​len(s)-1​

  ​所獲得的切片
• ​

  ​s[low:]​

  ​​：從切片s的索引位置low到​

  ​len(s)-1​

  ​所獲得的切片
• ​

  ​s[:high]​

  ​：從切片s的索引位置0到high所獲得的切片
• ​

  ​s[low:high]​

  ​：從切片s的索引位置low到high所獲得的切片
• ​

  ​s[low:high:max]​

  ​​：從low到high的切片，且容量​

  ​cap=max-low​

  ​

2.4 字元串轉切片

str := "hello,世界"
a := []byte(str)        //字元串轉換為[]byte類型切片
b := []rune(str)        //字元串轉換為[]rune類型切片      

三 切片存儲結構

與數組相比，切片多了一個存儲能力值的概念，即元素個數與配置設定空間可以是兩個不同的值，其結構如下所示：

type slice struct {
    arrary = unsafe.Pointer        //指向底層數組的指針
    len int                        //切片元素數量
    cap int                        //底層數組的容量
}      

四 切片作為函數參數

func test(s []int) {
    fmt.Printf("test---%p\n", s) // 列印與main函數相同的位址
    s = append(s, 1, 2, 3, 4, 5)
    fmt.Printf("test---%p\n", s) // 一旦append的資料超過切片長度，則會列印新位址
    fmt.Println("test---", s)    // [0 0 0 1 2 3 4 5]
}

func main() {

    s1 := make([]int, 3)
    test(s1)
    fmt.Printf("main---%p\n", s1) // 不會因為test函數内的append而改變
    fmt.Println("main---", s1)    // [ 0 0 0]
}