• 3.2 切片
    • 链接

    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。

    链接

    • 目录
    • 上一节：数组
    • 下一节：映射