1. 切片Slice

    需要说明，slice 并不是数组或数组指针。它通过内部指针和相关属性引用数组片段，以实现变长方案。

    3. import "fmt"
    5. func main() {
    6.    //1.声明切片
    7.    var s1 []int
    8.    if s1 == nil {
    9.       fmt.Println("是空")
    10.    } else {
    11.       fmt.Println("不是空")
    12.    }
    13.    // 2.:=
    14.    s2 := []int{}
    15.    // 3.make()
    16.    var s3 []int = make([]int, 0)
    17.    fmt.Println(s1, s2, s3)
    18.    // 4.初始化赋值
    19.    var s4 []int = make([]int, 0, 0)
    20.    fmt.Println(s4)
    21.    s5 := []int{1, 2, 3}
    22.    fmt.Println(s5)
    23.    // 5.从数组切片
    24.    arr := [5]int{1, 2, 3, 4, 5}
    25.    var s6 []int
    26.    // 前包后不包
    27.    s6 = arr[1:4]
    28.    fmt.Println(s6)
    29. }

    1.1.2. 切片初始化

    1. 全局：
    2. var arr = [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    3. var slice0 []int = arr[start:end] 
    4. var slice1 []int = arr[:end]        
    5. var slice2 []int = arr[start:]        
    6. var slice3 []int = arr[:] 
    7. var slice4 = arr[:len(arr)-1]      //去掉切片的最后一个元素
    8. 局部：
    9. arr2 := [...]int{9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
    10. slice5 := arr[start:end]
    11. slice6 := arr[:end]        
    12. slice7 := arr[start:]     
    13. slice8 := arr[:]  
    14. slice9 := arr[:len(arr)-1] //去掉切片的最后一个元素

    代码：

    1. package main
    3. import (
    4.     "fmt"
    5. )
    7. var arr = [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    8. var slice0 []int = arr[2:8]
    9. var slice1 []int = arr[0:6]        //可以简写为 var slice []int = arr[:end]
    10. var slice2 []int = arr[5:10]       //可以简写为 var slice[]int = arr[start:]
    11. var slice3 []int = arr[0:len(arr)] //var slice []int = arr[:]
    12. var slice4 = arr[:len(arr)-1]      //去掉切片的最后一个元素
    13. func main() {
    14.     fmt.Printf("全局变量：arr %v\n", arr)
    15.     fmt.Printf("全局变量：slice0 %v\n", slice0)
    16.     fmt.Printf("全局变量：slice1 %v\n", slice1)
    17.     fmt.Printf("全局变量：slice2 %v\n", slice2)
    18.     fmt.Printf("全局变量：slice3 %v\n", slice3)
    19.     fmt.Printf("全局变量：slice4 %v\n", slice4)
    20.     fmt.Printf("-----------------------------------\n")
    21.     arr2 := [...]int{9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
    22.     slice5 := arr[2:8]
    23.     slice6 := arr[0:6]         //可以简写为 slice := arr[:end]
    24.     slice7 := arr[5:10]        //可以简写为 slice := arr[start:]
    25.     slice8 := arr[0:len(arr)]  //slice := arr[:]
    26.     slice9 := arr[:len(arr)-1] //去掉切片的最后一个元素
    27.     fmt.Printf("局部变量： arr2 %v\n", arr2)
    28.     fmt.Printf("局部变量： slice5 %v\n", slice5)
    29.     fmt.Printf("局部变量： slice6 %v\n", slice6)
    30.     fmt.Printf("局部变量： slice7 %v\n", slice7)
    31.     fmt.Printf("局部变量： slice8 %v\n", slice8)
    32.     fmt.Printf("局部变量： slice9 %v\n", slice9)
    33. }

    输出结果：

    1.     全局变量：arr [0 1 2 3 4 5 6 7 8 9]
    2.     全局变量：slice0 [2 3 4 5 6 7]
    3.     全局变量：slice1 [0 1 2 3 4 5]
    4.     全局变量：slice2 [5 6 7 8 9]
    5.     全局变量：slice3 [0 1 2 3 4 5 6 7 8 9]
    6.     全局变量：slice4 [0 1 2 3 4 5 6 7 8]
    7.     -----------------------------------
    8.     局部变量： arr2 [9 8 7 6 5 4 3 2 1 0]
    9.     局部变量： slice5 [2 3 4 5 6 7]
    10.     局部变量： slice6 [0 1 2 3 4 5]
    11.     局部变量： slice7 [5 6 7 8 9]
    12.     局部变量： slice8 [0 1 2 3 4 5 6 7 8 9]
    13.     局部变量： slice9 [0 1 2 3 4 5 6 7 8]

    1.1.3. 通过make来创建切片

    1.     var slice []type = make([]type, len)
    2.     slice  := make([]type, len)
    3.     slice  := make([]type, len, cap)

    切片

    代码：

    1. package main
    3. import (
    4.     "fmt"
    5. )
    7. var slice0 []int = make([]int, 10)
    8. var slice1 = make([]int, 10)
    9. var slice2 = make([]int, 10, 10)
    11. func main() {
    12.     fmt.Printf("make全局slice0 ：%v\n", slice0)
    13.     fmt.Printf("make全局slice1 ：%v\n", slice1)
    14.     fmt.Printf("make全局slice2 ：%v\n", slice2)
    15.     fmt.Println("--------------------------------------")
    16.     slice3 := make([]int, 10)
    17.     slice4 := make([]int, 10)
    18.     slice5 := make([]int, 10, 10)
    19.     fmt.Printf("make局部slice3 ：%v\n", slice3)
    20.     fmt.Printf("make局部slice4 ：%v\n", slice4)
    21.     fmt.Printf("make局部slice5 ：%v\n", slice5)
    22. }

    输出结果：

    1.     make全局slice0 ：[0 0 0 0 0 0 0 0 0 0]
    2.     make全局slice1 ：[0 0 0 0 0 0 0 0 0 0]
    3.     make全局slice2 ：[0 0 0 0 0 0 0 0 0 0]
    4.     --------------------------------------
    5.     make局部slice3 ：[0 0 0 0 0 0 0 0 0 0]
    6.     make局部slice4 ：[0 0 0 0 0 0 0 0 0 0]
    7.     make局部slice5 ：[0 0 0 0 0 0 0 0 0 0]

    切片的内存布局

    读写操作实际目标是底层数组，只需注意索引号的差别。

    1. package main
    3. import (
    4.     "fmt"
    5. )
    7. func main() {
    8.     data := [...]int{0, 1, 2, 3, 4, 5}
    10.     s := data[2:4]
    11.     s[0] += 100
    13.     fmt.Println(s)
    14.     fmt.Println(data)
    15. }

    输出:

    1.     [102 203]
    2.     [0 1 102 203 4 5]

    可直接创建 slice 对象，自动分配底层数组。

    1. package main
    3. import "fmt"
    5. func main() {
    6.     s1 := []int{0, 1, 2, 3, 8: 100} // 通过初始化表达式构造，可使用索引号。
    7.     fmt.Println(s1, len(s1), cap(s1))
    9.     s2 := make([]int, 6, 8) // 使用 make 创建，指定 len 和 cap 值。
    10.     fmt.Println(s2, len(s2), cap(s2))
    12.     s3 := make([]int, 6) // 省略 cap，相当于 cap = len。
    13.     fmt.Println(s3, len(s3), cap(s3))
    14. }

    输出结果:

    1.     [0 1 2 3 0 0 0 0 100] 9 9
    2.     [0 0 0 0 0 0] 6 8
    3.     [0 0 0 0 0 0] 6 6
    1. package main
    3. import "fmt"
    5. func main() {
    6.     s := []int{0, 1, 2, 3}
    7.     p := &s[2] // *int, 获取底层数组元素指针。
    8.     *p += 100
    10.     fmt.Println(s)
    11. }

    输出结果:

    1.     [0 1 102 3]

    至于 [][]T，是指元素类型为 []T 。

    输出结果：

    1.     [[1 2 3] [100 200] [11 22 33 44]]

    可直接修改 struct array/slice 成员。

    1. package main
    3. import (
    4.     "fmt"
    5. )
    7. func main() {
    8.     d := [5]struct {
    9.         x int
    10.     }{}
    12.     s := d[:]
    14.     d[1].x = 10
    15.     s[2].x = 20
    17.     fmt.Println(d)
    18.     fmt.Printf("%p, %p\n", &d, &d[0])
    20. }

    输出结果:

    1.     [{0} {10} {20} {0} {0}]
    2.     0xc4200160f0, 0xc4200160f0

    1.1.4. 用append内置函数操作切片（切片追加）

    1. package main
    3. import (
    4.     "fmt"
    5. )
    7. func main() {
    9.     var a = []int{1, 2, 3}
    10.     fmt.Printf("slice a : %v\n", a)
    11.     var b = []int{4, 5, 6}
    12.     fmt.Printf("slice b : %v\n", b)
    13.     c := append(a, b...)
    14.     fmt.Printf("slice c : %v\n", c)
    15.     d := append(c, 7)
    16.     fmt.Printf("slice d : %v\n", d)
    17.     e := append(d, 8, 9, 10)
    18.     fmt.Printf("slice e : %v\n", e)
    20. }

    输出结果：

    1.     slice a : [1 2 3]
    2.     slice b : [4 5 6]
    3.     slice c : [1 2 3 4 5 6]
    4.     slice d : [1 2 3 4 5 6 7]
    5.     slice e : [1 2 3 4 5 6 7 8 9 10]

    append ：向 slice 尾部添加数据，返回新的 slice 对象。

    1. package main
    3. import (
    4.     "fmt"
    5. )
    7. func main() {
    9.     s1 := make([]int, 0, 5)
    10.     fmt.Printf("%p\n", &s1)
    12.     s2 := append(s1, 1)
    13.     fmt.Printf("%p\n", &s2)
    15.     fmt.Println(s1, s2)
    17. }

    输出结果：

    1.     0xc42000a060
    2.     0xc42000a080
    3.     [] [1]
    1. package main
    3. import (
    4.     "fmt"
    5. )
    7. func main() {
    9.     data := [...]int{0, 1, 2, 3, 4, 10: 0}
    10.     s := data[:2:3]
    12.     s = append(s, 100, 200) // 一次 append 两个值，超出 s.cap 限制。
    14.     fmt.Println(s, data)         // 重新分配底层数组，与原数组无关。
    15.     fmt.Println(&s[0], &data[0]) // 比对底层数组起始指针。
    17. }

    输出结果:

    1.     [0 1 100 200] [0 1 2 3 4 0 0 0 0 0 0]
    2.     0xc4200160f0 0xc420070060

    从输出结果可以看出，append 后的 s 重新分配了底层数组，并复制数据。如果只追加一个值，则不会超过 s.cap 限制，也就不会重新分配。 通常以 2 倍容量重新分配底层数组。在大批量添加数据时，建议一次性分配足够大的空间，以减少内存分配和数据复制开销。或初始化足够长的 len 属性，改用索引号进行操作。及时释放不再使用的 slice 对象，避免持有过期数组，造成 GC 无法回收。

    1.1.6. slice中cap重新分配规律：

    1. package main
    3. import (
    4.     "fmt"
    5. )
    7. func main() {
    9.     s := make([]int, 0, 1)
    10.     c := cap(s)
    12.     for i := 0; i < 50; i++ {
    13.         s = append(s, i)
    14.         if n := cap(s); n > c {
    15.             fmt.Printf("cap: %d -> %d\n", c, n)
    16.             c = n
    17.         }
    18.     }
    20. }

    输出结果:

    1.     cap: 1 -> 2
    2.     cap: 2 -> 4
    3.     cap: 8 -> 16
    4.     cap: 16 -> 32

    1.1.7. 切片拷贝

    1. package main
    3. import (
    4.     "fmt"
    5. )
    7. func main() {
    9.     s1 := []int{1, 2, 3, 4, 5}
    10.     fmt.Printf("slice s1 : %v\n", s1)
    11.     s2 := make([]int, 10)
    12.     fmt.Printf("slice s2 : %v\n", s2)
    13.     copy(s2, s1)
    14.     fmt.Printf("copied slice s1 : %v\n", s1)
    15.     fmt.Printf("copied slice s2 : %v\n", s2)
    16.     s3 := []int{1, 2, 3}
    17.     fmt.Printf("slice s3 : %v\n", s3)
    18.     s3 = append(s3, s2...)
    19.     fmt.Printf("appended slice s3 : %v\n", s3)
    20.     s3 = append(s3, 4, 5, 6)
    21.     fmt.Printf("last slice s3 : %v\n", s3)
    23. }

    输出结果：

    1.     slice s1 : [1 2 3 4 5]
    2.     slice s2 : [0 0 0 0 0 0 0 0 0 0]
    3.     copied slice s1 : [1 2 3 4 5]
    4.     copied slice s2 : [1 2 3 4 5 0 0 0 0 0]
    5.     slice s3 : [1 2 3]
    6.     appended slice s3 : [1 2 3 1 2 3 4 5 0 0 0 0 0]
    7.     last slice s3 : [1 2 3 1 2 3 4 5 0 0 0 0 0 4 5 6]

    copy ：函数 copy 在两个 slice 间复制数据，复制长度以 len 小的为准。两个 slice 可指向同一底层数组，允许元素区间重叠。

    1.     array data :  [0 1 2 3 4 5 6 7 8 9]
    2.     slice s1 : [8 9]
    3.     slice s2 : [0 1 2 3 4]
    4.     copied slice s1 : [8 9]
    5.     copied slice s2 : [8 9 2 3 4]
    6.     last array data :  [8 9 2 3 4 5 6 7 8 9]

    应及时将所需数据 copy 到较小的 slice，以便释放超大号底层数组内存。

    1.1.8. slice遍历：

    1. package main
    3. import (
    4.     "fmt"
    5. )
    7. func main() {
    9.     data := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    10.     slice := data[:]
    11.     for index, value := range slice {
    12.         fmt.Printf("inde : %v , value : %v\n", index, value)
    13.     }
    15. }

    输出结果：

    1.     inde : 0 , value : 0
    2.     inde : 1 , value : 1
    3.     inde : 2 , value : 2
    4.     inde : 3 , value : 3
    5.     inde : 4 , value : 4
    6.     inde : 5 , value : 5
    7.     inde : 6 , value : 6
    8.     inde : 7 , value : 7
    9.     inde : 8 , value : 8
    10.     inde : 9 , value : 9
    1. package main
    3. import (
    4.     "fmt"
    5. )
    7. func main() {
    8.     var a = []int{1, 3, 4, 5}
    9.     fmt.Printf("slice a : %v , len(a) : %v\n", a, len(a))
    10.     b := a[1:2]
    11.     fmt.Printf("slice b : %v , len(b) : %v\n", b, len(b))
    12.     c := b[0:3]
    13.     fmt.Printf("slice c : %v , len(c) : %v\n", c, len(c))
    14. }

    输出结果：

    1.     slice a : [1 3 4 5] , len(a) : 4
    2.     slice b : [3] , len(b) : 1
    3.     slice c : [3 4 5] , len(c) : 3

    1.1.10. 数组和切片的内存布局

    切片

    1.1.11. 字符串和切片（string and slice）

    string底层就是一个byte的数组，因此，也可以进行切片操作。

    1. package main
    3. import (
    4.     "fmt"
    5. )
    7. func main() {
    8.     str := "hello world"
    9.     s1 := str[0:5]
    10.     fmt.Println(s1)
    12.     s2 := str[6:]
    13.     fmt.Println(s2)
    14. }

    输出结果：

    1.     hello
    2.     world

    string本身是不可变的，因此要改变string中字符。需要如下操作： 英文字符串：

    1. package main
    3. import (
    4.     "fmt"
    5. )
    7. func main() {
    8.     str := "Hello world"
    9.     s := []byte(str) //中文字符需要用[]rune(str)
    10.     s[6] = 'G'
    11.     s = s[:8]
    12.     s = append(s, '!')
    13.     str = string(s)
    14.     fmt.Println(str)
    15. }

    输出结果：

    1.     Hello Go!

    1.1.12. 含有中文字符串：

    1. package main
    3. import (
    4.     "fmt"
    5. )
    7. func main() {
    8.     str := "你好，世界！hello world！"
    9.     s := []rune(str) 
    10.     s[3] = '够'
    11.     s[4] = '浪'
    12.     s[12] = 'g'
    13.     s = s[:14]
    14.     str = string(s)
    15.     fmt.Println(str)
    16. }

    输出结果：

    1. 你好，够浪！hello go

    golang slice data[:6:8] 两个冒号的理解

    常规slice , data[6:8]，从第6位到第8位（返回6， 7），长度len为2， 最大可扩充长度cap为4（6-9）

    另一种写法： data[:6:8] 每个数字前都有个冒号， slice内容为data从0到第6位，长度len为6，最大扩充项cap设置为8

    a[x:y:z] 切片内容 [x:y] 切片长度: y-x 切片容量:z-x

    1. package main
    3. import (
    4.     "fmt"
    5. )
    7. func main() {
    8.     slice := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    9.     d1 := slice[6:8]
    10.     fmt.Println(d1, len(d1), cap(d1))
    11.     d2 := slice[:6:8]
    12.     fmt.Println(d2, len(d2), cap(d2))
    1.     strings.Replace(strings.Trim(fmt.Sprint(array_or_slice), "[]"), " ", ",", -1)