Go基础：slice的介绍与使用

本文从三个方面讲解slice：

• slice的介绍：包括切片的概念、构成与基本操作。
• append()函数的介绍，还从源码层面分析了slice扩容策略。
• slice的使用示例，涵盖了slice的日常使用。

介绍

本小节从下面六个方面介绍了slice的基本内容：

• 切片的概念
• 切片的构成
• 切片的操作
• 切片的初始化
• 切片的比较
• 切片的零值

切片的概念

slice(切片)代表变长的序列，序列中每个元素都有相同的类型。

一个slice类型一般写作[]T，其中T代表slice中元素的类型。

slice的语法和数组很像，只是没有固定长度而已。

数组和slice之间有着紧密的联系。一个slice是一个轻量级的数据结构，提供了访问数组子序列
（或者全部）元素的功能，slice的底层引用一个数组对象。

切片的构成

一个slice由三个部分构成：指针、长度和容量。

指针指向第一个slice元素对应的底层数组元素的地址，要注意的是slice的第一个元素并不一定就是数组的第一个元素。

长度对应slice中元素的数目；长度不能超过容量，容量一般是从slice的开始位置到底层数据的结尾位置。

内置的len()和cap()函数分别返回slice的长度和容量。

多个slice之间可以共享底层的数据，并且引用的数组部分区间可能重叠。

切片的操作

slice的切片操作s[i:j]，其中0 ≤ i≤ j≤ cap(s)，用于创建一个新的slice，引用s的从第i个元素开始到第j-1个元素的子序列。新的slice只有j-i个元素。

如果i位置的索引被省略的话将使用0代替。

如果j位置的索引被省略的话将使用len(s)代替

如果切片操作超出cap(s)的上限将导致一个panic异常，但是超出len(s)则是意味着扩展了slice，因为新slice的长度会变大。

另外，字符串的切片操作和[]byte字节类型切片的切片操作是类似的。都写作x[m:n]，并且都是返回一个原始字节系列的子序列，底层都是共享之前的底层数组，因此这种操作都是常量时间复杂度。x[m:n]切片操作对于字符串生成一个新字符串。

因为slice值包含指向第一个slice元素的指针，因此向函数传递slice将允许在函数内部修改底层数组的元素。换句话说，复制一个slice只是对底层的数组创建了一个新的slice别名。

切片的初始化

slice类型的变量s和数组类型的变量a的初始化语法的差异。slice和数组的字面值语法很类似，它们都是用花括弧包含一系列的初始化元素，但是对于slice并没有指明序列的长度。这会隐式地创建一个合适大小的数组，然后slice的指针指向底层的数组。就像数组字面值一样，slice的字面值也可以按顺序指定初始化值序列，或者是通过索引和元素值指定，或者用两种风格的混合语法初始化。

切片的比较

和数组不同的是，slice之间不能比较，因此我们不能使用==操作符来判断两个slice是否含有全部相等元素。不过标准库提供了高度优化的bytes.Equal函数来判断两个字节型slice是否相等([]byte)，但是对于其他类型的slice，我们必须自己定义函数来比较每个元素。

slice唯一合法的比较操作是和nil比较。

切片的零值

一个零值的slice等于nil。一个nil值的slice并没有底层数组。一个nil值的slice的长度和容量都是0，但是也有非nil值的slice的长度和容量也是0的，例如[]int{}或make([]int, 3)[3:]。与任意类型的nil值一样，我们可以用[]int(nil)类型转换表达式来生成一个对应类型slice的nil值。

如果你需要测试一个slice是否是空的，使用·len(s) == 0·来判断，而不应该用s == nil来判断。除了和nil相等比较外，一个nil值的slice的行为和其它任意0长度的slice一样；例如reverse(nil)也是安全的。除了文档已经明确说明的地方，所有的Go语言函数应该以相同的方式对待nil值的slice和0长度的slice。

内置的make函数创建一个指定元素类型、长度和容量的slice。容量部分可以省略，在这种情况下，容量将等于长度。

make([]T, len)
make([]T, len, cap) // 等价于 make([]T, cap)[:len]
复制代码

在底层，make创建了一个匿名的数组变量，然后返回一个slice；只有通过返回的slice才能引用底层匿名的数组变量。在第一种语句中，slice是整个数组的view。在第二个语句中，slice只引用了底层数组的前len个元素，但是容量将包含整个的数组。额外的元素是留给未来的增长用的。

append()

• append()函数介绍
• 切片扩容策略源码分析

append()介绍

内置的append()函数用于向slice追加元素。

slice = append(slice, elem1, elem2)
slice = append(slice, anotherSlice...)
复制代码

我们并不知道append()函数的调用是否导致了内存的重新分配，因此我们不能确认新的slice和原始的slice是否引用的是相同Slice的底层数组空间。同样，我们不能确认在原先的slice上的操作是否会影响到新的slice**。因此，通常是将append()返回的结果直接赋值给输入的slice变量。**

更新slice变量不仅对调用append函数是必要的，实际上对应任何可能导致长度、容量或底层数组变化的操作都是必要的。要正确地使用slice，需要记住尽管底层数组的元素是间接访问的，但是slice对应结构体本身的指针、长度和容量部分是直接访问的。从这个角度看，slice并不是一个纯粹的引用类型。

切片扩容策略

这个地方贴一段slice扩容策略的代码，这段代码来Go 1.16版本源码中runtime包下的slice.go里：

newcap := old.cap
doublecap := newcap + newcap
if cap > doublecap {
    newcap = cap
} else {
    if old.cap < 1024 {
        newcap = doublecap
    } else {
        // 检查 0 < newcap 来防止上溢出
        // 且避免无限循环
        for 0 < newcap && newcap < cap {
            newcap += newcap / 4
        }
        // 上溢出检测
        if newcap <= 0 {
            newcap = cap
        }
    }
}
复制代码

这个地方稍微介绍一下几个关键的变量：

• cap：growslice()函数的输入参数，用来指定扩容之后的最小容量。
• newcap：经过计算后，实际扩容后的容量。

从这段扩容代码中可以看出，扩容策略如下：

1. 当指定的扩容后的最小容量大于当前容量的两倍时，直接扩容。
2. 否则，在当前容量小于1024时，扩容两倍。
3. 以上均不满足的时候，容量以当前容量的1.25倍指数增长，直到大于指定后的最小容量。
4. 若以第三种扩容方式，导致newcap上溢出，那么将扩容至指定的最小容量cap。

使用

本小结从以下八个方面展示了切片的使用示例：

• 创建切片
• 使用切片
• 切片增长
• 创建切片时的3个索引
• 迭代切片
• 多维切片
• 函数间传递切片
• 模拟栈

创建切片

make

一种创建切片的方法是使用内置的make()函数。需要传入一个参数指定切片的长度：

slice := make([]int, 5)
复制代码

如果只指定长度，那么切片的容量和长度相等。也可以分别指定长度和容量：

slice := make([]int, 3, 5)
复制代码

分别指定长度和容量时，创建的切片，底层数组的长度是指定的容量，但是初始化后并不能访问所有的数组元素。

切片字面量

另一种常用的创建切片的方法是使用切片字面量：

slice := []int{1, 2, 3, 4, 5}
复制代码

这种方法和创建数组类似，只是不需要指定[]运算符里的值。初始的长度和容量会基于初始化时提供的元素的个数确定。

使用索引创建切片

slice := []int{3: 1}
复制代码

创建一个整型切片，注意大括号里面用的是冒号:，而不是逗号,。这种初始化方式会将前面3个元素以零值的方式初始化，1则被赋值到第4个元素。

与数组的区别

slice := []int{1, 2, 3}
array := [3]int{1, 2, 3}
复制代码

如果在[]运算符里指定了一个值，那么创建的就是数组而不是切片。只有不指定值的时候，才会创建切片。

nil切片

在 Go 语言里，nil 切片是很常见的创建切片的方法。nil 切片可以用于很多标准库和内置函数。在需要描述一个不存在的切片时，nil 切片会很好用。例如，函数要求返回一个切片但是发生异常的时候。

var slice []int
复制代码

空切片

利用初始化，通过声明一个切片可以创建一个空切片。

slice := make([]int, 0)
slice := []int{}
复制代码

空切片在底层数组包含0 个元素，也没有分配任何存储空间。想表示空集合时空切片很有用，例如，数据库查询返回0个查询结果时。

不管是使用 nil 切片还是空切片，对其调用内置函数append()、len() 和cap() 的效果都是一样的。

使用切片

使用切片创建切片

slice := []int{1, 2, 3, 4, 5}
newSlice := slice[1:3]
复制代码

两个切片共享同一段底层数组，但是通过不同的切片会看到底层数组的不同部分。

长度和容量

对底层数组容量是k的切片slice[i:j]来说：

• 长度: j - i
• 容量: k - i

修改切片内容

newSlice[1] = 9
复制代码

把9赋值给newSlice的第二个元素(索引为1的元素)的同时也是在修改原来的slice的第三个元素(索引为2)。

越界访问

切片只能访问到其长度内的元素。试图访问超出其长度的元素将会导致语言运行时异常。与切片的容量相关联的元素只能用于增长切片。在使用这部分元素前，必须将其合并到切片的长度里。

newSlice[3] = 9

// Runtime Exception:
// panic: runtime error: index out of range
复制代码

切片增长

相对于数组而言，使用切片的一个好处是，可以按需增加切片的容量。Go 语言内置的append()函数会处理增加长度时的所有操作细节。

要使用 append，需要一个被操作的切片和一个要追加的值。当append()调用返回时，会返回一个包含修改结果的新切片。函数append()总是会增加新切片的长度，而容量有可能会改变，也可能不会改变，这取决于被操作的切片的可用容量。

不发生扩容时

slice := []int{1, 2, 3, 4, 5}
newSlice := slice[1:3]
newSlice = append(newSlice, 9)

// slice : [1, 2, 3, 9, 5]
// newSlice : [2, 3, 9]
复制代码

因为newSlice在底层数组里还有额外的容量可用，append 操作将可用的元素合并到切片的长度，并对其进行赋值。由于和原始的slice 共享同一个底层数组，slice 中索引为3 的元素的值也被改动了。

发生扩容时

如果切片的底层数组没有足够的可用容量，append()函数会创建一个新的底层数组，将被引用的现有的值复制到新数组里，再追加新的值。

slice := []int{1, 2, 3, 4}
newSlice := append(slice, 5)

// slice : [1, 2, 3, 4]
// newSlice : [1, 2, 3, 4, 5]
复制代码

具体扩容策略见append()章节中的详解。

创建切片时的3个索引

在创建切片时，还可以使用之前我们没有提及的第三个索引选项。第三个索引可以用来控制新切片的容量。其目的并不是要增加容量，而是要限制容量。允许限制新切片的容量为底层数组提供了一定的保护，可以更好地控制追加操作。

source := []string{"Apple", "Orange", "Plum", "Banana", "Grape"}
slice := source[2:3:4]
复制代码

• 长度：j - i 即 3 - 2 = 1
• 容量：k - i 即 4 - 2 = 2

如果试图设置的容量比可用的容量还大，就会得到一个语言运行时错误。

slice := source[2:3:6]
// Runtime Error:
// panic: runtime error: slice bounds out of range
复制代码

我们之前讨论过，内置函数append()会首先使用可用容量。一旦没有可用容量，会分配一个新的底层数组。这导致很容易忘记切片间正在共享同一个底层数组。一旦发生这种情况，对切片进行修改，很可能会导致随机且奇怪的问题。对切片内容的修改会影响多个切片，却很难找到问题的原因。

如果在创建切片时设置切片的容量和长度一样，就可以强制让新切片的第一个append操作创建新的底层数组，与原有的底层数组分离。新切片与原有的底层数组分离后，可以安全地进行后续修改。

source := []string{"Apple", "Orange", "Plum", "Banana", "Grape"}
slice := source[2:3:3]
slice = append(slice, "Kiwi")
复制代码

如果不加第三个索引，由于剩余的所有容量都属于 slice，向slice 追加Kiwi 会改变原有底层数组索引为3 的元素的值Banana。不过在代码清单4-36 中我们限制了slice 的容量为1。当我们第一次对slice 调用append 的时候，会创建一个新的底层数组，这个数组包括2 个元素，并将水果Plum 复制进来，再追加新水果Kiwi，并返回一个引用了这个底层数组的新切片。

因为新的切片slice 拥有了自己的底层数组，所以杜绝了可能发生的问题。我们可以继续向新切片里追加水果，而不用担心会不小心修改了其他切片里的水果

迭代切片

既然切片是一个集合，可以迭代其中的元素。Go 语言有个特殊的关键字range，它可以配合关键字for 来迭代切片里的元。

slice := []int{10, 20, 30, 40}
for index, value := range slice {
	fmt.Printf("Index: %d Value: %d\n", index, value)
}

// 输出:
// Index: 0 Value: 10
// Index: 1 Value: 20
// Index: 2 Value: 30
// Index: 3 Value: 40
复制代码

当迭代切片时，关键字range会返回两个值。第一个值是当前迭代到的索引位置，第二个值是该位置对应元素值的一份副本。

需要强调的是，range 创建了每个元素的副本，而不是直接返回对该元素的引用。如果使用该值变量的地址作为指向每个元素的指针，就会造成错误。

slice := []int{10, 20, 30, 40}
for index, value := range slice {
	fmt.Printf("Value: %d Value-Addr: %X ElemAddr: %X\n", value, &value, &slice[index])
}

// 输出：
// Value: 10 Value-Addr: 10500168 ElemAddr: 1052E100
// Value: 20 Value-Addr: 10500168 ElemAddr: 1052E104
// Value: 30 Value-Addr: 10500168 ElemAddr: 1052E108
// Value: 40 Value-Addr: 10500168 ElemAddr: 1052E10C
复制代码

因为迭代返回的变量是一个迭代过程中根据切片依次赋值的新变量，所以value的地址总是相同的。要想获取每个元素的地址，可以使用切片变量和索引值。

如果不需要索引值，可以使用占位字符来忽略这个值。

slice := []int{10, 20, 30, 40}
for _, value := range slice {
	fmt.Printf("Value: %d\n", value)
}
// 输出:
// Value: 10
// Value: 20
// Value: 30
复制代码

关键字 range 总是会从切片头部开始迭代。如果想对迭代做更多的控制，依旧可以使用传统的for循环。

slice := []int{10, 20, 30, 40}
for index := 2; index < len(slice); index++ {
	fmt.Printf("Index: %d Value: %d\n", index, slice[index])
}
// 输出:
// Index: 2 Value: 30
复制代码

有两个特殊的内置函数len()和cap()，可以用于处理数组、切片和通道。对于切片，函数len()返回切片的长度，函数cap()返回切片的容量。

多维切片

slice := [][]int{{10}, {100, 200}}
slice[0] = append(slice[0], 20)
复制代码

Go 语言里使用append 函数处理追加的方式很简明：先增长切片，再将新的整型切片赋值给外层切片的第一个元素。

函数间传递切片

在函数间传递切片就是要在函数间以值的方式传递切片。由于切片的尺寸很小，在函数间复制和传递切片成本也很低。让我们创建一个大切片，并将这个切片以值的方式传递给函数foo()。

slice := make([]int, 1e6)
slice = foo(slice)
func foo(slice []int) []int {}
复制代码

在 64 位架构的机器上，一个切片需要24字节的内存：指针字段需要8字节，长度和容量字段分别需要8字节。由于与切片关联的数据包含在底层数组里，不属于切片本身，所以将切片复制到任意函数的时候，对底层数组大小都不会有影响。复制时只会复制切片本身，不会涉及底层数组。

模拟栈

我们可以用append()函数和切片操作来模拟一个栈的进栈与出栈操作。

stack := make([]int, 0)

stack = append(stack, 1)
stack = append(stack, 2)
stack = append(stack, 3)
stack = append(stack, 4)

for len(stack) > 0 {
    top := stack[len(stack) - 1]
    stack = stack[:len(stack) - 1]
    fmt.Printf("%v, ", top)
}

// 输出：
// 4, 3, 2, 1,
复制代码