Go 语言中，slice表示一个拥有相同类型元素的可变长度序列。slice通常被写为[]T，其中元素的类型都是T；它看上去就像没有长度的数组类型。 数组和slice其实是紧密关联的。
var fslice []int // 和声明array一样，只是少了长度
slice 可以看成是一种轻量级的数据结构，可以用来访问数组的部分或者全部元素，而这个数组称之为 slice 的底层数组。slice的声明也可以像array一样，只是不需要长度。
slice 有三个属性：指针，长度和容量。指针指向数组的第一个可以从 slice 中访问的元素，这个元素不一定是数组的第一个元素。长度指的是 slice 中的元素个数，不能超过 slice 的容量。容量的大小通常大于等于长度，会随着元素个数增多而动态变化。Go语言的内置函数 len 和 cap 用来返回 slice 的长度和容量。
初始化
声明一个slice，并初始化数据：
slice := []byte{'a','b','c','d'}
// 声明一个数组
var array = [10]byte{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
// 声明两个slice
var aSlice, bSlice []byte
// 演示一些简便操作
aSlice = array[:3] // 等价于aSlice = array[0:3] aSlice包含元素: a,b,c
aSlice = array[5:] // 等价于aSlice = array[5:10] aSlice包含元素: f,g,h,i,j
aSlice = array[:] // 等价于aSlice = array[0:10] 这样aSlice包含了全部的元素
// 从slice中获取slice
aSlice = array[3:7] // aSlice包含元素: d,e,f,g，len=4，cap=7
bSlice = aSlice[1:3] // bSlice 包含aSlice[1], aSlice[2] 也就是含有: e,f
bSlice = aSlice[:3] // bSlice 包含 aSlice[0], aSlice[1], aSlice[2] 也就是含有: d,e,f
bSlice = aSlice[0:5] // 对slice的slice可以在cap范围内扩展，此时bSlice包含：d,e,f,g,h
bSlice = aSlice[:] // bSlice包含所有aSlice的元素: d,e,f,g
s3 := make([]int, 10, 20) //make函数初化，len=10, cap=20
slice可以从一个数组或一个已经存在的slice中再次声明。slice通过array[:i:j]来获取，其中i是数组的开始位置，j是结束位置，但不包含array[j]，它的长度是j-i。
注意：slice和数组在声明时的区别，声明数组时，方括号内写明了数组的长度或使用…自动计算长度，而声明slice时，方括号内没有任何字符。
数据结构
slice是引用类型，所以当引用改变其中元素的值时，其它的所有引用都会改变其值。例如修改了Slice_a中元素的值，那么Slice_b相对应的值也会改变。
包含了三个元素：
1）一个指针，指向数组中的slice指定的开始位置；
2）长度len，即slice的长度；
3）最大长度，也就是slice开始位置到数组的最后位置的长度；
一些简便操作
1）slice的默认开始位置是0，arr[:n]等价于arr[0:n]；
2）slice的第二个序列默认是数组的长度，arr[n:]等价于arr[n:len(arr)]；
3）如果从一个数组里面直接获取slice，可以这样arr[:]，因为默认第一个序列是0，第二个是数组的长度，即等价于arr[0:len(arr)]；
slice中len和cap关系
Go语言的内置函数len 和 cap 用来返回slice的长度和容量。
在追加元素时，如果容量cap不足时，cap**一般**变为原来的2倍来实现扩容。
slice的cap扩容规则：
- 如果新的cap大小是当前cap的2倍以上，则直接扩容为这个新的cap；
- 否则循环以下操作：如果当前cap小于1024，按每次2倍增长，否则每次按当前大小1/4增长。直到增长的大小超过或等于新的cap。
slice的几个内置函数
1）len：获取slice的长度；
2）cap：获取slice的最大容量；
3）append：向slice里面追加一个或者多个元素，然后返回一个和slice一样类型的slice；
4）copy：从源slice的src中复制元素到目标dst，并且返回复制的元素的个数；
slice的追加
slice一般用append函数追加元素，append函数会改变slice所引用的数组的空间，从而影响到引用同一数组的其它slice。但当slice中没有剩余空间（即(cap-len)==0）时，此时将动态分配新的数组空间。返回的slice数组指针将指向这个空间，而原数组的内容将保持不变，其它引用此数组的slice则不受影响。
append的第一个参数是slice，第二个参数是元素。结合下Go语言函数的不定参数，我们可以用append优雅地实现两个slice的拼接。例如，下面的函数能合并两个slice的全部元素到一个新的slice，并返回新slice的长度len和容量cap：
代码示例如下：
package main
import "fmt"
func print_info(my_slice[]int) {
fmt.Println("len :",len(my_slice))
fmt.Println("cap :",cap(my_slice))
for i,v := range my_slice{
fmt.Println("element[",i,"]=",v)
}
}
func main() {
my_slice01:=[]int{1,2,3,4,5}
my_slice02:=make([]int,5)
my_slice03:=make([]int,5,6)
my_slice04:=append(my_slice03,8,9,10)
fmt.Println(my_slice01) // 1 2 3 4 5，len: 5, cap:5
fmt.Println(my_slice02) // 0 0 0 0 0, len:5, cap:5
fmt.Println(my_slice03) // 0 0 0 0 0, len:5, cap:6
fmt.Println(my_slice04) // 0 0 0 0 0 8 9 10, len: 8, cap: 12
}
func slice_add(slice01[]int, slice02[]int)(int,int){
new_slice := append(slice01,slice02...)
return len(new_slice),cap(new_slice)
}
slice作为函数参数
注意和数组作为函数参数的区别：
package main
import (
"fmt"
)
func main() {
a := []int{1, 2, 3, 4, 5}
var b = a[0:3] // 1 2 3
var c = [...]int{3, 6, 9, 2, 6, 4}
d := c[0:2] // 3 6
sliceInfo(b)
fmt.Printf("sum of b is %d\n", sum(b)) // 6
fmt.Printf("sum of d is %d\n", sum(d)) // 9
}
func sum(a []int) int {
s := 0
for i := 0; i < len(a); i++ {
s += a[i]
}
return s
}
func sliceInfo(x []int) {
fmt.Printf("len is %d ,cap is %d, slice is %v\n", len(x), cap(x), x) // 3 5 {1，2，3}
}
slice的不可比性
Go 语言中slice 和map ，func一样，不支持 == 操作符，就是不能直接比较，唯一合法的就是和 nil 作比较。开发中经常会遇到需要比较两个slice包含的元素是否完全相等的情况，这个时候只能遍历两个slice中的所有元素 ，看它们是否完全相等。
