Go语言中的切片（十）
go中数组的长度是固定的，且不同长度的数组是不同类型，这样的限制带来不少局限性。于是切片就来了，切片（Slice）是一个拥有相同类型元素的可变长度的序列。它是基于数组类型做的一层封装。它非常灵活，支持自动扩容。
定义切片
切片的定义跟数组很类似，区别就是不需要指定长度，如下：
var a []int var 切片名 []切片值的类型
举例：
func main() { var a []int // 定义一个整型切片 var b = []int{} // 定义一个整型切片并初始化 var c = []bool{true,false} // 定义一个布尔切片并初始化 fmt.Println(a) // [] fmt.Println(b) // [] fmt.Println(c) // [true false] }
需要注意的是，定义的切片如果没有初始化，是不可以直接操作的。如：
func main() { var a []int // 定义了切片，但没初始化 a[0] = 100 // 直接赋值 fmt.Println(a) // 报错 }
基于数组定义切片
切片的底层就是一个数组，所以可以基于数组定义切片：
func main() { var a = [5]int{1,2,3,4,5} var b = a[1:3] fmt.Println(b) // [2,3] fmt.Printf("b的类型：%T",b) //b的类型：[]int }
代码中 a[1:3] 表示获取从数组索引 1 到 3 的值，包含开始索引的值，不包含结束索引的值，这样就能获取到一个切片。还支持以下操作：
var a = [5]int{1,2,3,4,5} var b = a[1:] // [2 3 4 5] var c = a[:3] // [1 2 3] var d = a[:] // [1 2 3 4 5]
切片的三要素
所谓的三要素是我自己觉得的，分别是 大小，容量和地址。
切片大小
切片的大小指的就是当前切片的长度，可以使用 len() 方法来获取：
func main() { var a = []int{1,2,3,4,5} fmt.Printf("a 的大小是：%v",len(a)) // a 的大小是：5 }
切片的容量
切片的容量可以理解为底层数组最大能存放的元素的个数，使用 cap() 方法来获取，例子：
func main() { var a = [...]string{"北京","上海","广州","深圳","杭州","成都","重庆"} // 定义字符串数组 var b = a[1:5] // 基于数组定义切片 fmt.Printf("切片b的容量：%v",cap(b)) // 切片b的容量：6 }
切片b是从数组a的索引 1 开始的，所以切片的容量是 6。容量是可变的，即切片支持扩容，可以是使用 append() 方法向切片添加项，例子：
func main() { var a = [...]string{"北京","上海","广州","深圳","杭州","成都","重庆"} // 定义字符串数组 var b = a[1:5] // 基于数组定义切片 fmt.Printf("切片b的长度：%v，切片b的容量：%v \n",len(b),cap(b)) b = append(b,"合肥") fmt.Printf("切片b的长度：%v，切片b的容量：%v \n",len(b),cap(b)) b = append(b,"长沙") fmt.Printf("切片b的长度：%v，切片b的容量：%v \n",len(b),cap(b)) b = append(b,"苏州") fmt.Printf("切片b的长度：%v，切片b的容量：%v \n",len(b),cap(b)) } // 切片b的长度：4，切片b的容量：6 // 切片b的长度：5，切片b的容量：6 // 切片b的长度：6，切片b的容量：6 // 切片b的长度：7，切片b的容量：12
从结果分析，每一次append后，切片的长度加 1，而容量如果大于长度时则不变，如果长度超过容量时，容量则会扩容，且每一次扩容都是2倍增长（一个一个的append时是2倍，别的情况不一定）。
直接定义的切片是一样满足的以上条件的：
func main() { var b = []string{"北京","上海","广州"} //直接定义切片 fmt.Printf("切片b的长度：%v，切片b的容量：%v \n",len(b),cap(b)) b = append(b,"合肥") fmt.Printf("切片b的长度：%v，切片b的容量：%v \n",len(b),cap(b)) b = append(b,"长沙") fmt.Printf("切片b的长度：%v，切片b的容量：%v \n",len(b),cap(b)) b = append(b,"苏州") fmt.Printf("切片b的长度：%v，切片b的容量：%v \n",len(b),cap(b)) } // 切片b的长度：3，切片b的容量：3 // 切片b的长度：4，切片b的容量：6 // 切片b的长度：5，切片b的容量：6 // 切片b的长度：6，切片b的容量：6
切片的地址
切片地址是指切片中第一个元素指向的内存空间，本质为底层数组第一个元素的地址，可以使用占位符 %p 来打印，例子：
func main() { var b = []string{"北京","上海","广州"} //直接定义切片 fmt.Printf("切片b的长度：%v，切片b的容量：%v，切片b的地址：%p \n",len(b),cap(b),b) b = append(b,"合肥") fmt.Printf("切片b的长度：%v，切片b的容量：%v，切片b的地址：%p \n",len(b),cap(b),b) b = append(b,"长沙") fmt.Printf("切片b的长度：%v，切片b的容量：%v，切片b的地址：%p \n",len(b),cap(b),b) b = append(b,"苏州") fmt.Printf("切片b的长度：%v，切片b的容量：%v，切片b的地址：%p \n",len(b),cap(b),b) b = append(b,"南京") fmt.Printf("切片b的长度：%v，切片b的容量：%v，切片b的地址：%p \n",len(b),cap(b),b) } // 切片b的长度：3，切片b的容量：3，切片b的地址：0xc000072180 // 切片b的长度：4，切片b的容量：6，切片b的地址：0xc00005a0c0 // 切片b的长度：5，切片b的容量：6，切片b的地址：0xc00005a0c0 // 切片b的长度：6，切片b的容量：6，切片b的地址：0xc00005a0c0 // 切片b的长度：7，切片b的容量：12，切片b的地址：0xc00009c000
从结果可以看到，当切片容量改变时，切片地址也会改变。这是因为当切片要扩容时，底层数组容量也就不够了，要将原数组进行扩容，扩容后由于要求数组的地址空间连续，因此原地址不满足条件，会在开辟一片新的空内存区域存放扩容后的数组，因此地址也就变了。
切片是引用类型
数组是值类型，但基于数组封装的切片却是引用类型，例子：
func main() { var a = []int{1,2,3,4,5} var b = a fmt.Printf("b：%v\n",b) b[0] = 100 fmt.Printf("修改后的b： %v，此时a是：%v\nz",a,b) } // b：[1 2 3 4 5] // 修改后的b： [100 2 3 4 5]，此时a是：[100 2 3 4 5]
引用类型保存的是内存地址，所以当b赋值为a时，引用的是同一个内存地址，当b修改时，a也会改变。
使用copy()函数复制切片
上面说到切片是引用类型，所以不能直接把一个切片赋值给另一个切片而到达复制切片的目的。好在go语言内置了 copy() 函数，可以迅速地将一个切片的数据复制到另外一个切片空间中。其使用方式如下：
copy(目标切片，数据源切片)
举个例子：
func main() { a:=[]int{1,3,5,7} b := make([]int,4,4) copy(b,a) fmt.Println(a) // [1 3 5 7] fmt.Println(b) // [1 3 5 7] a[0] = 100 fmt.Println(a) // [100 3 5 7] fmt.Println(b) // [1 3 5 7] }
使用make()函数构造切片
切片可以是自定义，可以基于数组定义，也可以基于切片再切片。现在还可以使用make()函数来动态创建切片。格式如下：
make([]T,size,cap) // T 切片中的元素类型 // size 切片中元素的数量 // cap 切片的容量
举个例子：
func main() { a:=make([]int,3,5) fmt.Println(a) fmt.Printf("a 的长度：%v\n",len(a)) fmt.Printf("a 的容量：%v",cap(a)) } // [0 0 0] // a 的长度：3 // a 的容量：5
遍历切片
切片的遍历跟数组是一致的，支持索引遍历和 for range遍历：
func main() { a:=[]int{1,3,5,7} for i:=0;i<len(a);i++{ fmt.Println(i) } for idx,val := range a{ println(idx,val) } }
删除切片中的元素
Go语言中并没有删除切片元素的专用方法，我们可以使用切片本身的特性来删除元素。
func main() { a:=[]int{1,3,5,7,9,11,13,15,17} // 删除索引为2的值 b:= append(a[:2],a[3:]...) fmt.Println(b) // [1 3 7 9 11 13 15 17] }
总结一下就是：要从切片 a 中删除索引为 index 的元素，操作方法是 a = append(a[:index], a[index+1:]...)
最后
切片的相关内容到此为止，可能说的不完整，后面学到再补充。
