写点什么

Go 语言快速入门指南:第五篇 与数据为舞之切片

作者:宇宙之一粟
  • 2021 年 12 月 15 日
  • 本文字数:4179 字

    阅读完需:约 14 分钟

Go 语言快速入门指南:第五篇 与数据为舞之切片

切片 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 main
import "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 main
import "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 main
import "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 main
import "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 main
import "fmt"
func main() {
x1 := []int{1, 2, 3, 4, 5, 6} var x2 []int
fmt.Println(x1 == nil) fmt.Println(x2 == nil)}
复制代码

运行后,得到

falsetrue
复制代码

多维切片

多维切片就像多维数组一样,只是切片不包含大小。 让我们看看下面的例子:

package main
import "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 main
import ( "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 main
import ( "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 main
import ( "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 main
import ( "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 往一个切片中添加元素。


下一篇中,我们将学习与数据共舞之映射篇,敬请期待。

发布于: 3 小时前阅读数: 12
用户头像

宇宙古今无有穷期,一生不过须臾,当思奋争 2020.05.07 加入

混迹于江湖,江湖却没有我的影子 热爱技术,专注于后端全栈,轻易不换岗 拒绝内卷,工作于软件工程师,弹性不加班 热衷分享,执着于阅读写作,佛系不水文 各大平台同名 CSDN、51CTO、掘金、知乎、公众号、简书。。。

评论

发布
暂无评论
Go 语言快速入门指南:第四篇 与数据为舞之切片