切片 slice
切片可以算是数组的一部分。 像数组一样，切片亦是可索引的并且有长度。 与数组不同，切片这个长度是可以改变的。
切片是灵活且可扩展的数据结构，可以根据需要增长和缩小。 像数组一样，切片可以索引并且有长度。 在 Go 中，数组允许您定义可以保存相同类型数据项的变量，但它不提供任何内置方法来动态增加其大小或获取子数组，但切片克服了数组的这种限制。
切片的定义
Slice 是可以调整大小的数组段，因此与数组相比，它更灵活。 像数组一样，切片是可索引的并且有长度。 切片是一种轻量级结构，它包装并表示数组的一部分。
var x []float64
切片的声明就像数组一样，但它不包含切片的大小。。 在这种情况下，x 的创建长度为 0，因此，它变得灵活且具有动态大小以适应需求。
如果你想要创建一个切片 slice ，应该使用内置的 make 函数，切片是使用 make 函数创建的。：
x := make([]float64, 3)
这将创建一个长度为 3 的类型为 float64 数组关联的切片，切片始终与某个数组关联，尽管它们永远不能长于数组，但它们可以更小。
make 函数还允许使用第三个参数：
x := make([]float64, 3, 10)
10 表示切片指向的底层数组的容量：
package mainimport "fmt"func main() { X := make([]float64, 3, 10) fmt.Printf("Slice = %v", X) fmt.Printf("\nLength = %d", len(X)) fmt.Printf("\nCapacity = %d", cap(X))}
运行代码，得到：
Slice = [0 0 0]Length = 3Capacity = 10
切片的声明
切片是一个可变长度的序列，它存储相似类型的元素，并且不允许在同一个切片中存储不同类型的元素。 切片中的第一个索引位置始终为 0，最后一个为(切片长度 - 1)。
另一种创建切片的方法是使用 [low : high] 表达式：
array := []float64{1, 2, 3, 4, 5}x := array[0:5]
low 是切片的起始索引， high 是终止索引，但不包括该索引本身。
例如： array[0:5] 返回 [1,2,3,4,5] 。 array[1:4] 得到 [2,3,4] .
为了方便，Go 语言允许省略 low , high ，甚至两个一起省略。
-
array[0:] 等同于 array[0:len(array)] . array[:5] 等同于 array[0:5] .-
array[:] 等同于 array[0:len(array)]
package mainimport "fmt"func main() { // Create a slice using a slice literal var my_slices = []int{1, 2, 3, 4, 5} fmt.Println("my_slices = ", my_slices) // Create a slice using a slice literal using short hand declaration my_slices2 := []int{6, 7, 8, 9, 10} fmt.Println("my_slices2 = ", my_slices2)}
切片的修改
切片是引用类型，它们引用底层数组。 因此，修改切片的一个元素将修改引用数组中的相应元素，引用同一数组的其他切片也将看到这些修改。
package mainimport "fmt"func main() { number_English := [7]string{"One", "Two", "Three", "Four", "Five", "Six", "Seven"} slice1 := number_English[1:] slice2 := number_English[3:] fmt.Println("--- 修改前 ---") fmt.Println("Array =", number_English) fmt.Println("slice1 = ", slice1) fmt.Println("slice2 = ", slice2) // 修改切片 slice1[0] = "TWO" slice1[2] = "FOUR" slice2[1] = "FIVE" fmt.Println("--- 修改后 ---") fmt.Println("Array =", number_English) fmt.Println("slice1 = ", slice1) fmt.Println("slice2 = ", slice2)}
运行后，结果为：
--- 修改前 ---Array = [One Two Three Four Five Six Seven]slice1 = [Two Three Four Five Six Seven]slice2 = [Four Five Six Seven]--- 修改后 ---Array = [One TWO Three FOUR FIVE Six Seven]slice1 = [TWO Three FOUR FIVE Six Seven]slice2 = [FOUR FIVE Six Seven]
空值切片
Nil slice 中不包含任何元素。 所以，这个切片的容量和长度都是 0。Nil 切片不包含数组引用。 让我们看看下面的例子：
package mainimport "fmt"func main() { var nil_slices []string fmt.Printf("Length of slice: %d\n", len(nil_slices)) fmt.Printf("Capacity: %d\n", cap(nil_slices))}
运行结果为：
Length of slice: 0Capacity: 0
切片是否为空
使用 == 来检查切片是否为空，如：
package mainimport "fmt"func main() { x1 := []int{1, 2, 3, 4, 5, 6} var x2 []int fmt.Println(x1 == nil) fmt.Println(x2 == nil)}
将会得到：
falsetrue
多维切片
多维切片就像多维数组一样，只是切片不包含大小。 让我们看看下面的例子：
package mainimport "fmt"func main() { x1 := [][]int{ {10, 20}, {20, 30}, {30, 40}, {40, 100}, } x2 := [][]string{ {"1", "小王"}, {"2", "小李"}, {"3", "小张"}, } fmt.Println("Slice 1: ", x1) fmt.Println("Slice 2: ", x2) fmt.Println("Length of slice 1: ", len(x1)) fmt.Println("Length of slice 2: ", len(x2))}
结果：
Slice 1: [[10 20] [20 30] [30 40] [40 100]]Slice 2: [[1 小王] [2 小李] [3 小张]]Length of slice 1: 4Length of slice 2: 3
切片操作
排序
在 Go 语言中，您可以对切片中存在的元素进行排序。 Go 标准库提供了 sort 包，其中包含不同类型的排序方法。
package mainimport ( "fmt" "sort")func main() { slice1 := []string{"India", "Japan", "China", "Ecuador", "New Zealand", "USA", "UK"} slice2 := []int{6, 7, 1, 9, 40, 1100, 122, 33, 414} fmt.Println("Slice 1: ", slice1) fmt.Println("Slice 2: ", slice2) sort.Strings(slice1) sort.Ints(slice2) fmt.Println("--- After sort ---") fmt.Println("Slice 1: ", slice1) fmt.Println("Slice 2: ", slice2)}
结果为：
Slice 1: [India Japan China Ecuador New Zealand USA UK]Slice 2: [6 7 1 9 40 1100 122 33 414]--- After sort ---Slice 1: [China Ecuador India Japan New Zealand UK USA]Slice 2: [1 6 7 9 33 40 122 414 1100]
遍历
您可以通过使用 for 循环或 for range 循环来遍历切片。
package mainimport ( "fmt")func main() { slice1 := []string{"India", "Japan", "China", "Ecuador", "New Zealand", "USA", "UK"} for i := 0; i < len(slice1); i++ { fmt.Println(slice1[i]) } for index, element := range slice1 { fmt.Printf("Index = %d, Element = %s\n", index, element) }}
结果为：
IndiaJapanChinaEcuadorNew ZealandUSAUKIndex = 0, Element = IndiaIndex = 1, Element = JapanIndex = 2, Element = ChinaIndex = 3, Element = EcuadorIndex = 4, Element = New ZealandIndex = 5, Element = USAIndex = 6, Element = UK
添加
使用 append 方法可以往切片里添加另一个 切片，append 通过获取现有切片(第一个参数)并将以下所有参数附加到它来创建一个新切片：
package mainimport ( "fmt")func main() { slice1 := []string{"India", "Japan", "China", "Ecuador", "New Zealand", "USA", "UK"} slice2 := append(slice1, "Russia", "France", "Germany", "Belgium") fmt.Println(slice1) fmt.Println(slice2)}
结果为：
[India Japan China Ecuador New Zealand USA UK][India Japan China Ecuador New Zealand USA UK Russia France Germany Belgium]
复制
copy 可以将一个切片的元素复制到另一个元素中：
package mainimport ( "fmt")func main() { slice1 := []string{"India", "Japan", "China", "Ecuador", "New Zealand", "USA", "UK"} slice2 := append(slice1, "Russia", "France", "Germany", "Belgium") fmt.Println(slice1) fmt.Println(slice2) slice3 := make([]string, 12) copy(slice3, slice2) fmt.Println(slice3)}
结果为：
[India Japan China Ecuador New Zealand USA UK][India Japan China Ecuador New Zealand USA UK Russia France Germany Belgium][India Japan China Ecuador New Zealand USA UK Russia France Germany Belgium ]
总结
在 Go 中，切片是数组的一部分，可以调整大小，比数组更灵活。 像数组一样，切片是可索引的并且有长度。
切片是一种轻量级结构，它包装并表示数组的一部分。 切片由三部分组成——指针、长度和容量。
在 Go 语言中，切片就像数组一样声明，但它不包含切片的大小。 因此，它在尺寸上变得灵活和动态以适应要求。
为了从数组创建切片，我们指定了两个索引，用冒号分隔的下限和上限。 low 的默认值为 0，high 是切片的长度。 切片表达式中的低和高索引是可选的。
在 Go 中，您可以使用 Go 库提供的 make() 函数创建切片。 这个函数需要三个参数——类型、长度和容量。 这里，容量值是可选的。 它分配一个大小等于给定容量的底层数组，并返回一个引用底层数组的切片。
切片是 Go 语言中的引用类型，它们引用底层数组。 因此，修改切片的元素将修改引用数组中的相应元素，引用同一数组的其他切片也将看到这些修改。
在 Go 中，一个 nil 切片中不包含任何元素。 因此，该切片的容量和长度均为 0，并且 nil 切片不包含数组引用。 此外，您可以在 slice 中使用 == 运算符来检查给定的 slice 是否为零。
在 Go 中，多维切片就像多维数组一样，只是切片不包含大小。
您可以使用 for 循环或 for 循环中的 range 遍历切片。 通过在 for 循环中使用范围，您还可以获得索引和元素值。
在 Go 中，您可以对切片中的元素进行排序。 Go 标准库提供了 sort 包，其中包含不同类型的排序方法，用于对切片进行排序。还可以通过 append 和 copy 往一个切片中添加元素。
评论（0）