Go 语言中的slice类型可以理解为是数组array类型的描述符，包含了三个因素：
- 指向底层数组的指针
- slice目前使用到的底层数组的元素个数，即长度
- 底层数组的最大长度，即容量
因此当我们定义一个切片变量，s := make([]int, 5, 10)，即为指向了一个最大长度为10的底层数组，目前切片s使用到的长度为5。
基于slice的定义，在使用slice时，有以下几点注意事项：
1.对slice进行切分操作
对slice进行切分操作会生成一个新的slice变量，新slice和原来的slice指向同一个底层数组，只不过指向的起始位置可能不同，长度及容量可能也不相同。
- 当从左边界有截断时，会改变新切片容量大小
- 左边界默认0，最小为0；右边界默认slice的长度，最大为slice的容量
- 当然，因为指向同一个底层数组，对新slice的操作会影响到原来的slice
package main
import (
"fmt"
)
func main() {
a := make([]int, 5, 10)
b := a[:3]
//b len: 3 cap: 10
fmt.Println("b-- ", "len:", len(b), " ,cap:", cap(b))
//当从左边界有截断时 会改变新切片容量大小
c := a[2:4]
//c len: 2 cap: 8
fmt.Println("c-- ", "len:", len(c), " ,cap:", cap(c))
//左边界默认0 最小为0 | 右边界默认slice的长度 最大为slice的容量
d := a[:cap(a)]
//d len: 10 cap: 10
fmt.Println("d-- ", "len:", len(d), " ,cap:", cap(d))
}
输出：
b-- len: 3 ,cap: 10 c-- len: 2 ,cap: 8 d-- len: 10 ,cap: 10
2.slice的赋值及函数间传递
a := []int{1, 2, 3, 4, 5}
b := a
package main
import (
"fmt"
)
func main() {
a := []int{1, 2, 3, 4, 5}
b := a
//对b进行操作会影响到a
b[0] = 10
// 10 2 3 4 5
fmt.Println(a)
}
输出：
[10 2 3 4 5]
如上所示，则a, b指向同一个底层数组，且长度及容量因素相同，对b进行的操作会影响到a。
切片作为函数参数示例：
package main
import (
"fmt"
)
func modifySlice(s []int) {
s[0] = 10
}
func main() {
a := []int{1, 2, 3, 4, 5}
modifySlice(a)
//[10 2 3 4 5]
fmt.Println(a)
}
输出：
[10 2 3 4 5]
如上所示，将slice作为参数在函数间传递的时候是值传递，产生了一个新的slice，只不过新的slice仍然指向原来的底层数组，所以通过新的slice也能改变原来的slice的值
package main
import (
"fmt"
)
func modifySlice(s []int) {
s = []int{10, 20, 30, 40, 50}
s[0] = -1
}
func main() {
a := []int{1, 2, 3, 4, 5}
modifySlice(a)
//[1 2 3 4 5]
fmt.Println(a)
}
如上所示，在调用函数的内部，将s整体赋值一个新的slice，并不会改变a的值，因为modifySlice函数内对s重新的整体赋值，让s指向了一个新的底层数组，而不是传递进来之前的a指向的那个数组，之后s的任何操作都不会影响到a了。
3.slice的append操作
append操作最容易踩坑，下面详细说明一下。
append函数定义:
func append(s []T, x ...T) []T
Append基本原则：对于一个slice变量，若slice容量足够，append直接在原来的底层数组上追加元素到slice上；如果容量不足，append操作会生成一个新的更大容量的底层数组。
package main
import (
"fmt"
)
func main() {
a := make([]int, 2, 4)
fmt.Println("initialize.....")
fmt.Println("a:", a, " &a[0]:", &a[0], " len:", len(a), " cap:", cap(a))
//通常append操作都是将返回值赋值给自己,
//此处为了方便说明,没有这样做
//改变b的前2个元素值 会影响到a
a[0] = 99
fmt.Println("赋值之后.....")
fmt.Println("a:", a, " &a[0]:", &a[0], " len:", len(a), " cap:", cap(a))
fmt.Println("Append之后.....")
b := append(a, 2)
b[0] = 1
fmt.Println("a:", a, " &a[0]:", &a[0], " len:", len(a), " cap:", cap(a))
fmt.Println("b:", b, " &b[0]:", &b[0], " len:", len(b), " cap:", cap(b))
a = append(a, 3)
fmt.Println("a Append之后.....")
fmt.Println("a:", a, " &a[0]:", &a[0], " len:", len(a), " cap:", cap(a))
fmt.Println("b:", b, " &b[0]:", &b[0], " len:", len(b), " cap:", cap(b))
a = append(a, 4)
a = append(a, 5)
fmt.Println("a 再次Append之后.....")
//a 扩容了，指向不同的底层数组
fmt.Println("a:", a, " &a[0]:", &a[0], " len:", len(a), " cap:", cap(a))
//a的扩容没有影响到b,b还是指向原来的底层数组
fmt.Println("b:", b, " &b[0]:", &b[0], " len:", len(b), " cap:", cap(b))
}
输出：
initialize..... a: [0 0] &a[0]: 0xc0000105a0 len: 2 cap: 4 赋值之后..... a: [99 0] &a[0]: 0xc0000105a0 len: 2 cap: 4 Append之后..... a: [1 0] &a[0]: 0xc0000105a0 len: 2 cap: 4 b: [1 0 2] &b[0]: 0xc0000105a0 len: 3 cap: 4 a Append之后..... a: [1 0 3] &a[0]: 0xc0000105a0 len: 3 cap: 4 b: [1 0 3] &b[0]: 0xc0000105a0 len: 3 cap: 4 a 再次Append之后..... a: [1 0 3 4 5] &a[0]: 0xc000014240 len: 5 cap: 8 b: [1 0 3] &b[0]: 0xc0000105a0 len: 3 cap: 4
a 再次Append之后，a 扩容了，指向不同的底层数组，a的扩容没有影响到b,b还是指向原来的底层数组
package main
import (
"fmt"
)
func main() {
a := make([]int, 2, 4)
a[0] = 10
a[1] = 20
//a: [10 20] &a[0]: 0x10410020 len: 2 cap: 4
fmt.Println("a:", a, " &a[0]:", &a[0], " len:", len(a), " cap:", cap(a))
//进行append操作
b := append(a[:1], 1)
//a: [10 1] &a[0]: 0x10410020 len: 2 cap: 4
fmt.Println("a:", a, " &a[0]:", &a[0], " len:", len(a), " cap:", cap(a))
//b: [10 1] &b[0]: 0x10410020 len: 2 cap: 4
fmt.Println("b:", b, " &b[0]:", &b[0], " len:", len(b), " cap:", cap(b))
}
输出：
a: [10 20] &a[0]: 0xc0000105a0 len: 2 cap: 4 a: [10 1] &a[0]: 0xc0000105a0 len: 2 cap: 4 b: [10 1] &b[0]: 0xc0000105a0 len: 2 cap: 4
如上所示，若append后的b的实际元素个数没有超过原来的a指向的底层数组的容量，那么a，b指向同一个底层数组。
注意此时append的操作对象是：对a进行切分之后的切片，只取了a的第一个值，相当于一个新切片，长度为1，和a指向同一个底层数组，我们称这个切分后的新切片为c吧，那么就相当于b其实是基于c切片进行append的，直接在长度1之后追加元素，所以append之后a的第二个元素变成了1。【所以切分操作和append操作放一起的时候，一定要小心】
package main
import (
"fmt"
)
func main() {
a := make([]int, 2, 4)
a[0] = 10
a[1] = 20
//a: [10 20] &a[0]: 0x10410020 len: 2 cap: 4
fmt.Println("a:", a, " &a[0]:", &a[0], " len:", len(a), " cap:", cap(a))
//进行append操作
//b := append(a[:1], 1)
c := a[:1]
fmt.Println("c:", c, " &c[0]:", &c[0], " len:", len(c), " cap:", cap(c))
b := append(c, 1)
//a: [10 1] &a[0]: 0x10410020 len: 2 cap: 4
fmt.Println("a:", a, " &a[0]:", &a[0], " len:", len(a), " cap:", cap(a))
//b: [10 1] &b[0]: 0x10410020 len: 2 cap: 4
fmt.Println("b:", b, " &b[0]:", &b[0], " len:", len(b), " cap:", cap(b))
}
输出：
a: [10 20] &a[0]: 0xc000072140 len: 2 cap: 4 c: [10] &c[0]: 0xc000072140 len: 1 cap: 4 a: [10 1] &a[0]: 0xc000072140 len: 2 cap: 4 b: [10 1] &b[0]: 0xc000072140 len: 2 cap: 4
package main
import (
"fmt"
)
func main() {
a := make([]int, 2, 4)
a[0] = 10
a[1] = 20
//a: [10 20] &a[0]: 0x10410020 len: 2 cap: 4
fmt.Println("a:", a, " &a[0]:", &a[0], " len:", len(a), " cap:", cap(a))
//进行append操作
//append是在第一个元素后开始追加，所以要超过容量，至少要追加4个，而不是之前例子的3个
b := append(a[:1], 1, 2, 3, 4)
//a: [10 20] &a[0]: 0x10410020 len: 2 cap: 4
fmt.Println("a:", a, " &a[0]:", &a[0], " len:", len(a), " cap:", cap(a))
//b: [10 1 2 3 4] &b[0]: 0x10454020 len: 5 cap: 8
fmt.Println("b:", b, " &b[0]:", &b[0], " len:", len(b), " cap:", cap(b))
}
如果append的元素数较多，超过了原来的容量，直接采用了新的底层数组，也就不会影响到a了。
输出：
a: [10 20] &a[0]: 0xc0000105a0 len: 2 cap: 4 a: [10 20] &a[0]: 0xc0000105a0 len: 2 cap: 4 b: [10 1 2 3 4] &b[0]: 0xc000014240 len: 5 cap: 8
package main
import (
"fmt"
)
func testAppend(s []int) {
//进行append操作
s = append(s, 1)
//s: [10 1] &s[0]: 0x10410020 len: 2 cap: 4
fmt.Println("s:", s, " &s[0]:", &s[0], " len:", len(s), " cap:", cap(s))
}
func main() {
a := make([]int, 2, 4)
a[0] = 10
a[1] = 20
//a: [10 20] &a[0]: 0x10410020 len: 2 cap: 4
fmt.Println("a:", a, " &a[0]:", &a[0], " len:", len(a), " cap:", cap(a))
testAppend(a[:1])
//a: [10 1] &a[0]: 0x10410020 len: 2 cap: 4
fmt.Println("a:", a, " &a[0]:", &a[0], " len:", len(a), " cap:", cap(a))
}
输出：
a: [10 20] &a[0]: 0xc0000105a0 len: 2 cap: 4 s: [10 1] &s[0]: 0xc0000105a0 len: 2 cap: 4 a: [10 1] &a[0]: 0xc0000105a0 len: 2 cap: 4
import (
"fmt"
)
func testAppend(s []int) {
//进行append操作
s = append(s, 1, 2, 3, 4)
//s: [10 1] &s[0]: 0x10410020 len: 2 cap: 4
fmt.Println("s:", s, " &s[0]:", &s[0], " len:", len(s), " cap:", cap(s))
}
func main() {
a := make([]int, 2, 4)
a[0] = 10
a[1] = 20
//a: [10 20] &a[0]: 0x10410020 len: 2 cap: 4
fmt.Println("a:", a, " &a[0]:", &a[0], " len:", len(a), " cap:", cap(a))
testAppend(a[:1])
//a: [10 1] &a[0]: 0x10410020 len: 2 cap: 4
fmt.Println("a:", a, " &a[0]:", &a[0], " len:", len(a), " cap:", cap(a))
}
输出
a: [10 20] &a[0]: 0xc0000105a0 len: 2 cap: 4 s: [10 1 2 3 4] &s[0]: 0xc000014240 len: 5 cap: 8 a: [10 20] &a[0]: 0xc0000105a0 len: 2 cap: 4
参考：
https://blog.golang.org/go-slices-usage-and-internals