首页 > 编程笔记 > Go语言笔记 阅读：12

Golang切片(slice)的用法（非常详细）

Go语言的切片（slice）是包含相同类型元素的、可变长度的序列。与数组不同，切片的长度是可变的。

本节讲解切片的使用方法。

Go语言切片的定义

定义切片可以分为声明切片和初始化切片两个步骤。

1) 声明切片

切片不需要指定长度，可使用“[]”声明切片。声明切片的语法格式如下： 
var slice_name []slice_type
参数说明如下：

2) 初始化切片

初始化切片的方式有多种，下面依次讲解常用的方式。

① 直接初始化切片。使用“短变量声明”的语法格式初始化 int 类型的切片 slice；在这个切片中，包含 2、5 和 8 这 3 个元素。代码如下： 
slice := []int{2, 5, 8} // 等价于 var slice = []int{2, 5, 8}

② 通过引用数组 array 中的所有元素完成切片 slice 的初始化操作。
声明并初始化包含 7 个元素（即 1、3、5、7、9、11 和 13）的 int 类型数组 value，使用“短变量声明”的语法格式初始化切片 slice，并让切片 slice 引用数组 value 中的所有元素。代码如下： 
value := [7]int{1, 3, 5, 7, 9, 11, 13} // 声明并初始化包含7个元素的int类型数组
slice := value[:] // 引用数组 value 中的所有元素

③ 通过引用数组 array 中索引为 startIndex 到 endIndex-1 的元素完成切片 slice 的初始化操作。
声明并初始化包含 7 个元素（即 1、3、5、7、9、11 和 13）的 int 类型数组 value，使用“短变量声明”的语法格式初始化切片 slice，并让切片 slice 引用数组 value 中索引为 2~5 的元素。代码如下： 
value := [7]int{1, 3, 5, 7, 9, 11, 13} // 声明并初始化包含7个元素的int类型数组
slice := value[2:6] // 引用数组 value 中索引为 2～5 的元素

④ 通过引用数组 array 中索引为 startIndex 的元素后的所有元素完成切片 slice 的初始化操作。
声明并初始化包含 7 个元素（1、3、5、7、9、11 和 13）的 int 类型数组 value，使用“短变量声明”的语法格式初始化切片 slice，并让切片 slice 引用数组 value 中索引为 2 的元素后的所有元素。代码如下： 
value := [7]int{1, 3, 5, 7, 9, 11, 13} // 声明并初始化包含7个元素的int类型数组
slice := value[2:] // 引用数组 value 中索引为 2 的元素后的所有元素

⑤ 通过引用数组 array 中索引为 endIndex 的元素前的所有元素完成切片 slice 的初始化操作。
声明并初始化包含 7 个元素（1、3、5、7、9、11 和 13）的 int 类型数组 value，使用“短变量声明”的语法格式初始化切片 slice，并让切片 slice 引用数组 value 中索引为 5 的元素前的所有元素。代码如下： 
value := [7]int{1, 3, 5, 7, 9, 11, 13} // 声明并初始化包含7个元素的int类型数组
slice := value[:5] // 引用数组 value 中索引为 5 的元素前的所有元素
数组和切片是紧密关联的，切片可以访问数组中的部分或全部元素。

⑥ 通过切片 slice 初始化切片 slice。
使用“短变量声明”的语法格式初始化包含 6 个 int 类型元素的切片 slice，并让切片 slice 引用切片 slice 中索引为 1~3 的元素。代码如下： 
slice := []int{2, 5, 8, 3, 6, 9} // 声明并初始化包含 6 个 int 类型元素的切片
slice := slice[1:4] // 引用切片 slice 中索引为 1～3 的元素

⑦ 使用 make() 函数初始化切片。
make() 函数是 Go 语言的内置函数，用于初始化切片。make() 函数的语法格式如下： 
make([]Type, size, cap)
参数说明如下：
使用“短变量声明”的语法格式和 make() 函数初始化元素是 int 类型的切片 slice，并且为这个切片分配 5 个 int 类型的元素。代码如下： 
slice := make([]int, 5)
在上述示例的基础上，设置切片的容量为 10，代码如下： 
slice := make([]int, 5, 10)

Go语言空切片

空切片是指尚未被初始化的切片。此时的切片是空的，即在切片中没有元素；空切片的长度为 0。

在 Go 语言中，用 nil 表示空切片，用一个实例演示如何打印空切片及其长度和容量。

【实例】声明 int 类型的切片 numbers。使用 if 语句判断切片 numbers 是否是空切片；如果切片 numbers 是空切片，则格式化输出切片 numbers 及其长度和容量。代码如下： 
package main
import "fmt"

func main() {
    var numbers []int // 声明 int 类型的切片 numbers
    if numbers == nil { // 如果切片 numbers 是空切片
        // 格式化输出切片 numbers 及其长度和容量
        fmt.Printf("len=%d cap=%d slice=%v\n", len(numbers), cap(numbers), numbers)
    }
}
运行结果如下：

len=0 cap=0 slice=[]

Go语言切片的访问

Go语言访问切片中的元素有两种形式：一种是使用索引的形式；另一种是使用索引切片访问切片的形式。

1) 使用索引访问切片元素的语法格式

slice_Name[index] // 获取切片 sliceName 的索引为 index 处的元素
参数说明如下：
下面通过示例演示如何使用索引访问切片中的元素。代码如下： 
package main
import (
    "fmt"
)

func main() {
    // 使用索引的形式，访问单个切片元素
    var s []int{123, 456, 789}
    s0 := s[0]
    s1 := s[1]
    s2 := s[2]
    fmt.Println("s0 =", s0, "ns1 =", s1, "ns2 =", s2)
}
运行结果如下：

s0 = 123
s1 = 456
s2 = 789

2) 使用索引切片访问切片元素的语法格式

slice_Name[index1:index2] // 获取切片 sliceName 中索引 index1 到 index2-1 的元素
参数说明如下：
下例演示如何使用索引切片访问切片中的元素。代码如下： 
package main
import (
    "fmt"
)

func main() {
    // 使用索引切片的形式，访问切片中的元素
    var s []int{123, 456, 789}
    sr := s[0:2]
    fmt.Println("sr =", sr)
}
运行结果如下：

sr = [123 456]

Go语言删除切片

Go 语言没有提供删除切片的函数或接口。与截取切片的实现方式相同，使用元素的索引也能够达到删除切片的目的。

根据删除切片中元素的位置，可以把删除切片分为如下 3 种情况：

1) 从切片的起始位置连续删除n个元素

声明并初始化 int 类型的切片 numbers，其中包含 1、2、3、4、5、6、7、8 和 9 等 9 个元素。从切片 numbers 的起始位置，连续删除 n 个元素，代码如下： 
numbers := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
numbers = numbers[n:]

2) 从切片的中间位置，连续删除n个元素

从切片 numbers 中索引为 i 的元素开始连续删除 n 个元素，代码如下： 
numbers := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
numbers = append(numbers[:i], numbers[(i+n):]...)

3) 从切片的尾部位置连续删除n个元素

从切片 numbers 的尾部位置连续删除 n 个元素，代码如下： 
numbers := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
numbers = numbers[:len(numbers)-n]
下例演示如何从切片的中间位置连续删除 n 个元素。

【实例】从切片的中间位置连续删除 3 个元素。声明并初始化 int 类型的切片 numbers，包含 1、2、3、4、5、6、7、8 和 9 等 9 个元素。从切片 numbers 中索引为 3 的元素往后连续删除 3 个元素。打印删除元素后的切片，代码如下： 
package main
import "fmt"

func main() {
    numbers := []int{1, 2, 3, 4, 5, 6, 7, 8, 9} // 声明并初始化 int 类型的切片 numbers
    i := 3 // 切片 numbers 中索引为 3 的元素
    n := 3 // 连续删除 3 个元素
    // 从切片 numbers 中索引为 3 的元素往后连续删除 3 个元素
    numbers = append(numbers[:i], numbers[(i+n):]...)
    fmt.Println(numbers) // 打印删除元素后的切片
}
运行结果如下：

[1 2 3 7 8 9]

相关文章