共计 4016 个字符，预计需要花费 11 分钟才能阅读完成。
对切片的了解
GO 中的数组是固定长度的数据结构，而切片能够了解为一个动静的数组的概念。
它基于数组并提供了动静扩容的 API，在应用上能够了解为 Java 中的 ArrayList，然而其底层还是有十分大的区别的。
切片的组成
切片次要蕴含三个局部
指向底层的数组的指针（pointer）
容量（capacity）
长度（length）
从组成能够看到，切片自身是不蕴含数组而是领有一个指向底层数组的指针，这个和 Java 中的 ArrayList 不同.
因为每个 ArrayList 都拥指向本人独有的数组的 ” 指针 ”，而对于 GO 的切片来说可能存在多个切片对应同一个底层数组的状况。
切片根底原理
定义一个切片的代码如下：
slice := make([]string, 2)
fmt.Println(“ 容量：”, cap(slice), “ 长度：”, len(slice))
// 输入：容量：2 长度：2
slice = make([]string, 2, 3)
fmt.Println(“ 容量：”, cap(slice), “ 长度：”, len(slice))
// 输入：容量：3 长度：2
复制代码
能够看到，如果不指定容量，那么容量默认和长度雷同。那么执行完 make 之后，外部的数据结构是如何呢？以 slice = make([]string, 2, 3)为例：
如图，底层会创立一个以切片容量为长度的数组，并将切片的指针指向数组的第一个元素，此时对切变的拜访会依据切边的长度 (length) 来做限度。
此时切片的 length 是 2，如果此时去拜访 slice 的第 3 个元素，就会产生谬误：
println(slice[2])
// 运行报错：panic: runtime error: index out of range [2] with length 2
复制代码
切片的英文单词是 slice，这个名字是有意义的，咱们能够从一个切片中“切”出一个新的切切片。这个操作如下所示：
newSlice := slice[1:2:3]
fmt.Println(“ 容量：”, cap(newSlice), “ 长度：”, len(newSlice))
// 输入：容量：2 长度：1
复制代码
这时候底层的构造如下：
依据下面的图咱们了解一下 slice[1:2:3]前面三个数字的意义：
第一个下标，这里是 1: 指的是新切片从原先的切片指向的数组索引为 1 的地位开始，这里就是指定新切片的起始下标；
第二个下标，这里是 2: 指的是新切片的长度在原先数组的地位，这里指定为 2（不是数组索引），起始地位为 1，所以新切片的长度就是 2 -1=1；
第三个下标：这里是 3: 指的是新切片的容量在原先数组的地位，这里指定为 3（不是数组索引），起始地位为 1，所以新切片的容量就是 3 -1=2；
这里留神，如果指定的三个下标的数值超过了原先底层的数组的长度（不是索引），会报数组越界谬误。
此时这里两个切片共享一个底层数组，对其中任何一个切片的元素进行批改，都会产生相互影响。
slice := make([]string, 2)
slice = make([]string, 2, 3)
newSlice := slice[1:2:3]
newSlice[0] = “ 张三 ”
printSlice(slice, “slice”)
printSlice(newSlice, “newSlice”)
func printSlice(slice []string, name string) {
fmt.Println(“—– 开始打印 ” + name + “ 的切片元素 ”)
for index, item := range slice {
fmt.Println(name+"索引为", index, "地位的数据为："+item)}
fmt.Println(name, “ 长度为：”, len(slice), ” 容量为：”, cap(slice))
fmt.Println(“—– 完结打印 ” + name + “ 的切片元素 ”)
}
// —– 开始打印 slice 的切片元素
// slice 索引为 0 地位的数据为：
// slice 索引为 1 地位的数据为：张三
// —– 完结打印 slice 的切片元素
// —– 开始打印 newSlice 的切片元素
// newSlice 索引为 0 地位的数据为：张三
// —– 完结打印 newSlice 的切片元素
复制代码
切片与 append 函数
当咱们定义好切片之后，须要增加元素咱们须要应用 append 办法。
slice := []string{“ 茄子 ”, “ 土豆 ”, “ 黄瓜 ”, “ 西瓜 ”}
newSlice := slice[1:3:4]
printSlice(slice, “slice”)
printSlice(newSlice, “newSlice”)
//—– 开始打印 slice 的切片元素
//slice 索引为 0 地位的数据为：茄子
//slice 索引为 1 地位的数据为：土豆
//slice 索引为 2 地位的数据为：黄瓜
//slice 索引为 3 地位的数据为：西瓜
//slice 长度为：4 容量为：4
//—– 完结打印 slice 的切片元素
//—– 开始打印 newSlice 的切片元素
//newSlice 索引为 0 地位的数据为：土豆
//newSlice 索引为 1 地位的数据为：黄瓜
//newSlice 长度为：2 容量为：3
//—– 完结打印 newSlice 的切片元素
复制代码
此时底层数组的构造如图所示，其中，slice 的长度和容量都是 4，即整个底层数组，而 newSlice 指定了 slice[1:3:4], 即其自身的容量是 3，然而此时切片长度为 2
此时咱们执行第一次增加数据：
newSlice = append(newSlice, “ 香蕉 ”)
printSlice(slice, “ 第一次增加数据后：slice”)
printSlice(newSlice, “ 第一次增加数据后：newSlice”)
//—– 开始打印第一次增加数据后：slice 的切片元素
// 第一次增加数据后：slice 索引为 0 地位的数据为：茄子
// 第一次增加数据后：slice 索引为 1 地位的数据为：土豆
// 第一次增加数据后：slice 索引为 2 地位的数据为：黄瓜
// 第一次增加数据后：slice 索引为 3 地位的数据为：香蕉
// 第一次增加数据后：slice 长度为：4 容量为：4
//—– 完结打印第一次增加数据后：slice 的切片元素
//—– 开始打印第一次增加数据后：newSlice 的切片元素
// 第一次增加数据后：newSlice 索引为 0 地位的数据为：土豆
// 第一次增加数据后：newSlice 索引为 1 地位的数据为：黄瓜
// 第一次增加数据后：newSlice 索引为 2 地位的数据为：香蕉
// 第一次增加数据后：newSlice 长度为：3 容量为：3
//—– 完结打印第一次增加数据后：newSlice 的切片元素
复制代码
这里能够看到，对 newSlice 进行 append 增加数据之后，也会同时批改 slice 的数据，这是因为其底层的数据是共享的。append 中后的构造如下
这里，对 newSlice 进行增加数据的时候，因为自身容量为 3，以后长度是 2，它还有空间，所以会间接将数据 ’ 香蕉 ’ 笼罩原先的 ’ 西瓜 ’，因为对于 newSlice 来说，自身 ’ 西瓜 ’ 地位的元素对他来说是未应用的。
此时咱们再对 newSlice 进行第二次增加数据
newSlice = append(newSlice, “ 苹果 ”)
printSlice(slice, “ 第二次增加数据后：slice”)
printSlice(newSlice, “ 第二次增加数据后：newSlice”)
//—– 开始打印第二次增加数据后：slice 的切片元素
// 第二次增加数据后：slice 索引为 0 地位的数据为：茄子
// 第二次增加数据后：slice 索引为 1 地位的数据为：土豆
// 第二次增加数据后：slice 索引为 2 地位的数据为：黄瓜
// 第二次增加数据后：slice 索引为 3 地位的数据为：香蕉
// 第二次增加数据后：slice 长度为：4 容量为：4
//—– 完结打印第二次增加数据后：slice 的切片元素
//—– 开始打印第二次增加数据后：newSlice 的切片元素
// 第二次增加数据后：newSlice 索引为 0 地位的数据为：土豆
// 第二次增加数据后：newSlice 索引为 1 地位的数据为：黄瓜
// 第二次增加数据后：newSlice 索引为 2 地位的数据为：香蕉
// 第二次增加数据后：newSlice 索引为 3 地位的数据为：苹果
// 第二次增加数据后：newSlice 长度为：4 容量为：6
//—– 完结打印第二次增加数据后：newSlice 的切片元素
复制代码
此时能够看到，newSlice 的容量间接扩容了两倍，而 slice 的切片的容量没有变动！这是怎么回事呢，看下图：
这里 newSlice 进行 append 的时候，因为其 length 和容量相等，即其自身的元素曾经慢了，这时候增加元素底层数组也没有空间了，这时候会创立一个容量双倍的底层数组，并将本来的数据进行一次数据的拷贝，放入新创建的数组中，这时候再将数据 ’ 苹果 ’ 放入新增加的数组中，而新的切片会会将数组的指针，指向新创建的数组的第一个元素。
小结
对于切片，它是一种不可变的数据结构，对数组进行赋值都是操作的底层的数组
对切片进行 append 操作，每次都会创立新的 slice 对象，所以每次 append 之后，都要为局部变量从新赋值
扩容的容量，在容量小于 1000 时，每次都是双倍扩容，当超过 1000 之后每次都是 1.25 倍扩容
最初
如果你感觉此文对你有一丁点帮忙，点个赞。或者能够退出我的开发交换群：1025263163 互相学习，咱们会有业余的技术答疑解惑
如果你感觉这篇文章对你有点用的话，麻烦请给咱们的开源我的项目点点 star:http://github.crmeb.net/u/defu 不胜感激！
PHP 学习手册：https://doc.crmeb.com
技术交换论坛：https://q.crmeb.com