Go语言切片

基本介绍

Go 语言切片是对数组的抽象，是一种长度可变的动态数组。

基本用法

切片声明

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

	var s []int

或者使用 make 函数来创建切片

	var slice1 []type = make([]type, len)

	// 使用简短声明
	slice1 := make([]type, len)

切片初始化

直接初始化切片，不用像数组一样指定长度

	s := []int {1,2,3}

引用一个数组

	arr := [3]int{1,2,3}
	s := arr[:]

引用部分数组

	arr := [3]int{1,2,3}
	s := arr[1:2]

引用一个切片

	s1 := []int{1,2,3,4,5}
	s2 := s1[:]

len 和 cap

len ：获取切片元素的数量

	s1 := []int{1,2,3,4,5}
	fmt.Println(len(s1)) // 输出 5

cap ：获取切片元素的容量

	s1 := []int{1,2,3,4,5}
	fmt.Println(cap(s1)) // 输出 5

切片截取

切片截取规则

截取规则由起始位置和结束位置组成，中间用冒号隔开
起始位置和结束位置可以省略不写，不写则代表开头或者结尾
截取元素包含起始位置的元素，但是不包含结束位置的元素
起始位置和结束位置必须不能是负数
结束位置要大于等于起始位置

	// 获取全部元素
	fmt.Println(slice1[:])// [1 2 3 4 5 6 7 8 9]

	// 获取从下标为 0 元素到下标为 7 的元素，不包含最后的元素
	fmt.Println(slice1[:7])// [1 2 3 4 5 6 7]

	// 获取从下标为 2 的元素开始，到结尾
	fmt.Println(slice1[2:])// [3 4 5 6 7 8 9]

	// 获取从下标为 4 元素到下标为 6 的元素
	fmt.Println(slice1[4:6])// [5 6]

append 函数

切片初始化之后，可以使用 append 函数向切片中追加元素

可以一次追加一个元素
也可以一次追加多个元素
也可以追加整个切片，切片后面使用…

	// 追加一个元素
	slice2 := []int{1,2,3,4,5}
	slice2 = append(slice2,6)
	fmt.Println(slice2)// [1 2 3 4 5 6]

	// 追加多个元素
	slice2 = append(slice2,7,8,9)
	fmt.Println(slice2)// [1 2 3 4 5 6 7 8 9]

	// 追加一个切片
	slice3 := []int{1,2,3}
	slice2 = append(slice2,slice3...)// [1 2 3 4 5 6 7 8 9 1 2 3]

copy 函数

由于切片是引用类型，如果简单赋值给一个变量，两者其实还是指向相同的底层数组，这时可以使用copy 函数可以将一个切片复制给另外一个切片。

	slice4 := []int{1,2,3}
	slice6 := make([]int,3)
	slice5 := slice4
	copy(slice6,slice4)
	
	slice4[0] = 3
	
	fmt.Println(slice5)//[3 2 3]
	fmt.Println(slice6)//[1 2 3]

从上面的 demo 可以看出来直接赋值后的 slice5 因为 slice4 改变，自己也改变
而 slice6 还是保持自己原有的值，表示他和 slice4 指向不同的底层数组
使用 copy 的切片一定是要初始化过的或者使用 make 之后的，要不然无法复制

自动扩容

每次使用 append 函数给切片添加元素的时候，Go 为了减少内存分配次数，会进行扩容判断，如果当前容量够用，则不进行扩容，如果超出目前容量则将容量进行翻倍。

	slice7 := []int{1,2,3}
	fmt.Println(cap(slice7)) // 3

	slice7 = append(slice7,4)
	fmt.Println(cap(slice7))// 6

	slice7 = append(slice7,5)
	fmt.Println(cap(slice7))// 6

	slice7 = append(slice7,6)
	fmt.Println(cap(slice7))// 6

	slice7 = append(slice7,7)
	fmt.Println(cap(slice7))// 12