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的切片。(如果你留意过,你会发现makelen实现了重载。go语言的一些特性会让你有点失望,因为有些特性是没有暴露出来给开发者使用。)

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

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

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

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

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

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

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

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

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

切片scores的初始容量是5。但是为了容纳20个元素,切片的容量必须扩展3次,分别是12、24和48(译者注:原文不是12、24和48,而是10、20和40)。

作为最后一个例子,思考一下:

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

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

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

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

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

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

func extractPowers(saiyans []*Saiyans) []int {
    powers := make([]int, len(saiyans))
    for index, saiyan := range saiyans {
    powers[index] = saiyan.Power
    }
    return powers
}

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

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

func extractPowers(saiyans []*Saiyans) []int {
    powers := make([]int, 0, len(saiyans))
    for _, saiyan := range saiyans {
        powers = append(powers, saiyan.Power)
    }
    return powers
}

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

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

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

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

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

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

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

在go中,我们使用切片:

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

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

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

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

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

func removeAtIndex(source []int, index int) []int {
    lastIndex := len(source) - 1
    //swap the last value and the value we want to remove
    source[index], source[lastIndex] = source[lastIndex], source[index]
    return source[:lastIndex]
}

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

import (
    "fmt"
    "math/rand"
    "sort"
)

func main() {
    scores := make([]int, 100)
    for i := 0; i < 100; i++ {
        scores[i] = int(rand.Int31n(1000))
    }
    sort.Ints(scores)
    worst := make([]int, 5)
    copy(worst, scores[:5])
    fmt.Println(worst)
}

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

链接

powered by Gitbook该教程制作时间: 2016-08-05 22:58:44