一次看懂go语言中的slice（底层原理和常用操作）

写在前面
本篇文章是通过学习[https://www.liwenzhou.com/posts/Go/06_slice/#autoid-2-1-5]和观看幼麟实验室的视频所写，用于个人学习，如有侵权请联系删除。

正文：
因为数组的长度是固定的并且数组长度属于类型的一部分，所以数组有很多的局限性 。
例如：

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

数组a中已经有三个元素了，我们不能再继续往数组a中添加新元素了。

所以便有了切片(slice)

slice

切片（Slice）是一个拥有相同类型元素的可变长度的序列。它是基于数组类型做的一层封装。它非常灵活，支持自动扩容。

切片是一个引用类型，它的内部结构包含地址、长度和容量。切片一般用于快速地操作一块数据集合。

切片的本质就是对底层数组的封装，它包含了三个信息：底层数组的指针、切片的长度（len）和切片的容量（cap）。

声明切片类型的基本语法如下：

var ints []int

由于还没有分配底层数组所以data为0，len和cap也为0

如果使用make方式初始化不仅会分配这三部分，还会开辟一段内存作为它的底层数组。

var ints []int = make([]int, 2 ,5)

切片可以使用append追加元素

ints = append(ints,1)

由于已经有两个元素所以它是第三个

此时数据变成0 0 1 0 0

已经存储的数据是可以安全读写的

ints[0] = 1 //正确
ints[3] = 1 //错误会引发panic

使用new创建一个字符串类型的slice变量

ps := new([]string)
*ps = append(*ps, "eggo")

底层数组

切片中的data并不一定指向底层数组的开头。

arr := [10]int{0,1,2,3,4,5,6,7,8,9} //注意数组定义后长度不可以改变
var s1 []int = arr[1:4] //切片共用底层数组， 索引从1到4左闭右开
var s2 []int = arr[7:]

需要注意的是此时的s1 它的data指向arr[1] len为3 cap为9(注意容量为data指向的位置到底层数组的最后)

slice访问和修改的都是底层数组。

切片的扩容

如果此时给s2追加元素会怎么样？会开辟新的数组，发生扩容。

步骤1：预估扩容后的容量newcap

可以通过查看$GOROOT/src/runtime/slice.go源码，其中扩容相关代码如下：

newcap := old.cap
doublecap := newcap + newcap
if cap > doublecap {
	newcap = cap
} else {
	if old.len < 1024 {
		newcap = doublecap
	} else {
		// Check 0 < newcap to detect overflow
		// and prevent an infinite loop.
		for 0 < newcap && newcap < cap {
			newcap += newcap / 4
		}
		// Set newcap to the requested cap when
		// the newcap calculation overflowed.
		if newcap <= 0 {
			newcap = cap
		}
	}
}

• 首先判断，如果新申请容量（cap）大于2倍的旧容量（old.cap），最终容量（newcap）就是新申请的容量（cap）。
• 否则判断，如果旧切片的长度小于1024，则最终容量(newcap)就是旧容量(old.cap)的两倍，即（newcap=doublecap），
• 否则判断，如果旧切片长度大于等于1024，则最终容量（newcap）从旧容量（old.cap）开始循环增加原来的1/4，即（newcap=old.cap,for {newcap += newcap/4}）直到最终容量（newcap）大于等于新申请的容量(cap)，即（newcap >= cap）
• 如果最终容量（cap）计算值溢出，则最终容量（cap）就是新申请容量（cap）。

步骤2：newcap需要多大内存

很多编程语言中申请内存并不是和操作系统交涉而是和语言自身实现的内存管理模块，它会向操作系统提前申请一批内存，分成常用的规格管理起来(8,16,32,48,64,80,96,112)，申请内存时，他会帮助我们匹配足够大且最接近的规格。

步骤3：匹配到合适的内存

比如说扩容后容量为5，5*8=40，而实际会匹配到48字节。

下面举一个例子：

a := []string{"my", "name", "is"}
a = append(a, "eggo")
//step1 oldcap = 3, cap = 4, 3 * 2 > 4, 3 < 1024, newcap = 2*oldcap = 6
//step2 6 * 16 = 96
//step3 匹配到96字节

切片中常用的操作

遍历

切片的遍历方式和数组是一致的，支持索引遍历和for range遍历。

func main() {
	s := []int{1, 3, 5}

	for i := 0; i < len(s); i++ {
		fmt.Println(i, s[i])
	}

	for index, value := range s {
		fmt.Println(index, value)
	}
}

切片不能直接比较

切片之间是不能比较的，我们不能使用==操作符来判断两个切片是否含有全部相等元素。 切片唯一合法的比较操作是和nil比较。 一个nil值的切片并没有底层数组，一个nil值的切片的长度和容量都是0。但是我们不能说一个长度和容量都是0的切片一定是nil，例如下面的示例：

var s1 []int         //len(s1)=0;cap(s1)=0;s1==nil
s2 := []int{}        //len(s2)=0;cap(s2)=0;s2!=nil
s3 := make([]int, 0) //len(s3)=0;cap(s3)=0;s3!=nil

所以要判断一个切片是否是空的，要是用len(s) == 0来判断，不应该使用s == nil来判断。

添加元素

Go语言的内建函数append()可以为切片动态添加元素。 可以一次添加一个元素，可以添加多个元素，也可以添加另一个切片中的元素（后面加…）。

func main(){
	var s []int				//通过var声明的零值切片可以在append()函数直接使用，无需初始化。
	s = append(s, 1)        // [1]
	s = append(s, 2, 3, 4)  // [1 2 3 4]
	s2 := []int{5, 6, 7}  
	s = append(s, s2...)    // [1 2 3 4 5 6 7]
}

使用copy()函数来复制切片

首先我们来看一个问题：

func main() {
	a := []int{1, 2, 3, 4, 5}
	b := a
	fmt.Println(a) //[1 2 3 4 5]
	fmt.Println(b) //[1 2 3 4 5]
	b[0] = 1000
	fmt.Println(a) //[1000 2 3 4 5]
	fmt.Println(b) //[1000 2 3 4 5]
}

由于切片是引用类型，所以a和b其实都指向了同一块内存地址。修改b的同时a的值也会发生变化。

Go语言内建的copy()函数可以迅速地将一个切片的数据复制到另外一个切片空间中，copy()函数的使用格式如下：

copy(destSlice, srcSlice []T)

其中：

• srcSlice: 数据来源切片
• destSlice: 目标切片

举个例子：

func main() {
	// copy()复制切片
	a := []int{1, 2, 3, 4, 5}
	c := make([]int, 5, 5)
	copy(c, a)     //使用copy()函数将切片a中的元素复制到切片c
	fmt.Println(a) //[1 2 3 4 5]
	fmt.Println(c) //[1 2 3 4 5]
	c[0] = 1000
	fmt.Println(a) //[1 2 3 4 5]
	fmt.Println(c) //[1000 2 3 4 5]
}

删除元素

Go语言中并没有删除切片元素的专用方法，我们可以使用切片本身的特性来删除元素。 代码如下：

func main() {
	// 从切片中删除元素
	a := []int{30, 31, 32, 33, 34, 35, 36, 37}
	// 要删除索引为2的元素
	a = append(a[:2], a[3:]...)
	fmt.Println(a) //[30 31 33 34 35 36 37]
}

总结一下就是：要从切片a中删除索引为index的元素，操作方法是a = append(a[:index], a[index+1:]...)