Golang復合型別 切片

2022-06-13 12:12:07 字數 4264 閱讀 3244

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 復合型別

目錄指標的使用 package 宣告開頭表示 所屬包 package main import fmt func main a變數的位址是 c042052080 p變數的值 20通過指標修改變數 package 宣告開頭表示 所屬包 package main import fmt func main ...

GO 復合型別 切片

相當於長度可以擴張的陣列 經過陣列擷取的片段就是切片 func main01 擷取陣列的前9位 slice array 0 9 fmt.printf array的資料型別是 t n array fmt.printf slice的資料型別是 t,值是 v n slice,slice 下標為0開始擷取5...

golang復合資料型別 陣列

顧名思義，復合資料型別就是由其他型別組合而成的型別。go語言基本的復合資料型別有 指標 陣列 切片 字典 map 通道 結構和介面 go語言提供了陣列型別的資料結構。陣列是具有相同唯一型別的一組編號且長度固定的資料項序列，這種型別可以是任意的原始型別，例如 整形 字串或者自定義型別。陣列元素可以通過...