go語言學習筆記之slice用法

一、slice的概念：

Slices（切片）slice是概念上一個結構包含三個域：一個數組的指標、長度和容量。切片支援[]操作符來訪問底層數組的元素。內建的len函數返回的切片長度。內建的的cap函數返回切片的容量。

切片是參考型別，這意味著如果你將一個切片賦值給另外一個切片，這兩個切片將引用同一個底層數組。

二、如何建立slice

建立切片可用以下兩種方法：

（1）直接建立：

s := make([]int, 10)

建立了名為s 的,有10個元素(長度等於10)的整數類型切片

如果建立後沒有給slice賦值，那麼slice的值為建立類型的預設值，如：

packagemain

import"fmt"

funcmain(){

 s:=make([]int,10)

 fmt.Println(s)

}

//output

//[0000000000]

或

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

建立了名為s 有5個元素的整數類型切片，並為每個元素賦值分別為1,2,3,4,5

（2）間接建立：

先建數組a 再用數組建立切片s

var a [10]int

s := a[1:5] //a[1],a[2],a[3],a[4]

建立了名為s 長度為4 容量為10 的整數類型切片，即len(s)等於4,cap(s)等於10 （效果與使用make([]int,4, 10)相似）

切片s 指向數組a[1],a[2],a[3],a[4]

當數組a 的值改變，切片s 的值也會變，因為切片s 引用數組a

(如果多個切片指向同一個數組,當這個底層數組值改變時，指向它的多個切片的值也會變)

 

也可以重新指定：

s = a[0:8]  //s 指向數組 a[0]至 a[7]

s = s[2:5]  //s 指向原切片的s[2],s[3],s[4]三個元素。

            //用[x:y]時總會指向x 至 y -1 的元素

            //當x為首個元素 或y為最後一個元素時可以省略不寫

package main

import "fmt"

func main() {

         vara = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}

         s:= a[1:5]    //表示取a數組中啊a[1]到a[4]的元素值

         fmt.Println(s)//output:  [2 3 4 5]

         a[2]= 21

         fmt.Println(s)//output:[2 21 4 5] ，說明切片s和數組a指向同一記憶體空間

}

//output:

//[2 3 4 5]

//[2 21 4 5]

增加元素：

用append函數可增加切片的長度

s := []int{1,2,3}    //建切片s

s = append(s, 4, 5)    //當追加的是值時(可以是1個或多個)

            //它為切片s 增加兩個元素，並賦值為4 和5 

也可以為切片追加切片

a := []int{6, 7}     //建切片a

s = append(s,a...)    //當追加的是切片時後面要有三個點

            //為切片s 追加切片a得出s 等於[1,2,3,4,5,6,7]

s = append(s[2:5],a...)  //得出s 等於[3,4,5,6,7]

當追加後的元素個數大於本切片的容量時，函數append會為

原來的切片s 重新分配空間,所以s 不會引用原來的數組或被追加的數組

若沒有...就會報錯誤而無法工作；這是追加值與追加切片的不同

package main

import "fmt"

func main() {

         s:= []int{1, 2, 3} //建切片s

         s= append(s, 4, 5) //當追加的是值時(可以是1個或多個)

         fmt.Println(s)

         a:= []int{6, 7}    //建切片a

         s= append(s, a...) //當追加的是切片時後面要有三個點

         fmt.Println(s)

         s= append(s[2:5], a...) //得出s 等於[3,4,5,6,7]

         fmt.Println(s)

 

}

//output

//[1 2 3 4 5]

//[1 2 3 4 5 6 7]

//[3 4 5 6 7]

還有函數copy

copy函數用於從一個數組或切片中複製 資料到另一個切片中

n1 := copy(s, a[x:y])

把數組或切片a 複製到s 中,並反回被複製的元素個數給n1

a 可以是數組或切片，但s 只能是切片

被複製的是數組元素的值而不是引用

被複製的元素個數為len(a[x:y]) 和len(s)中較少的一個

例：

var a = [...]int{0, 1, 2, 3, 4, 5, 6, 7}

var s = make([]int, 6)

n1 := copy(s, a[:])        //說明：把a 全部的值 複製到s 中

n2 := copy(s, s[2:])       //說明：把指定範圍的值複製到s 的開始位置

n3 := copy(s[4:6], a[6:8])  //說明：把指定範圍的值複製到s的指定位置

package main

 

import "fmt"

 

func main() {

         vara = [...]int{0, 1, 2, 3, 4, 5, 6, 7}

         vars = make([]int, 6)

         n1:= copy(s, a[:])  //說明：把a 全部的值 複製到s 中

         fmt.Println(n1)      //賦值個數

         fmt.Println(s)       //賦值後的結果

         n2:= copy(s, s[2:]) //說明：把指定範圍的值複製到s 的開始位置

         fmt.Println(n2)

         fmt.Println(s)

         n3:= copy(s[4:6], a[6:8]) //說明：把指定範圍的值複製到s 的指定位置

         fmt.Println(n3)

         fmt.Println(s)

}

 

//output:

//6

//[0 1 2 3 4 5]

//4

//[2 3 4 5 4 5]

//2

//[2 3 4 5 6 7]

三、注意：

slice是一個指標而不是值。

指標比值可就小多了，因此，我們將slice作為函數參數傳遞比將

array作為函數參數傳遞會更有效能。

slice是一個指標，它指向的是一個array機構，它有兩個基本函數

len和cap。 

看下面的圖示：

slice是一個帶有point（指向數組的指標），Len（數組中實際有值的個數），Cap（數組的容量）

比如上面的這個slice，它指向的數組是[3]int,其中的前兩個有值，第三個為空白

那麼

len(slic) = 2

cap(slic) = 3

append函數就理解為往slice中加入一個值，如果未達到容量（len<cap）那麼就直接往數組中加值，如果達到容量（len = cap）那麼就增加一個新的元素空間，將值放在裡面