当前位置：首页 > news >正文

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

news 2025/7/7 5:31:37

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=3d = c[:2] // 有2个元素的切片，len=2，cap=3e = c[0:2:cap(c)] // 有2个元素的切片，len=2，cap=3 f = c[:0] // 有0个元素的切片，len=0，cap=3g = 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 迭代其中的元素：

for 循环方式的迭代：

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

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 []intprintSlice(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)