切片

数组作为最基本同构类型在Go语言中被保留了下来,但数组在使用上确有两点不足:固定的元素个数,以及传值机制下导致的开销较大。于是Go设计者们又引入了另外一种同构复合类型:切片(slice),来弥补数组的这两处不足。

切片和数组就像两个一母同胞的亲兄弟,长得像,但又各有各的行为特点。我们可以先声明并初始化一个切片变量看看:

var nums = []int{1, 2, 3, 4, 5, 6}

我们看到与数组声明相比,切片声明仅仅是少了一个“长度”属性。去掉“长度”这一束缚后,切片展现出更为灵活的特性,这些特性我们后面再分析。 虽然不需要像数组那样在声明时指定长度,但切片也有自己的长度,只不过这个长度不是固定的,而是随着切片中元素个数的变化而变化的。我们可以通过len函数获得切片类型变量的长度,比如上面那个切片变量的长度就是6:

fmt.Println(len(nums)) // 6

而且,通过Go内置函数append,我们可以动态地向切片中添加元素。当然,添加后切片的长度也就随之发生了变化,如下面代码所示:

nums = append(nums, 7) // 切片变为[1 2 3 4 5 6 7]
fmt.Println(len(nums)) // 7

到这里,我想你已经初步了解切片类型的一些基础信息了。我们前面也说,相比数组类型,切片展现了更为灵活的特性,这些特性是怎么样的呢?现在我们深入它的实现原理看看。

Go是如何实现切片类型的?

Go切片在运行时其实是一个三元组结构,它在Go运行时中的表示如下:

type slice struct {
    array unsafe.Pointer
    len   int
    cap   int
}

我们可以看到,每个切片包含三个字段:

Go编译器会自动为每个新创建的切片,建立一个底层数组,默认底层数组的长度与切片初始元素个数相同。我们还可以用以下几种方法创建切片,并指定它底层数组的长度。

方法一:通过make函数来创建切片,并指定底层数组的长度。 我们直接看下面这行代码:

sl := make([]byte, 6, 10) // 其中10为cap值,即底层数组长度,6为切片的初始长度

如果没有在make中指定cap参数,那么底层数组长度cap就等于len,比如:

sl := make([]byte, 6) // cap = len = 6

方法二:采用array[low : high : max]语法基于一个已存在的数组创建切片。这种方式被称为数组的切片化,比如下面代码:

arr := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
sl := arr[3:7:9]

基于数组创建的切片,它的起始元素从low所标识的下标值开始,切片的长度(len)是high - low,它的容量是max - low。而且,由于切片sl的底层数组就是数组arr,对切片sl中元素的修改将直接影响数组arr变量。比如,如果我们将切片的第一个元素加10,那么数组arr的第四个元素将变为14:

sl[0] += 10
fmt.Println("arr[3] =", arr[3]) // 14

这样看来, 切片好比打开了一个访问与修改数组的“窗口”,通过这个窗口,我们可以直接操作底层数组中的部分元素。这有些类似于我们操作文件之前打开的“文件描述符”(Windows上称为句柄),通过文件描述符我们可以对底层的真实文件进行相关操作。 可以说,切片之于数组就像是文件描述符之于文件。

在Go语言中,数组更多是“退居幕后”,承担的是底层存储空间的角色。切片就是数组的“描述符”,也正是因为这一特性,切片才能在函数参数传递时避免较大性能开销。因为我们传递的并不是数组本身,而是数组的“描述符”,而这个描述符的大小是固定的(见上面的三元组结构),无论底层的数组有多大,切片打开的“窗口”长度有多长,它都是不变的。此外,我们在进行数组切片化的时候,通常省略max,而max的默认值为数组的长度。

另外,针对一个已存在的数组,我们还可以建立多个操作数组的切片,这些切片共享同一底层数组,切片对底层数组的操作也同样会反映到其他切片中。

方法三:基于切片创建切片。

不过这种切片的运行时表示原理与上面的是一样的,我这里就不多分析了,你可以自己看一下。

这里我们要清楚一个概念:切片与数组最大的不同,就在于其长度的不定长,这种不定长需要Go运行时提供支持,这种支持就是切片的“动态扩容”。

切片的动态扩容

“动态扩容”指的就是,当我们通过append操作向切片追加数据的时候,如果这时切片的len值和cap值是相等的,也就是说切片底层数组已经没有空闲空间再来存储追加的值了,Go运行时就会对这个切片做扩容操作,来保证切片始终能存储下追加的新值。

接下来,我们再通过一个例子来体会一下切片动态扩容的过程:

var s []int
s = append(s, 11)
fmt.Println(len(s), cap(s)) //1 1
s = append(s, 12)
fmt.Println(len(s), cap(s)) //2 2
s = append(s, 13)
fmt.Println(len(s), cap(s)) //3 4
s = append(s, 14)
fmt.Println(len(s), cap(s)) //4 4
s = append(s, 15)
fmt.Println(len(s), cap(s)) //5 8

在这个例子中,我们看到,append会根据切片对底层数组容量的需求,对底层数组进行动态调整。具体我们一步步分析。

  1. 最开始,s初值为零值(nil),这个时候s没有“绑定”底层数组。我们先通过append操作向切片s添加一个元素11,这个时候,append会先分配底层数组u1(数组长度1),然后将s内部表示中的array指向u1,并设置len = 1, cap = 1;
  2. 接着,我们通过append操作向切片s再添加第二个元素12,这个时候len(s) = 1,cap(s) = 1,append判断底层数组剩余空间已经不能够满足添加新元素的要求了,于是它就创建了一个新的底层数组u2,长度为2(u1数组长度的2倍),并把u1中的元素拷贝到u2中,最后将s内部表示中的array指向u2,并设置len = 2, cap = 2;
  3. 然后,第三步,我们通过append操作向切片s添加了第三个元素13,这时len(s) = 2,cap(s) = 2,append判断底层数组剩余空间不能满足添加新元素的要求了,于是又创建了一个新的底层数组u3,长度为4(u2数组长度的2倍),并把u2中的元素拷贝到u3中,最后把s内部表示中的array指向u3,并设置len = 3, cap为u3数组长度,也就是4 ;
  4. 第四步,我们依然通过append操作向切片s添加第四个元素14,此时len(s) = 3, cap(s) = 4,append判断底层数组剩余空间可以满足添加新元素的要求,所以就把14放在下一个元素的位置(数组u3末尾),并把s内部表示中的len加1,变为4;
  5. 但我们的第五步又通过append操作,向切片s添加最后一个元素15,这时len(s) = 4,cap(s) = 4,append判断底层数组剩余空间又不够了,于是创建了一个新的底层数组u4,长度为8(u3数组长度的2倍),并将u3中的元素拷贝到u4中,最后将s内部表示中的array指向u4,并设置len = 5, cap为u4数组长度,也就是8。

到这里,这个动态扩容的过程就结束了。我们看到,append会根据切片的需要,在当前底层数组容量无法满足的情况下,动态分配新的数组,新数组长度会按一定规律扩展。在上面这段代码中,针对元素是int型的数组,新数组的容量是当前数组的2倍。新数组建立后,append会把旧数组中的数据拷贝到新数组中,之后新数组便成为了切片的底层数组,旧数组会被垃圾回收掉。 不过append操作的这种自动扩容行为,有些时候会给我们开发者带来一些困惑,比如基于一个已有数组建立的切片,一旦追加的数据操作触碰到切片的容量上限(实质上也是数组容量的上界),切片就会和原数组解除“绑定”,后续对切片的任何修改都不会反映到原数组中了。我们再来看这段代码:

u := [...]int{11, 12, 13, 14, 15}
fmt.Println("array:", u)    // array: [11 12 13 14 15]
s := u[1:3]
fmt.Printf("slice(len=%d, cap=%d): %v\\n", len(s), cap(s), s)    // slice(len=2, cap=4): [12 13]

s = append(s, 24)
fmt.Println("after append 24, array:", u)
fmt.Printf("after append 24, slice(len=%d, cap=%d): %v\\n", len(s), cap(s), s)
// after append 24, array: [11 12 13 24 15]
// after append 24, slice(len=3, cap=4): [12 13 24]

s = append(s, 25)
fmt.Println("after append 25, array:", u)
fmt.Printf("after append 25, slice(len=%d, cap=%d): %v\\n", len(s), cap(s), s)
// after append 25, array: [11 12 13 24 25]
// after append 25, slice(len=4, cap=4): [12 13 24 25]

s = append(s, 26)
fmt.Println("after append 26, array:", u)
fmt.Printf("after append 26, slice(len=%d, cap=%d): %v\\n", len(s), cap(s), s)
// after append 26, array: [11 12 13 24 25]
// after append 26, slice(len=5, cap=8): [12 13 24 25 26]

s[0] = 22
fmt.Println("after reassign 1st elem of slice, array:", u)
fmt.Printf("after reassign 1st elem of slice, slice(len=%d, cap=%d): %v\\n", len(s), cap(s), s)
// after reassign 1st elem of slice, array: [11 12 13 24 25]
// after reassign 1st elem of slice, slice(len=5, cap=8): [22 13 24 25 26]

运行这段代码,我们得到这样的结果:

array: [11 12 13 14 15]
slice(len=2, cap=4): [12 13]
after append 24, array: [11 12 13 24 15]
after append 24, slice(len=3, cap=4): [12 13 24]
after append 25, array: [11 12 13 24 25]
after append 25, slice(len=4, cap=4): [12 13 24 25]
after append 26, array: [11 12 13 24 25]
after append 26, slice(len=5, cap=8): [12 13 24 25 26]
after reassign 1st elem of slice, array: [11 12 13 24 25]
after reassign 1st elem of slice, slice(len=5, cap=8): [22 13 24 25 26]

这里,在append 25之后,切片的元素已经触碰到了底层数组u的边界了。然后我们再append 26之后,append发现底层数组已经无法满足append的要求,于是新创建了一个底层数组(数组长度为cap(s)的2倍,即8),并将slice的元素拷贝到新数组中了。

在这之后,我们即便再修改切片的第一个元素值,原数组u的元素也不会发生改变了,因为这个时候切片s与数组u已经解除了“绑定关系”,s已经不再是数组u的“描述符”了。这种因切片的自动扩容而导致的“绑定关系”解除,有时候会成为你实践道路上的一个小陷阱,你一定要注意这一点。