Go语言--语法基础6--基本数据类型--切片类型

Go 语言切片是对数组的抽象。Go 数组的长度不可改变,在特定场景中这样的集合就不太适用,Go 中提供了一种灵活、功能强悍的内置类型切片 ("动态数组"),与数组相比切片的长度是不固定的,可以追加元素,在追加时可能使切片的容量增大。

切片是一个在 Go 语言中引入的新理念,它有一些特征如下:

  • 对数组抽象
  • 数组长度不固定
  • 可追加元素
  • 切片容量可增大

1、定义切片

你可以声明一个未指定大小的数组来定义切片:

复制代码
var identifier []type 

切片不需要说明长度。

示例

复制代码
var s []int // 定义一个整形大小不定的切片,变量名称 s

除此之外,切片还有其他几种定义方式:

复制代码
var (
    a []int // nil 切片,和 nil 相等,一般用来表示一个不存在的切片
    b = []int{} // 空切片,和 nil 不相等,一般用来表示一个空的集合
    c = []int{1, 2, 3} // 有3个元素的切片,len=3,cap=3
    d = c[:2] // 有2个元素的切片,len=2,cap=3
    e = c[0:2:cap(c)] // 有2个元素的切片,len=2,cap=3 
    f = c[:0] // 有0个元素的切片,len=0,cap=3
    g = make([]int, 3) // 有3个元素的切片,len=3,cap=3 
    h = make([]int, 2, 3) // 有2个元素的切片,len=2,cap=3 
    i = make([]int, 0, 3) // 有0个元素的切片,len=0,cap=3 
)

本质

切片本身是一个三个字段的数据结构:

复制代码
type SliceHeader struct {
    Data uintptr // 指向底层数组的指针
    Len  int     // 切片中元素的个数,通过 len(s) 获取
    Cap  int     // 切片的容量(不需重新分配内存前,可容纳的元素数量),通过 cap(s) 获取
}

区分数组的声明和切片的声明方式

当使用字面量来声明切片时,其语法与使用字面量声明数组非常相似。二者的区别是:如果在 [] 运算符里指定了一个值,那么创建的就是数组而不是切片。只有在 [] 中不指定值的时候,创建的才是切片。

2、切片初始化

复制代码
s := []int{1, 2, 3}  // 直接初始化切片,[] 表示是切片类型,{1, 2, 3} 初始化值依次是1, 2, 3,其 cap=len=3
s := arr[:]          // 初始化切片 s,是数组 arr 的引用
s := arr[startIndex:endIndex]  // 将 arr 中从下标 startIndex 到 endIndex-1 下的元素创建为一个新的切片
s := arr[startIndex:]  // 缺省 endIndex 时将表示一直到 arr 的最后一个元素
s := arr[:endIndex]    // 缺省 startIndex 时将表示从 arr 的第一个元素开始
s1 := s[startIndex:endIndex]  // 通过切片 s 初始化切片 s1
s := make([]int, len, cap)  // 通过内置函数 make() 初始化切片 s,[]int 标识为其元素类型为 int 的切片

3、访问

切片只能访问其长度范围内的内容,通过下标访问:

复制代码
s[i] = 10  // 写操作
v := s[i]  // 读操作

迭代方式访问

切片是一个集合,可以通过 range 迭代其中的元素:

  1. for 循环方式的迭代

    var slice = []string{"Red", "Yellow", "Blue", "Green", "Gray"}
    // for 循环迭代
    for i := 0; i < len(slice); i++ {
    fmt.Println(i, slice[i])
    }

  2. range 遍历

    for index, value := range slice {
    fmt.Printf("index: %d, value: %s\n", index, value)
    }

注意

  • range 返回的第二个值是对应元素的一份副本,不能用于修改;若要修改则需要通过索引。
  • 迭代方式遍历时,不能对切片进行操作(添加、或删除元素),否则会引发异常。

5、len () 和 cap () 函数

切片是可索引的,并且可以由 len() 方法获取长度。切片提供了计算容量的方法 cap() 可以测量切片最长可以达到多少。

示例

复制代码
package main
import "fmt"

func main() {
    var numbers = make([]int, 3, 5)
    printSlice(numbers)
}

func printSlice(x []int) {
    fmt.Printf("len=%d cap=%d slice=%v\n", len(x), cap(x), x)
}

输出结果

复制代码
len=3 cap=5 slice=[0 0 0]

6、空 (nil) 切片

一个切片在未初始化之前默认为 nil,长度为 0。

示例

复制代码
package main
import "fmt"

func main() {
    var numbers []int
    printSlice(numbers)
    if numbers == nil {
        fmt.Printf("切片是空的")
    }
}

func printSlice(x []int) {
    fmt.Printf("len=%d cap=%d slice=%v\n", len(x), cap(x), x)
}

输出结果

复制代码
len=0 cap=0 slice=[]
切片是空的

7、切片的增删改查操作

1. 切片尾部新增元素

复制代码
var slice []int
// 新增一个元素
slice = append(slice, 1)
// 新增多个元素
slice = append(slice, 1, 2)
// 新增多个元素,切片作为参数,需要使用 ... 运算符来辅助解构切片
var newSlice = []int{1, 2, 3}
slice = append(slice, newSlice...) // ... 不能省略

2. 切片首部新增元素

复制代码
// 切片首部增加元素
var slice = []int{1, 2}
// 首部增一个元素
slice = append([]int{5}, slice...) 
// 首部增多个元素
var newSlice = []int{5, 6, 7}
slice = append(newSlice, slice...) 

3. 切片中间新增元素

复制代码
// 切片中间某个位置插入元素
var slice = []int{1, 2, 3}
// 比如需要插入到元素索引 i 后,则先以 i+1 为切割点,把 slice 切割成两半
// 索引 i 前数据:slice[:i+1],索引 i 后的数据:slice[i+1:]
// 然后再把索引 i 后的数据:slice[i:] 合并到需要插入的元素切片中
// 最后再把合并后的切片合并到索引 i 前数据:slice[:i]
// 如在元素索引 1 后增加元素
slice = append(slice[:2], append([]int{6, 7}, slice[2:]...)...)

删除操作

复制代码
var slice = []int{1, 2, 3, 4, 5, 6}
// 从切片首部删除
slice = slice[1:]
// 从切片尾部删除2个
slice = slice[:len(slice) - 2]
// 从切片中间删除,如从索引为 i,删除2个元素(i+2)
slice = append(slice[:1], slice[3:]...)

其他操作

复制代码
// 修改元素
var slice = []int{1, 2, 3}
slice[1] = 6

// 查找元素
var slice = []int{1, 2, 3}
log.Println("slice[1]=", slice[1])

// 试图访问超出其长度的元素就会报错
a := slice[4]  // runtime error: index out of range [4] with length 3
log.Println(a)

课堂练习

使用切片的增删改查功能完成一个简单用户信息录入和维护程序。