【Go學習】slice切片的本質及操作——切片的追加、刪除、插入等

【Go學習】slice切片的本質及操作——切片的追加、刪除、插入等

切片的本質

一個切片是一個數組切割區間的描述。它包含了指向數組的指針，切割區間的長度，和容量（切割區間的最大長度），如下圖所示：

假如使用 make([]byte, 5) 創建的切片變量s的結構如下圖所示：

長度是切片引用的元素數目。容量是底層數組的元素數目（從切片指針開始）。關於長度和容量和區域將在下一個例子說明。

下面這個例子，我們繼續對 s 進行切分，觀察切片的數據結構和它引用的底層數組：

s = s[2:4]

注意上圖中，這個時候切片的長度是2，但是切片的容量是3，容量是底層數組的元素數目（從切片指針開始），從上圖指針出開始向右數，確實是3，注意長度和容量的區別。

切片並不複製整個切片元素。它創建一個新的切片執行同樣的底層數組。這使得切片操作和數組索引一樣高效。因此，通過一個新切片修改元素同樣會影響到原始的切片。

d := []byte{'r', 'o', 'a', 'd'}
e := d[2:] 
// e == []byte{'a', 'd'}
e[1] = 'm'
// e == []byte{'a', 'm'}
// d == []byte{'r', 'o', 'a', 'm'}

前面創建的切片 s 長度小於它的容量。我們可以增長切片的長度爲它的容量：

s = s[:cap(s)]

上圖中，切片長度和切片容量是一樣的，都是3。

切片增長不能超出其容量。增長超出切片容量將會導致運行時異常，就像切片或數組的索引超出範圍引起異常一樣。同樣，不能使用小於零的索引去訪問切片之前的元素。

對切片有了一個整體的認識之後，下來我們結合一些實例來進行操作。

一、一般操作

1,聲明變量，go自動初始化爲nil，長度：0，地址：0，nil

package main

import (
    "fmt"
)

func main(){
    var ss []string;
    fmt.Printf("length:%v \taddr:%p \tisnil:%v",len(ss),ss, ss==nil)    
}

2,切片的追加，刪除，插入操作

package main

import (
    "fmt"
)

func main(){
    var ss []string;
    fmt.Printf("[ local print ]\t:\t length:%v\taddr:%p\tisnil:%v\n",len(ss),ss, ss==nil)    
    print("func print",ss)
    //切片尾部追加元素append elemnt
    for i:=0;i<10;i++{
        ss=append(ss,fmt.Sprintf("s%d",i));
    }
    fmt.Printf("[ local print ]\t:\tlength:%v\taddr:%p\tisnil:%v\n",len(ss),ss, ss==nil)    
    print("after append",ss)
    //刪除切片元素remove element at index
    index:=5;
    ss=append(ss[:index],ss[index+1:]...)
    print("after delete",ss)
    //在切片中間插入元素insert element at index;
    //注意：保存後部剩餘元素，必須新建一個臨時切片
    rear:=append([]string{},ss[index:]...) 
    ss=append(ss[0:index],"inserted")
    ss=append(ss,rear...)
    print("after insert",ss)
}
func print(msg string,ss []string){
    fmt.Printf("[ %20s ]\t:\tlength:%v\taddr:%p\tisnil:%v\tcontent:%v\n",msg,len(ss),ss, ss==nil,ss)    
    fmt.Println()
}

3，copy的使用。

在使用copy複製切片之前，要保證目標切片有足夠的大小，注意是大小，而不是容量，還是看例子：

package main

import (
    "fmt"
)

func main() {

    var sa = make ([]string,0);
    for i:=0;i<10;i++{
        sa=append(sa,fmt.Sprintf("%v",i))

    }
    var da =make([]string,0,10);
    var cc=0;
    cc= copy(da,sa);
    fmt.Printf("copy to da(len=%d)\t%v\n",len(da),da)
    da = make([]string,5,10)
    cc= copy(da,sa);
    fmt.Printf("copy to da(len=%d)\tcopied=%d\t%v\n",len(da),cc,da)
    da = make([]string,10)
    cc = copy(da,sa);
    fmt.Printf("copy to da(len=%d)\tcopied=%d\t%v\n",len(da),cc,da)

}

從上面運行結果，明顯看出，目標切片大小0，容量10，copy不能複製。目標切片大小小於源切片大小，copy就按照目標切片大小複製，不會報錯。

二、初始大小和容量

　當我們使用make初始化切片的時候，必須給出size。go語言的書上一般都會告訴我們，當切片有足夠大小的時候，append操作是非常快的。但是當給出初始大小後，我們得到的實際上是一個含有這個size數量切片類型的空元素，看例子：

package main

import (
    "fmt"
)

func main(){

    var ss=make([]string,10,10);
    print("befor append",ss)
    ss=append(ss,"last");
    print("after append",ss)

}


func print(msg string,ss []string){
    fmt.Printf("[ %20s ]\t:\tlength:%v\tcap:%v\taddr:%p\tisnil:%v\tcontent:%v",msg,len(ss),cap(ss),ss, ss==nil,ss)    
    fmt.Println()
}

上圖運行結果可以看出，切片的地址已經改變了。所以用append函數追加元素到切片時，如果容量不夠，go就會創建一個新的切片變量。

實際上，此時我們應該先用下標爲切片元素負值。但是如果我們既想有好的效率，有想繼續使用append函數而不想區分是否有空的元素，此時就要請出make的第三個參數，容量，也就是我們通過傳遞給make，0的大小和足夠大的容量數值就行了。

package main

import (
    "fmt"
)

func main(){

    var ss=make([]string,0,10);
    print("befor append",ss)
    ss=append(ss,"last");
    print("after append",ss)

}


func print(msg string,ss []string){
    fmt.Printf("[ %20s ]\t:\tlength:%v\tcap:%v\taddr:%p\tisnil:%v\tcontent:%v",msg,len(ss),cap(ss),ss, ss==nil,ss)    
    fmt.Println()
}

三、切片的指針。

1，當我們用append追加元素到切片時，如果容量不夠，go就會創建一個新的切片變量，看下面程序的執行結果：

package main

import (
    "fmt"
)

func main() {
    var sa []string
fmt.Printf("addr:%p \t\tlen:%v content:%v\n",sa,len(sa),sa);
    for i:=0;i<10;i++{
        sa=append(sa,fmt.Sprintf("%v",i))
        fmt.Printf("addr:%p \t\tlen:%v cap:%v content:%v\n",sa,len(sa),cap(sa),sa);
    }
    fmt.Printf("addr:%p \t\tlen:%v cap:%v content:%v\n",sa,len(sa),cap(sa),sa);

}

由上面的運行結果可以看出，切片的地址經過了數次改變，而且切片的容量每次改變都是成倍增加，1–>2–>4–>8–>16。

　2,如果，在make初始化切片的時候給出了足夠的容量，append操作不會創建新的切片：

package main

import (
    "fmt"
)

func main() {
    var sa = make ([]string,0,10);
fmt.Printf("addr:%p \t\tlen:%v cap:%v content:%v\n",sa,len(sa),cap(sa),sa);
    for i:=0;i<10;i++{
        sa=append(sa,fmt.Sprintf("%v",i))
        fmt.Printf("addr:%p \t\tlen:%v cap:%v content:%v\n",sa,len(sa),cap(sa),sa);
    }
    fmt.Printf("addr:%p \t\tlen:%v cap:%v content:%v\n",sa,len(sa),cap(sa),sa);

}

由上圖運行結果可以看出，切片的地址一直保持不變，切片容量一直沒變。

3, 如果不能準確預估切片的大小，又不想改變變量（如：爲了共享數據的改變），這時候就要請出指針來幫忙了，下面程序中，sa就是osa這個切片的指針，我們共享切片數據和操作切片的時候都使用這個切片地址就ok了，其本質上是：append操作亦然會在需要的時候構造新的切片，不過是將地址都保存到了sa中，因此我們通過該指針始終可以訪問到真正的數據。

package main

import (
    "fmt"
)

func main() {
    var osa = make ([]string,0);
    sa:=&osa;
    fmt.Printf("addr of osa:%p,\tsa addr:%p \t sa point to:%p \t cap:%v content:%v\n",osa,sa,*sa,cap(*sa),sa);
    for i:=0;i<10;i++{
        *sa=append(*sa,fmt.Sprintf("%v",i))
        fmt.Printf("addr of osa:%p,\tsa addr:%p \t sa point to:%p \t cap:%v content:%v\n",osa,sa,*sa,cap(*sa),sa);
    }
    fmt.Printf("addr of osa:%p,\tsa addr:%p \t sa point to:%p \t cap:%v content:%v\n",osa,sa,*sa,cap(*sa),sa);
}