切片（slice）是对数组的一个连续片段的引用，所以切片是一个引用类型，这个片段可以是整个数组，也可以是由起始和终止索引标识的一些项的子集，需要注意的是，终止索引标识的项不包括在切片内。
Go语言中切片的内部结构包含地址、大小和容量，切片一般用于快速地操作一块数据集合，如果将数据集合比作切糕的话，切片就是你要的“那一块”，切的过程包含从哪里开始（切片的起始位置）及切多大（切片的大小），容量可以理解为装切片的口袋大小，如下图所示:
切片默认指向一段连续内存区域，可以是数组，也可以是切片本身。
从连续内存区域生成切片是常见的操作，格式如下：
slice [开始位置 : 结束位置]
语法说明如下：
从数组生成切片，代码如下：
import "fmt"
func main() {
var a = [3]int{1, 2, 3}
fmt.Println(a, a[1:2])
}
从数组或切片生成新的切片拥有如下特性：
a[len(a)-1]
除了可以从原有的数组或者切片中生成切片外，也可以声明一个新的切片，每一种类型都可以拥有其切片类型，表示多个相同类型元素的连续集合，因此切片类型也可以被声明，切片类型声明格式如下：
var name []Type
package main
import "fmt"
func main() {
// 声明字符串切片
var strList []string
// 声明整型切片
var numList []int
// 声明一个空切片 分配了内存 但是没有元素
var numListEmpty = []int{}
// 输出3个切片
fmt.Println(strList, numList, numListEmpty)
// 输出3个切片大小
fmt.Println(len(strList), len(numList), len(numListEmpty))
// 切片判定空的结果
fmt.Println(strList == nil)
fmt.Println(numList == nil)
fmt.Println(numListEmpty == nil)
}
切片是动态结构 只能与nil判断相等，不能互相判等。
如果需要动态地创建一个切片，可以使用 make() 内建函数，格式如下：
make( []Type, size, cap )
代码：
package main
import "fmt"
func main() {
a := make([]int, 2)
b := make([]int, 2, 10)
fmt.Println(a, b)
fmt.Println(len(a), len(b))
}
结果：
[0 0] [0 0]
2 2
a和b均是预分配了2个元素的切片，只是b的内部存储空间已经分配了10个，但实际上只是用了2个元素。
容量不会影响当前的元素个数，因此a和b取len都是2
使用make（）函数一定发生了内存分配的操作。但给定开始与结束位置的切片只是将新的切片结构指向已经分配好的内存区域，不会发生内存分配操作。
Go语言的内建函数append（）可以为切片动态添加元素，每个切片会指向一片内存空间，这片空间能容纳一定数量的元素。当空间不能容纳足够多的元素时，切片就会进行扩容（2倍），扩容操作往往发生在append（）函数调用时。
代码：
package main
import "fmt"
func main() {
//声明一个切片
var numbers []int
for i := 0; i < 10; i++ {
numbers = append(numbers, i) //给切片中添加元素
fmt.Printf("len: %d cap: %d pointer: %p\n", len(numbers), cap(numbers), numbers)
}
}
结果：
len: 1 cap: 1 pointer: 0xc000018080
len: 2 cap: 2 pointer: 0xc0000180a0
len: 3 cap: 4 pointer: 0xc00001a040
len: 4 cap: 4 pointer: 0xc00001a040
len: 5 cap: 8 pointer: 0xc00001e0c0
len: 6 cap: 8 pointer: 0xc00001e0c0
len: 7 cap: 8 pointer: 0xc00001e0c0
len: 8 cap: 8 pointer: 0xc00001e0c0
len: 9 cap: 16 pointer: 0xc000102000
len: 10 cap: 16 pointer: 0xc000102000
可以看到容量是以2倍进行扩增的。在进行扩增之后，地址也可能发生改变
也可以一次性添加多个元素
package main
import "fmt"
func main() {
//声明一个切片
var car []string
//添加一个元素
car = append(car, "oldDriver")
//添加多个元素
car = append(car, "ice", "sniper", "monk")
fmt.Println(car)
//添加切片
team := []string{"pig", "cat"}
car = append(car, team...)
fmt.Println(car)
}
结果：
[oldDriver ice sniper monk]
[oldDriver ice sniper monk pig cat]
team后添加的...表示将team整个添加到car的后面
使用Go语言内建的copy函数，可以迅速地将一个切片的数据复制到另一个切片空间中，如果加入的两个数组切片不一样大，就会按照其中较小的那个数组切片的元素个数进行复制。
copy() 函数的使用格式如下：
copy( destSlice, srcSlice []T) int
代码：
package main
import "fmt"
func main() {
// 设置元素数量为1000
const elementCount = 1000
// 预分配足够多的元素切片
srcData := make([]int, elementCount)
// 将切片赋值
for i := 0; i < elementCount; i++ {
srcData[i] = i
}
// 引用切片数据
refData := srcData
// 预分配足够多的元素切片
copyData := make([]int, elementCount)
// 将数据复制到新的切片空间中
copy(copyData, srcData)
// 修改原始数据的第一个元素
srcData[0] = 999
// 打印引用切片的第一个元素
fmt.Println(refData[0])
// 打印复制切片的第一个和最后一个元素
fmt.Println(copyData[0], copyData[elementCount-1])
// 复制原始数据从4到6(不包含)
copy(copyData, srcData[4:6])
for i := 0; i < 5; i++ {
fmt.Printf("%d ", copyData[i])
}
}
结果：
999
0 999
4 5 2 3 4
Go语言并没有对删除切片元素提供专用的语法或者接口，需要使用切片本身的特性来删除元素，根据要删除元素的位置有三种情况，分别是从开头位置删除、从中间位置删除和从尾部删除，其中删除切片尾部的元素速度最快。
删除开头的元素可以直接移动数据指针：
a = []int{1, 2, 3}
a = a[1:] // 删除开头1个元素
a = a[N:] // 删除开头N个元素
也可以不移动数据指针，但是将后面的数据向开头移动，可以用 append 原地完成（所谓原地完成是指在原有的切片数据对应的内存区间内完成，不会导致内存空间结构的变化）：
a = []int{1, 2, 3}
a = append(a[:0], a[1:]...) // 删除开头1个元素
a = append(a[:0], a[N:]...) // 删除开头N个元素
还可以用 copy() 函数来删除开头的元素：
a = []int{1, 2, 3}
a = a[:copy(a, a[1:])] // 删除开头1个元素
a = a[:copy(a, a[N:])] // 删除开头N个元素
对于删除中间的元素，需要对剩余的元素进行一次整体挪动，同样可以用 append 或 copy 原地完成：
a = []int{1, 2, 3, ...}
a = append(a[:i], a[i+1:]...) // 删除中间1个元素
a = append(a[:i], a[i+N:]...) // 删除中间N个元素
a = a[:i+copy(a[i:], a[i+1:])] // 删除中间1个元素
a = a[:i+copy(a[i:], a[i+N:])] // 删除中间N个元素
a = []int{1, 2, 3}
a = a[:len(a)-1] // 删除尾部1个元素
a = a[:len(a)-N] // 删除尾部N个元素
删除开头的元素和删除尾部的元素都可以认为是删除中间元素操作的特殊情况，下面来看一个示例。
【示例】删除切片指定位置的元素。
package main
import "fmt"
func main() {
seq := []string{"a", "b", "c", "d", "e"}
// 指定删除位置
index := 2
// 查看删除位置之前的元素和之后的元素
fmt.Println(seq[:index], seq[index+1:])
// 将删除点前后的元素连接起来
seq = append(seq[:index], seq[index+1:]...)
fmt.Println(seq)
}
代码输出结果：
[a b] [d e]
[a b d e]
代码说明如下：
Go语言中删除切片元素的本质是，以被删除元素为分界点，将前后两个部分的内存重新连接起来。
连续容器的元素删除无论在任何语言中，都要将删除点前后的元素移动到新的位置，随着元素的增加，这个过程将会变得极为耗时，因此，当业务需要大量、频繁地从一个切片中删除元素时，如果对性能要求较高的话，就需要考虑更换其他的容器了（如双链表等能快速从删除点删除元素）
使用range关键字来迭代切片
代码：
package main
import "fmt"
func main() {
//创建一个切片
slice := []int{10, 20, 30}
//迭代每个元素，并显示值和地址和切片中的地址
for index, value := range slice {
fmt.Printf("%d value: %d value-addr: %X,slice-addr %X\n", index, value, &value, &slice[index])
}
}
结果：
0 value: 10 value-addr: C000018080,slice-addr C00001C078
1 value: 20 value-addr: C000018080,slice-addr C00001C080
2 value: 30 value-addr: C000018080,slice-addr C00001C088
因为迭代返回的变量是一个在迭代过程中根据切片依次赋值的新变量，所以 value 的地址总是相同的，要想获取每个元素的地址，需要使用切片变量和索引值（例如上面代码中的 &slice[index]）
如果不需要索引，可以使用匿名变量名-来忽略这个值。