Slice

Slice(切片)代表变长的序列,序列中每个元素都有相同的类型。一个slice类型一般写作[]T,其中T代表slice中元素的类型;slice的语法和数组很像,只是没有固定长度而已。

数组和slice关系非常密切，一个slice可以访问数组的部分或者全部数据，而且slice的底层本身就是对数组的引用。

一个Slice由三部分组成：指针，长度和容量。内置的len和cap函数可以分别返回slice的长度和容量。指针指向第一个slice元素对应的底层数组元素的地址,要注意的是slice的第一个元素并不一定就是数组的第一个元素。长度对应slice中元素的数目;长度不能超过容量,容量一般是从slice的开始位置到底层数据的结尾位置。内置的len和cap函数分别返回slice的长度和容量。

多个slice之间可以共享底层的数据,并且引用的数组部分区间可能重叠。图4.1显示了表示一 年中每个月份名字的字符串数组,还有重叠引用了该数组的两个slice。数组这样定义.

  1. months := [...]string{1: "January", /* ... */, 12: "December"}

一月份是months[1],十二月份是months[12]。通常,数组的第一个元素从索引0开始,但是月份一般是从1开始的,因此我们声明数组时直接跳过第0个元素,第0个元素会被自动初始化为空字符串。

Slice - 图1

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)则是意味着扩展了lice,因为新slice的长度会变大.

  • 注意: 这里截取slice的时候容易犯错误
  2. func main(){
  3.    p:=[]int{1,2,3}
  4.    fmt.Println("p:",p)
  6.    m1 :=p[:2]
  7.    fmt.Println("m1:",m1)
  9.    m2 := m1[1:]
  10.    fmt.Println("m2:",m2)
  12.    m3 := m2[:2]
  13.    m4 := p[:2][1:][:2]
  14.    fmt.Println("m3",m3)
  15.    fmt.Println("m4",m4)
  16. }
  18. 结果如下:
  20. p: [1 2 3]
  21. m1: [1 2]
  22. m2: [2]
  23. m3 [2 3]
  24. m4 [2 3]

这里大家可能会有疑问m4中p[:2][1:]已经等价与m2中的截取到的值[２]了为何还可以在接续截取m2[:2]==m4　操作，其实这里就要说到切片的原因，slice的底层本身就是对数组的引用，因而多个 slice 共享的是底层的同一个数组。

虽然 m４ 表面上没有，但是如果你指定了截止的位置并且这个位置没有超过底层数组的范围，它就会指针引用底层的数组，这还是可以取到底层数组的值。

slice创建方式主要有两种：1.基于数组创建。2.直接创建

  • 基于数组创建：

    1. arrVar := [4]int{1, 2, 3，4}
    2. sliceVar := arrVar[1:3]

    数组arrVar和sliceVar里面的地址其实是一样的，因而如果你改变sliceVar里面的变量，那么arrVar里面的变量也会随之改变。

  • 直接创建

  1. 内建函数new分配了零值填充的元素类型的内存空间，并且返回其地址，一个指针类型的值。
  1. var p *[]int = new([]int)  //分配slice结构内存
  2. var ｍ []int = make([]int,100) //m指向一个新分配的有100个整数的数组

因此:

  1. new 分配；make 初始化
  2. new(T) 返回 *T 指向一个零值 T
  3. make(T) 返回初始化后的 T

注意: make仅适用于 map，slice 和 channel，并且返回的不是指针。应当用 new 获得特定的指针。

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

使用内置的make()函数来创建。事实上还是会创建一个匿名的数组，只是不需要我们来定义。

  1. make([]T, len)
  2. make([]T, len, cap) // same as make([]T, cap)[:len]

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

  1. slice1 := make([]int,5)//创建一个元素个数5的slice,cap也是5
  2. slice2 := make([]int,5,10)//创建一个元素个数5的slice，cap是10
  3. slice3 := []int{1,2,3,4,5}//创建一个元素个数为5的slice，cap是5
  4. var slice []int //创建一个空的slice，cap和len都是0

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

  1. func equal(x, y []string) bool {
  2.    if len(x) != len(y) {
  3.         return false
  4.    }
  5.    for i := range x {
  6.         if x[i] != y[i] {
  7.             return false
  8.         }
  9.   }
  10.   return true
  11. }

通过在slice的深度相等测试,运行的时间并不比支持==操作的数组或字符串更多,但是为何slice不直接支持比较运算符呢?这方面有两个原因。第一个原因,一个slice的元素是间接引用的,一个slice甚至可以包含自身。虽然有很多办法处理这种情形,但是没有一个是简单有效的。

第二个原因,因为slice的元素是间接引用的,一个固定值的slice在不同的时间可能包含不同的元素,因为底层数组的元素可能会被修改。并且Go语言中map等哈希表之类的数据结构的key只做简单的浅拷贝,它要求在整个声明周期中相等的key必须对相同的元素。对于像指针或chan之类的引用类型,==相等测试可以判断两个是否是引用相同的对象。一个针对slice的浅相等测试的==操作符可能是有一定用处的,也能临时解决map类型的key问题,但是slice和数组不同的相等测试行为会让人困惑。因此,安全的做法是直接禁止slice之间的比较操作。

slice唯一合法的比较操作是和nil比较,例如:

  1. if slice == nil { /* ... */ }

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

  1. var s []int      // len(s) == 0, s == nil
  2. s = nil         // len(s) == 0, s == nil
  3. s = []int(nil)  // len(s) == 0, s == nil
  4. s = []int{}     // len(s) == 0, s != nil

如果你需要测试一个slice是否是空的,使用len(s) == 0来判断,而不应该用s == nil来判断。除了和nil相等比较外,一个nil值的slice的行为和其它任意0长度的slice一样.

此外Slice切片还有append函数用于向slice追加元素.虽然Slice是可以动态扩展的。但Slice的动态扩展是有代价的，也就是说如果在确定大小的前提下，最好是设置好slice的cap大小.

  1. func main() {
  2.     var x, y []int
  3.     for i := 0; i < 10; i++ {
  4.         y = appendInt(x, i)
  5.         fmt.Printf("%d cap=%d\t%v\n", i, cap(y), y)
  6.         x = y
  7.     }
  8. }

每一次容量的变化都会导致重新分配内存和copy操作:

  1. 0 cap=1 [0]
  2. 1 cap=2 [0 1]
  3. 2 cap=4 [0 1 2]
  4. 3 cap=4 [0 1 2 3]
  5. 4 cap=8 [0 1 2 3 4]
  6. 5 cap=8 [0 1 2 3 4 5]
  7. 6 cap=8 [0 1 2 3 4 5 6]
  8. 7 cap=8 [0 1 2 3 4 5 6 7]
  9. 8 cap=16 [0 1 2 3 4 5 6 7 8]
  10. 9 cap=16 [0 1 2 3 4 5 6 7 8 9]

我们仔细查看i=3次的迭代。当时x包含了[0 1 2]三个元素,但是容量是4,因此可以简单将新的元素添加到末尾,不需要新的内存分配。然后新的y的长度和容量都是4,并且和x引用着相同的底层数组.

Slice - 图2

在下一次迭代时i=4,现在没有新的空余的空间了,因此appendInt函数分配一个容量为8的底层数组,将x的4个元素[0 1 2 3]复制到新空间的开头,然后添加新的元素i,新元素的值是4。新的y的长度是5,容量是8;后面有3个空闲的位置,三次迭代都不需要分配新的空间。当前迭代中,y和x是对应不同底层数组的view。

Slice - 图3

当slice的的容量等于len的时候，cap是翻倍了。append的底层原理就是当slice的容量满了的时候，重新建立一块内存，然后将原来的数据拷贝到新建的内存。所以说容量的扩充是存在内存的建立和复制的。该过程将会影响到系统的运行速度。

更新slice变量不仅对调用append函数是必要的,实际上对应任何可能导致长度、容量或底层数组变化的操作都是必要的。要正确地使用slice,需要记住尽管底层数组的元素是间接访问的,但是slice对应结构体本身的指针、长度和容量部分是直接访问的。要更新这些信息需要像上面例子那样一个显式的赋值操作。从这个角度看,slice并不是一个纯粹的引用类型,它实际上是一个类似下面结构体的聚合类型:

  1. type IntSlice struct {
  2.     ptr         *int
  3.     len, cap    int
  4. }

我们的appendInt函数每次只能向slice追加一个元素,但是内置的append函数则可以追加多个元素,甚至追加一个slice。

  1. var x []int
  2. x = append(x, 1)
  3. x = append(x, 2, 3)
  4. x = append(x, 4, 5, 6)
  5. x = append(x, x...) // append the slice x
  6. fmt.Println(x)     // "[1 2 3 4 5 6 1 2 3 4 5 6]"

通过这样的修改我们可以可以达到append函数类似的功能。其中在appendInt函数参数中的最后的“…”省略号表示接收变长的参数为slice。

内置的copy函数可以方便地将一个slice复制另一个相同类型的slice。使用copy函数：。

  1. slice1 := []int{1, 2, 3, 4, 5}
  2. slice2 := []int{5, 4, 3}
  3. copy(slice2, slice1) // 只会复制slice1的前3个元素到slice2中
  4. copy(slice1, slice2) // 只会复制slice2的3个元素到slice1的前3个位置

copy函数的第一个参数是要复制的目标slice,第二个参数是源slice,目标和源的位置顺序和dst = src赋值语句是一致的。两个slice可以共享同一个底层数组,甚至有重叠也没有问题。copy函数将返回成功复制的元素的个数(我们这里没有用到),等于两个slice中较小的长度,所以我们不用担心覆盖会超出目标slice的范围。