6 Go的切片

概述

    在上一节的内容中，我们介绍了Go的数组，包括：声明数组、初始化数组、访问数组元素等。在本节中，我们将介绍Go的切片。在Go语言中，数组的长度是固定的，不能改变，这在某些场景下使用不太方便。切片（slice）是一种动态数组，它提供了更为灵活和便捷的方式来操作数组。切片是对数组的抽象，它包含了指向数组元素的指针、切片的长度和容量。

声明切片

    切片的声明使用[]操作符，语法如下：

      var sliceName []Type

    其中，sliceName表示切片的名称，Type表示切片中元素的类型。与数组不同，声明切片时，不需要指定长度。

    在下面的示例代码中，我们声明了一个名为numbers的整数类型切片，并初始为空切片。

var numbers []int

初始化切片

    可以使用数组来初始化切片，语法如下：

      var sliceName []Type = []Type{value1, value2, ..., valueN}

    其中，Type表示切片中元素的类型，value1、value2、...、valueN是切片中元素的初始值。

    在下面的示例代码中，我们创建了一个包含3个整数的切片，其初始值为1、2、3。还创建了一个包含2个字符串的切片，其初始值为“Hello”、“CSDN”。

package main

import "fmt"

func main() {
    var numbers []int = []int{1, 2, 3}
    text := []string{"Hello", "CSDN"}

    // 输出：[1 2 3]
    fmt.Println(numbers)
    // 输出：[Hello CSDN]
    fmt.Println(text)
}

    我们还可以使用内置函数make()来初始化切片，传入类型、数量、容量（可忽略）即可，元素的初始值为类型的默认值。

package main

import "fmt"

func main() {
    var numbers []int = make([]int, 3)
    text := make([]string, 2)

    // 输出：[0 0 0]
    fmt.Println(numbers)
    // 输出：[ ]
    fmt.Println(text)
}

    与数组相比，切片的长度是不固定的，可以追加元素。在追加时，可能使切片的容量增大。切片的长度可以由 len()函数获取，容量可以由cap()函数获取。

package main

import "fmt"

func main() {
    var numbers []int = make([]int, 3, 10)
    
    // 输出：3 10
    fmt.Println(len(numbers), cap(numbers))
}

    如果切片声明后，没有初始化，则为空切片。空切片默认为nil，其长度和容量均为0。

package main

import "fmt"

func main() {
    var numbers []int
    
    // 输出：0 0
    fmt.Println(len(numbers), cap(numbers))
    if numbers == nil {
        // 输出：[]
        fmt.Println(numbers)
    }
}

切片的切割

    在Go语言中，可以使用切片的切片操作来切割切片。切片的切片操作可以用来获取切片的一部分，或者将一个切片分割成多个子切片。切片的切片操作使用两个索引来指定切割的位置：第一个索引指定切割的起始位置，第二个索引指定切割的结束位置，但不包括该位置的元素。第一个索引不指定时，默认为0。第二个索引不指定时，默认为切片的长度。

package main

import "fmt"

func main() {
    numbers := []int{1, 2, 3, 4, 5, 6}
    // 输出：[3 4 5 6]
    fmt.Println(numbers[2:])
    // 输出：[1 2 3 4]
    fmt.Println(numbers[:4])
    // 输出：[3 4]
    fmt.Println(numbers[2:4])
    // 输出：[1 2 3 4 5 6]
    fmt.Println(numbers[:])
}

切片的添加

    可以使用append()函数向切片添加一个或多个元素。append()函数会根据切片的容量和长度，自动调整底层数组的大小，并将新元素添加到切片的末尾。注意：append()函数会返回一个新的切片，包含添加元素后的结果；因此，需要将返回的结果重新赋值给原切片，以更新切片的内容。

package main

import "fmt"

func main() {
    numbers := []int{1, 2, 3}
    // 添加元素99和100到切片的末尾
    numbers = append(numbers, 99, 100)
    // 输出：[1 2 3 99 100]
    fmt.Println(numbers)
}

    当向一个切片添加另一个切片的所有元素时，使用append()函数需要对第二个切片进行解包（切片后面添加符号...，用于展开切片中的元素），可参考下面的示例代码。

package main

import "fmt"

func main() {
    numbers := []int{1, 2, 3}
    numbers2 := []int{99, 100}
    // 添加另一个切片，需要解包
    numbers = append(numbers, numbers2...)
    // 输出：[1 2 3 99 100]
    fmt.Println(numbers)
}

切片的删除

    切片的删除分为几种情况：从头部删除、从中间删除、从尾部删除。

    删除开头的元素时，可以直接移动数据指针。假如有一个切片slice，则slice[1:]会删除开头1个元素，slice[N:]会删除开头N个元素。

package main

import "fmt"

func main() {
    numbers := []int{1, 2, 3, 4, 5}
    // 删除开头2个元素
    numbers = numbers[2:]
    // 输出：[3 4 5]
    fmt.Println(numbers)
}

    也可以不移动数据指针，但将后面的数据向开头移动，此时可用append()函数原地完成。

package main

import "fmt"

func main() {
    numbers := []int{1, 2, 3, 4, 5}
    // 删除开头2个元素
    numbers = append(numbers[:0], numbers[2:]...)
    // 输出：[3 4 5]
    fmt.Println(numbers)
}

    删除中间的元素时，需要对剩余元素进行一次整体移动，此时仍可用append()函数原地完成。

package main

import "fmt"

func main() {
    numbers := []int{1, 2, 3, 4, 5, 6}
    // 删除中间的3、4两个元素
    numbers = append(numbers[:2], numbers[4:]...)
    // 输出：[1 2 5 6]
    fmt.Println(numbers)
}

    删除尾部的元素时，直接切割即可。

package main

import "fmt"

func main() {
    numbers := []int{1, 2, 3, 4, 5, 6}
    // 删除尾部的两个元素
    numbers = numbers[:len(numbers) - 2]
    // 输出：[1 2 3 4]
    fmt.Println(numbers)
}

切片的复制

    可以使用copy()函数来复制切片，它接受两个参数：第一个参数是目标切片，第二个参数是源切片。copy()函数会将源切片中的元素复制到目标切片中，并返回实际复制的元素个数。注意：如果源切片和目标切片不一样大，则会按照其中较小的那个切片的元素个数进行复制。另外，切片的复制不是在末尾添加元素，而是从开头位置覆盖之前已经存在的元素。

package main

import "fmt"

func main() {
    slice1 := []int{1, 2, 3, 4, 5}
    slice2 := []int{66, 88, 99}

    // slice2的容量小，故只会复制slice1的前3个元素到slice2中
    copy(slice2, slice1)
    // 输出：[1 2 3]
    fmt.Println(slice2)

    slice2 = []int{66, 88, 99}
    copy(slice1, slice2)
    // 输出：[66 88 99 4 5]
    fmt.Println(slice1)
}

切片的遍历

    有两种方法来实现切片的遍历：一是使用for循环，二是使用range关键字。

    在下面的示例代码中，我们使用了一个for循环，从切片的索引0开始遍历到切片的长度减1。通过索引，我们可以访问切片中的每个元素，并打印出来。

package main

import "fmt"

func main() {
    numbers := []int{1, 2, 3, 4, 5}
    for i := 0; i < len(numbers); i++ {
        fmt.Println(numbers[i])
    }
}

    在下面的示例代码中，我们使用了range关键字来遍历切片。每次迭代时，range会返回当前元素的索引和值。我们可以使用它们来访问切片中的元素，这种方法更加简洁和易读。

package main

import "fmt"

func main() {
    numbers := []int{1, 2, 3, 4, 5}
    for index, value := range numbers {
        fmt.Println(index, value)
    }
}

多维切片

    多维切片是由一系列切片组成的，每个切片可以具有不同的长度和容量。要创建一个多维切片，首先需要创建一个初始切片。然后使用该切片来创建额外的切片，每个新切片都会将原始切片的元素拆分为更小的切片。

    声明一个多维切片的语法格式如下：

      var sliceName [][]...[]Type

    其中，sliceName表示切片的名称，Type表示切片的类型，每个[]代表着一个维度，切片有几个维度就需要几个[]。

    在下面的示例代码中，我们首先创建了一个初始切片slice，长度为3。然后，我们使用range循环为每个内部切片创建了长度为2的子切片。接下来，我们给多维切片中的元素进行了赋值。最后，我们使用嵌套的range循环打印了多维切片的内容。

package main
  
import "fmt"
  
func main() {
    // 创建一个初始切片，长度为3
    slice := make([][]int, 3)
    for i := range slice {
        // 每个内部切片长度为2
        slice[i] = make([]int, 2)
    }
  
    // 给多维切片中的元素赋值
    slice[0][0] = 50
    slice[0][1] = 60
    slice[1][0] = 70
    slice[1][1] = 80
    slice[2][0] = 90
    slice[2][1] = 100
  
    // 打印多维切片的内容
    for i := range slice {
        for j := range slice[i] {
            fmt.Println(slice[i][j])
        }
    }
}