Golang入門學習 Slice的初步使用

2021-10-08 20:19:04 字數 4220 閱讀 2891

go 語言切片是對陣列的抽象。 go 陣列的長度不可改變，在特定場景中這樣的集合就不太適用，go中提供了一種靈活，功能強悍的內建型別切片("動態陣列"),與陣列相比切片的長度是不固定的，可以追加元素，在追加時可能使切片的容量增大

切片是一種方便、靈活且強大的包裝器。切片本身沒有任何資料。它們只是對現有陣列的引用。

切片與陣列相比，不需要設定長度，在中不用設定值，相對來說比較自由

從概念上面來說slice像乙個結構體，這個結構體包含了三個元素：

指標，指向陣列中slice指定的開始位置

長度，即slice的長度

最大長度，也就是slice開始位置到陣列的最後位置的長度

定義切片

var identifier type
切片不需要說明長度。 或使用make()函式來建立切片:

var slice1 type = make(type, len)


也可以簡寫為


slice1 := make(type, len)


make(t, length, capacity)
初始化

s[0] = 1


s[1] = 2


s[2] = 3


s := int  


s := arr[startindex:endindex]
將arr中從下標startindex到endindex-1 下的元素建立為乙個新的切片（前閉後開），長度為endindex-startindex

s := arr[startindex:]
預設endindex時將表示一直到arr的最後乙個元素

s := arr[:endindex]
預設startindex時將表示從arr的第乙個元素開始

package main


​import (  


"fmt")​


func main() 


var b int = a[1:4] //creates a slice from a[1] to a[3]


fmt.println(b)


}
slice沒有自己的任何資料。它只是底層陣列的乙個表示。對slice所做的任何修改都將反映在底層陣列中。

示例**：

package main


​import (  


"fmt")​


func main() 


dslice := darr[2:5]


fmt.println("array before",darr)


for i := range dslice 


fmt.println("array after",darr) 


}
執行結果：

array before [57 89 90 82 100 78 67 69 59]  


array after [57 89 91 83 101 78 67 69 59]
當多個片共享相同的底層陣列時，每個元素所做的更改將在陣列中反映出來。

示例**：

package main


​import (  


"fmt")​


func main() 


nums1 := numa[:] //creates a slice which contains all elements of the array


nums2 := numa[:]


fmt.println("array before change 1",numa)


nums1[0] = 100


fmt.println("array after modification to slice nums1", numa)


nums2[1] = 101


fmt.println("array after modification to slice nums2", numa)


}
執行結果：

array before change 1 [78 79 80]  


array after modification to slice nums1 [100 79 80]  


array after modification to slice nums2 [100 101 80]
切片的長度是切片中元素的數量。切片的容量是從建立切片的索引開始的底層陣列中元素的數量。

切片是可索引的，並且可以由 len() 方法獲取長度 切片提供了計算容量的方法 cap() 可以測量切片最長可以達到多少

package main


​import "fmt"


​func main() 


​func printslice(x int)
執行結果

len=3 cap=5 slice=[0 0 0]
空切片

乙個切片在未初始化之前預設為 nil，長度為 0

package main


​import "fmt"


​func main() }​


func printslice(x int)
執行結果

len=0 cap=0 slice=


切片是空的


package main


​import "fmt"


​func main()    


printslice(numbers)


​   /* 列印原始切片 */


fmt.println("numbers ==", numbers)


​   /* 列印子切片從索引1(包含) 到索引4(不包含)*/


fmt.println("numbers[1:4] ==", numbers[1:4])


​   /* 預設下限為 0*/


fmt.println("numbers[:3] ==", numbers[:3])


​   /* 預設上限為 len(s)*/


fmt.println("numbers[4:] ==", numbers[4:])


​   numbers1 := make(int,0,5)


printslice(numbers1)


​   /* 列印子切片從索引  0(包含) 到索引 2(不包含) */


number2 := numbers[:2]


printslice(number2)


​   /* 列印子切片從索引 2(包含) 到索引 5(不包含) */


number3 := numbers[2:5]


printslice(number3)​}


​func printslice(x int)
執行結果

len=9 cap=9 slice=[0 1 2 3 4 5 6 7 8]


numbers == [0 1 2 3 4 5 6 7 8]


numbers[1:4] == [1 2 3]


numbers[:3] == [0 1 2]


numbers[4:] == [4 5 6 7 8]


len=0 cap=5 slice=


len=2 cap=9 slice=[0 1]


len=3 cap=7 slice=[2 3 4]
package main


​import "fmt"


​func main() 


​func printslice(x int)
執行結果

len=0 cap=0 slice=


len=1 cap=2 slice=[0]


len=2 cap=2 slice=[0 1]


len=5 cap=8 slice=[0 1 2 3 4]


len=5 cap=12 slice=[0 1 2 3 4]
numbers1與numbers兩者不存在聯絡，numbers發生變化時，numbers1是不會隨著變化的。也就是說copy方法是不會建立兩個切片的聯絡的

golang學習筆記 slice

go 語言中的slice型別可以理解為是陣列array型別的描述符，包含了三個因素 指向底層陣列的指標 slice目前使用到的底層陣列的元素個數，即長度 底層陣列的最大長度，即容量 因此當我們定義乙個切片變數，s make int,5,10 即為指向了乙個最大長度為10的底層陣列，目前切片s使用到的...

golang學習（九） 切片（slice）

在go 語言中，陣列是值型別，長度是固定的 而切片是引用型別，長度可動態增長。切片的內部結構包括位址 大小和容量。特性 1.當省略開始位置時，表示從連續區域開頭到結束位置。2.當省略結束位置時，表示從開始位置到整個連續區域結束位置。3.兩者都省略時，與切片本身等效。基本格式如下 slice 開始位置...

golang學習筆記 slice 2

array是固定長度的陣列,slice是對array的擴充套件,本質上是基於陣列實現的,主要特點是定義完乙個slice變數之後，不需要為它的容量而擔心。array與slice的差別 1 array是固定長度，slice是可變長度 2 array是值型別,slice是引用型別 slice 結構 typ...