如果说GO语言的数组为静态长度的数组，那么切片（slice）则为动态长度的数组

一、基于数组创建切片

1、存在一个整型数组intArr := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}，那么下面的slice就是数组切片

var slice []int = intArr[3:7]

从图中可以看出切片从数组的第4个元素开始读取数据，直至第8个元素（但不包含第8个）。切记程序员的计数都是从0开始的哟

2、若只读intArr数组的前4个元素，该如何办呢？聪明的你一定能想到

var slice [] int = intArr[0:4]

或者

slice := intArr[0:4]

3、是否还有更简洁的表示吗？那肯定了，GO这么懂程序员

slice := intArr[:4]，它与slice := intArr[0:4]等价

4、哪些读取intArr数组第4个元素（包含第4个元素）之后的所有数据呢？

slice := intArr[3:10]

当然也可以如下表示

slice := intArr[3:len(intArr)]

或者

slice := intArr[3:]

二、基于数组创建的切片与该数组的关系

上例中基于数组intArr创建了切片slice，那么slice与intArr有什么关系呢？可以简单地理解为切片是在数组的基础上增加了一些管理功能，很类型C++中的数组与std::vector的关系。

intArr := [10]int{1,2,3,4,5,6,7,8,9,10} // 定义数组intArr

var slice []int = intArr[3:7]        // 基于intArr创建切片 

fmt.Printf("intArr的地址是: %p\n", &intArr) 

fmt.Printf("slice的地址是 : %p\n", &slice)

fmt.Printf("intArr的第4个元素地址是: %p\n", &intArr[3])

fmt.Printf("slice的第1个元素地址是 : %p\n", &slice[0])

从程序运行结果上可以看切片slice和数组intArr两者没有任何关系，是不同的内在地址；但有意思的是切片slice的第一个元素地址恰恰是数组intArr的第4个元素地址，这不是巧合，而是切片的实质

所以有人也说切片是指向数组的指针，对切片元素的更改会影响数组元素的值，这个通过改写上面示例可以得到验证：

intArr := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

slice := intArr[3:]

slice[0] = 100 // 更改切片的第1个元素值为100

fmt.Println("slice=", slice)

fmt.Println("intArr=", intArr)

三、基于切片创建切片

能否基于切片创建切片呢？答案是肯定的，其使用方法与基于数组创建切片相同

intArr := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

slice := intArr[3:]

reslice := slice[1:]

fmt.Println(reslice)

由于slice是基于数组intArr创建的切片，它从intArr的第4个值开始，所以slice的值为[4,5,6,7,8,9,10]； 而reslice是基于切片slice创建的切片，它从slice的第2个值开始，所以reslice的值为[5,6,7,8,9,10]

四、直接创建切片

并不是非得基于数组或者切片才能创建切片，GO语言很贴心地为程序员提供了make()函数，其形式为slice := make([] type, number, capacity)，例如：

slice := make([]int, 3, 10)

1、number和capacity分别是什么意思？

number是切片元素个数，创建切片slice之后，里面有几个元素；capacity表示切片的容量，创建切片slice之后，先预留10个元素的存储空间。运行上面例子便能理解：

从结果上来看，切片slice元素个数为3，且元素缺省填充为0；由于切片slice的容量为10，所以还可以向切片追加7个元素。

2、len()和cap()

切片有len()和cap()函数，分别用来获取切片的元素个数和容量值，例如：

slice := make([]int, 3, 10)

num := len(slice)

capacity := cap(slice)

fmt.Println("切片slice元素个数为:", num, "，容量为:", capacity)

3、能省略容量吗？

答案是OK的，所以可以这样声明切片：slice := make([]int,3)

那么此时它的容量与元素个数相同，即为3

4、能把元素个数和容量都省略变为slice := make([]int)可行吗？

答案是NO，此时GO语言就晕了，它在想难道程序员让我把所有内存都占用？就抛出missing len argument to make([]int)错误信息

5、只有类型和容量，省略元素个数呢，类似slice := make([]int,,10)

答案是NO，但可以声明后直接初始化，即slice := []int{1,2,3,4,5,6}

6、如何追加元素？

slice := make([]int, 3, 10)

fmt.Println("切片slice元素个数为:", len(slice), ",容量为:", cap(slice), ",slice=", slice)

可以这样追加：

slice = append(slice, 4)

slice = append(slice, 5)

也可以这样追加：

slice = append(slice, 6, 7, 8)

甚至可以追加一个切片，但在后面必须添加...：

arr := [2]int{9, 10}

slice = append(slice, arr...)

程序运行追加后的结果如下：

五、切片追加元素后切片是否重新生成？

1、追加说明

slice := make([]int, 3, 10) // 声明一个切片

fmt.Printf("原切片的地址%p\n", &slice)

fmt.Printf("原切片第一个元素的地址%p\n", &slice[0])

slice = append(slice, 4)  // 追加一个元素

fmt.Printf("新切片的地址%p\n", &slice)

fmt.Printf("新切片第一个元素的地址%p\n", &slice[0])

从运行结果上可以看到，追加一个元素后，切片元素的地址并没有发生变化；但在应用时必须返回值赋给slice，即下面的程序是错误的：

slice := make([]int, 3, 10) 

append(slice, 4) // 必须返回slice

fmt.Printf("%p\n", &slice)

2、追加超过容量大小

slice := make([]int, 3, 10)                   // 切片容量为10

fmt.Printf("%p\n", &slice)                    // 打印切片地址

fmt.Println("len:", len(slice), "cap:", cap(slice))   // 打印切片元素个数和容量

slice = append(slice, 4, 5, 6, 7, 8, 9, 10, 11)      // 切片追加元素

fmt.Printf("%p\n", &slice)                    // 打印切片地址

fmt.Println("len:", len(slice), "cap:", cap(slice))   // 打印切片元素个数和容量

这个例子中一开始声明了容量为10的切片，当向切片中追加元素时，使其元素个数超过容量，此时切片会自动扩展容量一倍变为20，这点与Java的集合很相似

本文出自 “青客” 博客，请务必保留此出处http://qingkechina.blog.51cto.com/5552198/1616987