Go 语言入门很简单 -- 7. Go Slices #私藏项目实操分享#-CSDN博客

本文链接：https://blog.csdn.net/yuzhou_1shu/article/details/122476796

切片 slice

切片可以算是数组的一部分。像数组一样，切片亦是可索引的并且有长度。与数组不同，切片这个长度是可以改变的。

切片是灵活且可扩展的数据结构，可以根据需要增长和缩小。像数组一样，切片可以索引并且有长度。在 Go 中，数组允许您定义可以保存相同类型数据项的变量，但它不提供任何内置方法来动态增加其大小或获取子数组，但切片克服了数组的这种限制。

切片的定义

Slice 是可以调整大小的数组段，因此与数组相比，它更灵活。像数组一样，切片是可索引的并且有长度。切片是一种轻量级结构，它包装并表示数组的一部分。

var x []float64

切片的声明就像数组一样，但它不包含切片的大小。。在这种情况下，x 的创建长度为 0，因此，它变得灵活且具有动态大小以适应需求。

如果你想要创建一个切片 slice ，应该使用内置的 make 函数，切片是使用 make 函数创建的。：

x := make([]float64, 3)

这将创建一个长度为 3 的类型为 float64 数组关联的切片，切片始终与某个数组关联，尽管它们永远不能长于数组，但它们可以更小。

make 函数还允许使用第三个参数：

x := make([]float64, 3, 10)

10 表示切片指向的底层数组的容量：

Go 语言入门很简单 -- 7. Go Slices #私藏项目实操分享#_引用类型

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 = 3
Capacity = 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: 0
Capacity: 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)
}

将会得到：

false
true

多维切片

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

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:  4
Length 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)
    }
}

结果为：

India
Japan
China
Ecuador
New Zealand
USA
UK
Index = 0, Element = India
Index = 1, Element = Japan
Index = 2, Element = China
Index = 3, Element = Ecuador
Index = 4, Element = New Zealand
Index = 5, Element = USA
Index = 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 ]