Slice

1.切片定义

切片是指向底层数组指针、能访问的元素个数（切片长度）和允许增长的元素个数（切片容量）组成

2.切片底层实现

image.png

数据结构如下

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

注意
其中cap总是大于len的，如果初始化的时候小于会报错

3.切片与数组

功能
1.数组定义之后是固定的，slice可以动态操作（设计理念来自于动态数组），可以做一些截取、append等操作

值 or 引用
1.数组传的是值，复制给另外一个数组的时候会复制，从而消耗很多内存（如果数组很大）
2.切片传的是引用，所以不需要额外的内存，比数组更有效
3.切片底层数组可能会在堆上分配内存，而且小的数组在栈上拷贝的消耗也未必比make大

4.但是并非所有的时候，

4.切片初始化

var slice []int //nil 切片 需要进行初始化之后才能用

使用make创建

slice := make([]int, 3)  //len 3, cap 3
slice := make([]int, 3, 5)  //len 3， cap 5

使用字面量创建 (这种方法与数组类似)

#创建切片
slice := []int{1,2,3} //len 3, cap 3
#创建数组
slice := [10]int{1,2,3}  //大小为10的数组
#只初始化某个索引值
s := []int{4:1} //len 5, cap 5 ,value [0 0 0 0 1]

基于已有数组或者切片创建

s := []int{0, 1, 2, 3, 4, 5, 6,  7, 8, 9}
#两个索引截取
s1 := s[:] //[0 1 2 3 4 5 6 7 8 9]
s2 := s[2:] //[2 3 4 5 6 7 8 9]
s3 := s[:4] //[0 1 2 3]
s4 := s[2:4] //[2, 3]

#三个索引截取,第三个参数限定slice的容量
s4 := s[2:4:8]

#原切片和新切片同一底层数组，改变新切片值的时候，原切片也会变

s := []int{1, 2, 3 ,4 ,5}
s1 = s[1:4] 
fmt.Println("before s:", s)   //[1 2 3 4 5]
fmt.Println("before s1:", s1) //[2 3 4]
s1[1] = 10
fmt.Println("after,s:",s) //[1 10 3 4 5]
fmt.Println("after, s1:", s1) //[10 3 4 ]

注意：
1.大小为cap的切片截取之后的slice的len和cap如何算
在执行[i, j]操作之后，获得的新切片长度：j -i , 容量 cap-i
举例： s[2:4]，长度：4-2=2, 容量： 10-2=8

2.可以用两个索引截取，也可以用三个索引截取
第三个索引参数表示限定切片容量，该容量不能大于原来切片的容量

原切片和新切片是基于同一个底层数组的
只是指针指向不同的位置，容量和长度可能不同
所以当心的切片值修改的时候，原切片的值也会跟着修改

4.如果用append()函数进行追加，可能改变原来底层数组的值，也可能新建一个底层数组

5.空切片和nil切片

空切片和nil切片的区别，如下图

nil切片

空切片

6.切片append

考点1 扩容

情况1：在容量够用的情况下追加，修改原来切片的值

func main() {
    array := [4]int{10, 20, 30, 40}
    slice := array[0:2]
    newSlice := append(slice, 50)
    fmt.Printf("Before slice = %v, Pointer = %p, len = %d, cap = %d\n", slice, &slice, len(slice), cap(slice))
    fmt.Printf("Before newSlice = %v, Pointer = %p, len = %d, cap = %d\n", newSlice, &newSlice, len(newSlice), cap(newSlice))
    newSlice[1] += 10
    fmt.Printf("After slice = %v, Pointer = %p, len = %d, cap = %d\n", slice, &slice, len(slice), cap(slice))
    fmt.Printf("After newSlice = %v, Pointer = %p, len = %d, cap = %d\n", newSlice, &newSlice, len(newSlice), cap(newSlice))
    fmt.Printf("After array = %v\n", array)
}

Before slice = [10 20], Pointer = 0xc4200c0040, len = 2, cap = 4
Before newSlice = [10 20 50], Pointer = 0xc4200c0060, len = 3, cap = 4
After slice = [10 30], Pointer = 0xc4200c0040, len = 2, cap = 4
After newSlice = [10 30 50], Pointer = 0xc4200c0060, len = 3, cap = 4
After array = [10 30 50 40]

情况2：在容量不够用的情况下追加，创建新的底层数组

注意：
因为底层数组修改内容的时候，会影响共同指向同一个底层数组的多个切片
一般在创建新的切片的时候，最好要让新的切片长度和容量一样
这样我们在追加操作的时候就会生成新的底层数组，和原数组分离。不然会因为共用底层数组而引起奇怪的问题

考点2 append可变函数

append(s S, x ...T) S  // T is the element type of S

因为append是一个可变函数，最后一个参数是 ...，可变参数，所以可以append多个参数，也可以append一个slice加上...

s0 := []int{0, 0}
s1 := append(s0, 2)                // append a single element     s1 == []int{0, 0, 2}
s2 := append(s1, 3, 5, 7)          // append multiple elements    s2 == []int{0, 0, 2, 3, 5, 7}
s3 := append(s2, s0...)            // append a slice              s3 == []int{0, 0, 2, 3, 5, 7, 0, 0}
s4 := append(s3[3:6], s3[2:]...)   // append overlapping slice    s4 == []int{3, 5, 7, 2, 3, 5, 7, 0, 0}

var t []interface{}
t = append(t, 42, 3.1415, "foo")   //                             t == []interface{}{42, 3.1415, "foo"}

var b []byte
b = append(b, "bar"...)            // append string contents      b == []byte{'b', 'a', 'r' }

7.切片拷贝

Slice 中拷贝方法有2个
函数定义

copy(dst, src []T) int
copy(dst []byte, src string) int

举例：

考点1：copy的时候取决于短的那一个

func main() {
    array := []int{10, 20, 30, 40}
    slice := make([]int, 6)
    n := copy(slice, array)
    fmt.Println(n,slice) //4 [10,20,30,40]
}

func main() {
    slice := make([]byte, 3)
    n := copy(slice, "abcdef")
    fmt.Println(n,slice)  //3 [97,98,99]
}

var a = [...]int{0, 1, 2, 3, 4, 5, 6, 7}
var s = make([]int, 6)
var b = make([]byte, 5)
n1 := copy(s, a[0:])            // n1 == 6, s == []int{0, 1, 2, 3, 4, 5}
n2 := copy(s, s[2:])            // n2 == 4, s == []int{2, 3, 4, 5, 4, 5}
n3 := copy(b, "Hello, World!")  // n3 == 5, b == []byte("Hello")

8.切片迭代

方法1：for进行迭代

方法2：range进行迭代
如果用 range 的方式去遍历一个切片，拿到的 Value 其实是切片里面的值拷贝。
举例：

func main() {
    slice := []int{10, 20, 30, 40}
    for index, value := range slice {
        fmt.Printf("value = %d , value-addr = %x , slice-addr = %x\n", value, &value, &slice[index])
    }
}

value = 10 , value-addr = c4200aedf8 , slice-addr = c4200b0320
value = 20 , value-addr = c4200aedf8 , slice-addr = c4200b0328
value = 30 , value-addr = c4200aedf8 , slice-addr = c4200b0330
value = 40 , value-addr = c4200aedf8 , slice-addr = c4200b0338

从上面结果我们可以看到，如果用 range 的方式去遍历一个切片，拿到的 Value 其实是切片里面的值拷贝。所以每次打印 Value 的地址都不变。

考点

参考文档

https://halfrost.com/go_slice/

go--基本数据结构--slice