3.2 切片

在go中，你一般很少直接使用数组。相反，你会使用切片。切片是一个轻量级的结构体封装，这个结构体被封装后，代表一个数组的一部分。这里指出了一些创建切片的方式，并指出我们以后会在何时使用这些方式。

第一种方式和我们创建一个数组时有点细微的变化：

scores := []int{1,4,293,4,9}

和声明数组不同的是，声明切片不需要在方括号中指定其大小。理解2中不同的方式创建切片，下面使用另外一种方式创建切片，这里使用make：

scores := make([]int, 10)

我们使用make，没有使用new，是因为创建一个切片不仅仅是分配一段内存（new只能分配一段内存）。需要特别指出的是，我们需要为底层数组分配内存，并且也要初始化这个切片。在上面的例子中，我们初始化了一个长度和容量都是10的切片。长度表示切片的长度，容量表示底层数组的大小。在使用make创建切片时，我们可以分别的指定长度和容量大小：

scores := make([]int, 0, 10)

上面创建了一个长度为0但是容量为10的切片。（如果你留意过，你会发现make和len实现了重载。go语言的一些特性会让你有点失望，因为有些特性是没有暴露出来给开发者使用。）

要更好的理解切片长度和容量之间的相互作用，让我们看下面的例子：

  1. func main() {
  2.     scores := make([]int, 0, 10)
  3.     scores[5] = 9033
  4.     fmt.Println(scores)
  5. }

上面的例子不能运行。为什么？因为我们创建的切片长度是0。是的，这个底层的数组有10个元素。但是为了访问切片元素，我们需要明确的扩展切片。一种扩展切片的方式是使用append：

  1. func main() {
  2.     scores := make([]int, 0, 10)
  3.     scores = append(scores, 5)
  4.     fmt.Println(scores) // 打印：[5]
  5. }

但是这改变为了我们之前代码的意图。当往一个长度为0的切片上添加元素时，这个元素会被赋值给切片的第一个元素。不管出于什么原因，那段不能运行的代码想给切片的第6个元素赋值。为了到达这个目的，我们可以再切分一直我们的切片：

  1. func main() {
  2.     scores := make([]int, 0, 10)
  3.     scores = scores[0:6]
  4.     scores[5] = 9033
  5.     fmt.Println(scores)
  6. }

调整切片的大小上限是多少？这个上限就是切片的容量大小，在上面的例子中，上限是10。你也许会认为，这实际没有解决定长数组的问题。事实证明，append比较特殊。如果底层的数组已经达到上限，append会重新创建一个更大的数组，并将所有的值复制过去（这就是动态数组的工作原理，例如php、python、ruby和javascript等等）。这就是为什么我们在上面的例子中使用append。我们必须将append返回的值重新赋予给scores变量：如果原始切片没有更多的空间时，append可能会创建一个新值。

如果我告诉你go扩展数组使用的是2倍算法（2x algorithm）。你能猜出下面代码将输出什么吗？

  1. func main() {
  2.     scores := make([]int, 0, 5)
  3.     c := cap(scores)
  4.     fmt.Println(c)
  5.     for i := 0; i < 25; i++ {
  6.         scores = append(scores, i)
  7.         // 如果容量已经改变，go为了容下这些新数据，不得不增长数组的长度        
  8.         if cap(scores) != c {
  9.         c = cap(scores)
  10.         fmt.Println(c)
  11.         }
  12.     }
  13. }

切片scores的初始容量是5。但是为了容纳20个元素，切片的容量必须扩展3次，分别是10、20和40。

作为最后一个例子，思考一下：

  1. func main() {
  2.     scores := make([]int, 5)
  3.     scores = append(scores, 9332)
  4.     fmt.Println(scores)
  5. }

当面的代码输出是[0, 0, 0, 0, 0, 9332]。也许你认为应该是[9332, 0, 0, 0, 0]。对人类来说，这似乎更合乎逻辑。但是对于编译器来说，你是要告诉它往一个已经拥有5个元素的切片添加一个值。

最后，这里提供了4种常用的方式去初始化一个切片：

  1. names := []string{"leto", "jessica", "paul"}
  2. checks := make([]bool, 10)
  3. var names []string
  4. scores := make([]int, 0, 20)

你该使用哪一个？第一种你不需要太多的说明。但是使用这种方式你得提前知道你想往数组存放的值。

第二种方式在你想往切片的特定位置写入一个值时很有用，例如：

  1. func extractPowers(saiyans []*Saiyans) []int {
  2.     powers := make([]int, len(saiyans))
  3.     for index, saiyan := range saiyans {
  4.     powers[index] = saiyan.Power
  5.     }
  6.     return powers
  7. }

第三种方式会返回一个空切片，一般和append一起使用，此时切片的元素数量是未知的。

最后一种方式可以让我们指定切片的初始容量。当我们大概知道需要多少元素时很有用。即使你知道元素的个数，append也能被使用，这主要取决于个人喜好：

  1. func extractPowers(saiyans []*Saiyans) []int {
  2.     powers := make([]int, 0, len(saiyans))
  3.     for _, saiyan := range saiyans {
  4.         powers = append(powers, saiyan.Power)
  5.     }
  6.     return powers
  7. }

切片作为一个数组的封装是一个非常有用的概念。很多语言都有类似的概念。javascript和ruby的数组都有一个slice方法。你也可以在ruby中通过[START..END]得到一个切片，或者在python中通过[START:END]得到一个切片。然而，在一些语言中，切片确实是从原始数组拷贝而来的新数组。如果我们使用ruby，下面代码将输出什么？

  1. scores = [1,2,3,4,5]
  2. slice = scores[2..4]
  3. slice[0] = 999
  4. puts scores

答案是[1, 2, 3, 4, 5]。因为切片slice是由值拷贝组成的一个全新数组。现在，同等情况下看go：

  1. scores := []int{1,2,3,4,5}
  2. slice := scores[2:4]
  3. slice[0] = 999
  4. fmt.Println(scores)

输出是[1, 2, 999, 4, 5]。

这会如何改变你的代码。例如，很多函数需要一个位置参数。在javascript中，如你我们想在前五个字符后查找一个字符串中的第一个空白符（对，切片也当字符串处理），我们可以这样写：

  1. haystack = "the spice must flow";
  2. console.log(haystack.indexOf(" ", 5));

在go中，我们使用切片：

strings.Index(haystack[5:], " ")

从上面例子中，我们可以看出[X:]表示X到结尾的一种缩写。而[:X]是开始到X的一种缩写。不像其他语言，go不支持负值索引。如果我们想要切片所有元素，但除了最后一个，我们可以这样写：

  1. scores := []int{1, 2, 3, 4, 5}
  2. scores = scores[:len(scores)-1]

上述是一种从一个乱序的切片中去除一个值的有效方法。

  1. func main() {
  2.     scores := []int{1, 2, 3, 4, 5}
  3.     scores = removeAtIndex(scores, 2)
  4.     fmt.Println(scores)
  5. }
  7. func removeAtIndex(source []int, index int) []int {
  8.     lastIndex := len(source) - 1
  9.     //swap the last value and the value we want to remove
  10.     source[index], source[lastIndex] = source[lastIndex], source[index]
  11.     return source[:lastIndex]
  12. }

最后，我们已经学习了切片，我们来学习一下另外一个常用的内置函数：copy。copy是众多函数中重点显示出切片如何改变我们代码方式的函数之一。正常情况下，拷贝一个数组到另外一个数组的方法需要5个参数：source，sourceStart，count，destination和destinationStart。但是在切片中，我们只需要2个参数：

  1. import (
  2.     "fmt"
  3.     "math/rand"
  4.     "sort"
  5. )
  7. func main() {
  8.     scores := make([]int, 100)
  9.     for i := 0; i < 100; i++ {
  10.         scores[i] = int(rand.Int31n(1000))
  11.     }
  12.     sort.Ints(scores)
  13.     worst := make([]int, 5)
  14.     copy(worst, scores[:5])
  15.     fmt.Println(worst)
  16. }

花点时间研究上面的代码。试着改变一些代码。如果你使用copy(worst[2:4], scores[:5])方式去复制看看会发生什么，或者试着复制多于或者少于5个值到worst。

链接