Go 语言中的两种 slice 表达式

本文只是关注于 slice 的表示方式，它们可以创建两种类型的值:

截断的 string

指向 array 或者 slice 的指针

Go语言对 slice有两种表示方式：简略表达式与完整表达式。

简略表达式

Slice 的简略表达式是：

1 Input[low:high]

其中，low和 high是 slice 的索引(index)，其数值必须是整数，它们指定了输入操作数(Input)的哪些元素可以被放置在结果的slice中。输入操作数可以是 string，array，或者是指向 array或slice 的指针。结果 slice 的长度就是 high-low。如下例所示：

1 numbers := [10]int{0,1,2,3,4,5,6,7,8,9}2 s := numbers[2:4:6]3 fmt.Println(s) // [2, 3]4 fmt.Println(cap(s)) // 4

将 slice 表达式应用到 array 的指针中，这是第一次取消对该指针的引用，然后以常规的方式应用 slice 表达式。将 slice 表达式应用于数组的指针，是先解引用该指针，然后按常规方式应用切片表达式的简写形式。

1 numbers := [5]int{1, 2, 3, 4, 5}2 fmt.Println((&numbers)[1:3]) // [2, 3]

Slice 的索引low 和high 可以省略，low 的默认值是0，high 的默认值为slice 的长度：

1 fmt.Println("foo"[:2]) // "fo"2 fmt.Println("foo"[1:]) // "oo"3 fmt.Println("foo"[:]) // "foo"

但是 slice 的索引不可以是以下几种类型的值：

1 low < 0 or high < 02 low <= high3 high <= len(input)4 fmt.Println("foo"[-1:]) // invalid slice index -1 (index must be non-negative)5 //fmt.Println("foo"[:4]) // invalid slice index 4 (out of bounds for 3-byte string)6 fmt.Println("foo"[2:2]) // ""(blank)7 //fmt.Println("foo"[2:1]) // invalid slice index: 2 > 1

否则，即使一个超过slice 范围的索引不能在编译的时候被检测到，那么在运行时就会发生一个panic 。

1 func low() int {2 return 43 }4 5 func main() {6 fmt.Println("foo"[low():])7 }8 panic: runtime error: slice bounds out of range910 goroutine 1 [running]:11 panic(0x102280, 0x1040a018)12 /usr/local/go/src/runtime/panic.go:500 +0x72013 main.main()14 /tmp/sandbox685025974/main.go:12 +0x120

完整表达式这种方法可以控制结果 slice 的容量，但是只能用于 array 和指向 array 或 slice 的指针（string 不支持），在简略表达式中结果 slice 的容量是从索引low开始的最大可能容量（slice 的简略表达式）：

1 numbers := [10]int{0,1,2,3,4,5,6,7,8,9}2 s := numbers[1:4]3 fmt.Println(s) // [1, 2, 3]4 fmt.Println(cap(s)) // 9

对于一个 array 来说，cap(a) == len(a) 在上面的代码片段中，s 的容量是 9，因为这个slice 从索引 1 开始，而底层 array 有 8 个元素（2 到 9）。完整的 slice 表达式允许修改这种默认行为，以如下代码为例：

1 numbers := [10]int{0,1,2,3,4,5,6,7,8,9}2 s := numbers[1:4:5]3 fmt.Println(s) // [1, 2, 3]4 fmt.Println(cap(s)) // 4

完整的 slice 表达式具有以下的形式：

1 input[low:high:max]

索引 low 和索引 high 的含义和工作方式与简略表达式相同。唯一的区别是 max 将结果slice 的容量设置为 max-low。

1 numbers := [10]int{0,1,2,3,4,5,6,7,8,9}2 s := numbers[2:4:6]3 fmt.Println(s) // [2, 3]4 fmt.Println(cap(s)) // 4

当 slice 的输入操作数是一个 slice 时，结果 slice 的容量取决于输入操作数，而不是它的指向的底层 array：

1 numbers := [10]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}2 fmt.Println(cap(numbers)) // 103 s1 := numbers[1:4]4 fmt.Println(s1) // [1, 2, 3]5 fmt.Println(cap(s1)) // 96 s2 := numbers[1:4:5]7 fmt.Println(s2) // [1, 2, 3]8 fmt.Println(cap(s2)) // 49 s3 := s2[:]10 fmt.Println(s3) // [1, 2, 3]11 fmt.Println(cap(s3)) // 4

这个例子中 s3 的容量不能超过 s2 的容量 (4)，即使它指向的 array 有 10 个元素，而且s1,s2,s3 都是从 1 开始的。

当输入操作数是 slice 时，完整表达式的索引 hight 不能超过其 cap(input)

1 numbers := [10]int{0,1,2,3,4,5,6,7,8,9}2 s1 := numbers[0:1]3 fmt.Println(s1) // [0]4 fmt.Println(len(s1)) // 15 fmt.Println(cap(s1)) // 106 s2 := numbers[0:5]7 fmt.Println(s2) // [0, 1, 2, 3, 4]8 fmt.Println(cap(s1)) // 10

另外，对于它的 max 取值，有两个额外的规则

1 high <= max2 max <= cap(input)3 numbers := [10]int{0,1,2,3,4,5,6,7,8,9}4 s1 := numbers[0:1]5 s2 := numbers[0:5:11] // invalid slice index 11 (out of bounds for 10-element array)6 fmt.Println(s1, s2)

在完整的 slice 表达式中低索引(low)是可以省略的

1 numbers := [10]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}2 s := numbers[:4:6]3 fmt.Println(s) // [0, 1, 2, 3]4 fmt.Println(cap(s)) // 6

然而，不能省略略高索引(hight)

1 numbers := [10]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}2 s1 := numbers[:4:6]3 s2 := s1[::5]4 fmt.Println(s2)5 fmt.Println(cap(s2))

否则，代码会在编译时报错middle index required in 3-index slice

原文链接：

via: https://medium.com/golangspec/slice-expressions-in-go-963368c20765作者：Michał Łowicki 译者：bizky 校对：polaris1119