Go切片类型的使用

起风时&李璇 作品

我们总是喜欢拿“顺其自然”来敷衍人生道路上的荆棘坎坷，却很少承认，真正的顺其自然，其实是竭尽所能之后的不强求，而非两手一摊的不作为。 by 瑞卡斯

引用于：http://wufazhuce.com/one/1353

slice 知识要点

1. ** slice 是引用类型，所以当引用改变其中元素的值时，其它的所有引用都会改变该值**。
2. ** slice 在未初始化之前默认为 nil，长度为 0**。
3. slice 的声明格式：var identifier []type （不需要说明长度）。
4. slice 初始化格式：
   4.1. var sliceName []type = arrName[start:end] （通过数组初始化切片）。
   4.2. var sliceName []type = make([]type, len, cap)（cap可选参数）。
   4.3. a := []int(1, 2)（已知道元素值情况下初始化切片）。
5. slice 像一个结构体，这个结构体包含了三个元素
   5.1. 一个指针，指向数组中 slice 指定的开始位置。
   5.2. len 长度，即 slice 的长度。
   5.3. cap 最大长度，也就是 slice 开始位置到数组的最后位置的长度。
6. 尽可能的用切片代替数组
7. 使用 make([]type, 0) 实例化一个空的切片。

例如：下面示例和视图

Array_a := [10]byte{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
Slice_a := Array_a[2:5]

slice示例图

slice和数组在声明时的区别：声明数组时，方括号内写明了数组的长度或使用...自动计算长度，而声明slice时，方括号内没有任何字符。

slice 的一些简便操作

1. slice 的默认开始位置是0，ar[:n]等价于ar[0:n]。
2. slice 的第二个序列默认是数组的长度，ar[n:]等价于ar[n:len(ar)]。
3. 如果从一个数组里面直接获取 slice，可以这样ar[:]，因为默认第一个序列是0，第二个是数组的长度，即等价于ar[0:len(ar)]。

slice和array的对应关系图

func printSliceByRange(s []int) {
    for k, v := range s {
        fmt.Printf("s[%d]=%d ", k, v)
    }
    fmt.Println()
}

func printSliceByLen(s []int) {
    for i, j := 0, len(s); i < j; i++ {
        fmt.Printf("s[%d]=%d ", i, s[i])
    }
    fmt.Println()
}

/*
 数组[a:b]
 创建一个包含数组的第a个元素到第b-1个元素的切片。
 当前长度 = b - a
 最大容量 = len(数组) - a

 slice是引用类型，所以当引用改变其中元素的值时，其它的所有引用都会改变该值
*/
func main() {
    //通过指向一个数组声明并初始化slice
    arr := [5]int{1, 2, 3, 4, 5}

    //等价于sliceA := arr[0:5]
    //包含arr的全部元素{1, 2, 3, 4, 5}
    //len = 5，cap = 5
    sliceA := arr[:]

    //等价于sliceA := arr[0:4]
    //包含arr的全部元素{1, 2, 3, 4}
    //len = 4，cap = 5
    sliceA = arr[:4]

    //等价于sliceA := arr[3:5]
    //包含arr的全部元素{4, 5}
    //len = 2，cap = 2
    sliceA = arr[3:]

    //包含arr的全部元素{2, 3, 4}
    //len = 3，cap = 4
    sliceA = arr[1:4]

    //通过make声明并初始化slice
    //指向一个int类型数组，默认长度为2，最大容量为10
    sliceB := make([]int, 2, 10)

    printSliceByRange(sliceA) //s[0]=2 s[1]=3 s[2]=4
    printSliceByLen(sliceB) //s[0]=0 s[1]=0

    //append函数会改变slice所引用的数组的内容，从而影响到引用同一数组的其它slice。
    //但当slice中没有剩余空间（即(cap-len) == 0）时，此时将动态分配新的数组空间。
    //返回的slice数组指针将指向这个空间，而原数组的内容将保持不变；其它引用此数组的slice则不受影响。
    sliceA = arr[:]
    sliceC := append(sliceA, 6)
    printSliceByRange(sliceA) //s[0]=1 s[1]=2 s[2]=3 s[3]=4 s[4]=5
    printSliceByRange(sliceC) //s[0]=1 s[1]=2 s[2]=3 s[3]=4 s[4]=5 s[5]=6
}

在阅读<Golang入门指南>这本书时，对切片又有了一些新认识。

slice 结合append、copy函数使用

1. 将切片b追加到切片a之后。temp_as = append(temp_as, temp_bs...)
2. 复制切片a的元素到新的切片b上。copy(temp_cs, temp_bs)
3. 删除位于索引i的元素。append(temp_as[:i], temp_as[i+1:]...)
4. 切除切片a中从索引j至k位置的元素。append(temp_as[:j], temp_as[k:]...)
5. 将元素b追加到切片a。append(temp_as, b)

func demo7() {
    //将切片b追加到切片a之后
    temp_a := [10]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    temp_as := temp_a[:]
    temp_b := [5]int{10, 11, 12, 13, 14}
    temp_bs := temp_b[:]
    temp_as = append(temp_as, temp_bs...)
    fmt.Println(temp_as) //[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14]

    //复制切片a的元素到新的切片b上
    temp_cs := make([]int, 15)
    copy(temp_cs, temp_bs)
    fmt.Println(temp_cs) //[10 11 12 13 14 0 0 0 0 0 0 0 0 0 0]

    //删除位于索引5的元素
    temp_as = append(temp_as[:5], temp_as[6:]...)
    fmt.Println(temp_as) //[0 1 2 3 4 6 7 8 9 10 11 12 13 14]

    //切除切片a中从索引3至6位置的元素
    temp_as = append(temp_as[:3], temp_as[6:]...)
    fmt.Println(temp_as) //[0 1 2 7 8 9 10 11 12 13 14]

    //将元素15追加到切片a
    temp_as = append(temp_as, 15)
    fmt.Println(temp_as) //[0 1 2 7 8 9 10 11 12 13 14 15]
}

切片和垃圾回收

切片的底层指向一个数组，该数组的实际体积可能要大于切片所定义的体积。只有在没有任何切片指向的时候，底层的数组内层才会被释放，这种特性有时会导致程序占用多余的内存。

示例 函数FindDigits将一个文件加载到内存，然后搜索其中所有的数字并返回一个切片。

var digitRegexp = regexp.MustCompile("[0-9]+")

func FindDigits(filename string) []byte {
    b, _ := ioutil.ReadFile(filename)
    return digitRegexp.Find(b)
}

这段代码可以顺利运行，但返回的[]byte指向的底层是整个文件的数据。只要该返回的切片不被释放，垃圾回收器就不能释放整个文件所占用的内存。换句话说，一点点有用的数据却占用了整个文件的内存。

想要避免这个问题，可以通过拷贝我们需要的部分到一个新的切片中：

func FindDigits(filename string) []byte {
   b, _ := ioutil.ReadFile(filename)
   b = digitRegexp.Find(b)
   c := make([]byte, len(b))
   copy(c, b)
   return c
}

参考：
https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/02.2.md