我正在参加「掘金·启航计划」

1、引子

因为数组的长度是固定的并且数组长度属于类型的一部分，所以数组有很多局限性，例如函数之间传参时只能接收固定长度的数组，[2]int{1,2}已经有两个元素，不能再继续往数组中添加新元素

2、切片

切片(Slice)是一个拥有相同类型元素的可变长度的序列，它是基于数组类型做的一层封装，他非常灵活，可以支持自动扩容

切片是数组的一个引用，因此切片是引用类型，他的内部结构包含地址、长度和容量，它并不是数组或数组指针，它通过内部指针和相关属性引用数组片段，以实现边长方案，他一般用于快速的操作一块数据集合。

2.1、切片的定义

var name []T  //声明切片类型的基本语法，name表示变量名， T标识切片中元素的类型

例子：

func main(){
	var s1 []string    //[] 声明一个字符串类型切片
	var s2 = []int{}  //[]  声明一个整数类型切片并初始化
    s3 := []bool{true, false}    //[true false]
    var s4 = []bool{true, false} //[true false]
    fmt.Println(s1 == nil)   //true 未初始化等于nil
    fmt.Println(s2 == nil)   //false 初始化未赋值也不等于nil
    fmt.Println(s3 == nil)   //false
    // fmt.Println(s3 == s4) //切片是引用类型，不支持直接比较，只能和nil比较
}

2.2、数组的长度和容量

切片拥有自己的长度和容量，我们可以通过使用内置 len() 函数求长度，使用内置cap()函数求切片的容量。

2.3、切片表达式

切片表达式从字符串、数组、指向数组或切片的指针构造子字符串或切片，它有两种变体：一种是指定low和high两个索引界限值得简单形式，另一种是除了low和high索引界限值外还指定容量的完整形式

2.3.1、简单切片表达式

切片的底层就是一个数组，我们可以基于数组通过切片表达式得到切片。切片表达式中的low和high表示一个索引范围(左包含，右不包含); 也就是下面代码中从数组a中选出1<=索引值<4的元素组成切片s，得到的切片长度 =high -low, 容量等于得到的切片的底层数组的容量。

func main(){
    a := [5]int{1, 2, 3, 4, 5}
    s := a[1:3] // s := a[low:high] 左包含 右不包含
    fmt.Printf("s:%v len(s):%v cap(s):%v\n", s, len(s), cap(s))
    //输出 s:[2 3] len(s):2 cap(s):4 
}

为了方便起见，可以省略切片切片表达式中的任何索引，省略了low则默认为0，省略了high 则默认为切片操作数组的长度

a[:2] //等同于 a[0:2]
a[2:] //等同于 a[2:len(a)]
a[:] //等同于 a[0:len(a)]
a[:len(a)-1] //去掉最后一个元素

注意：

对于数组或字符串，如果0<=low<=high <=len(a)，则索引合法，否则就会索引越界(out of range)

对于切片再执行切片表达式时，high的上限边界是切片的容量cap(a)，而不是长度，常量索引必须是非负的，并且可以用int类型的值表示；对于数组或常量字符串，常量索引也必须在有效范围内。必须满足low<=high，如果索引在运行时超出范围，就会发生运行时panic

func main(){
    a := [5]int{1, 2, 3, 4, 5}
    s := a[1:3] 
    fmt.Printf("s:%v len(s):%v cap(s):%v\n", s, len(s), cap(s))
    //输出：  s:[2 3] len(s):2 cap(s):4
    
    s2 := s[3:4] //切片再切片， 索引的上限是cap(s) 而不是len(s)
    fmt.Printf("s2:%v len(s2):%v cap(s2):%v", s2, len(s2), cap(s2))
    //输出： s2:[5] len(s2):1 cap(s2):1 

}

2.3.2、完整切片表达式

对于数组，指向数组的指针，或切片a(注意不能是字符串)支持完整切片表达式

a[low : high : max] //切片长度high-low 切片容量 max-low

上面代码会构造出与简单切片表达式a[low:high]相同类型、相同长度和元素的切片，另外，他会将得到的结果切片的容量设置为max-low。在完整切片表达式中只有第一个索引(low)可以省略，默认认为0。

完整切片表达式需要满足的条件是 0 <= low <= hith <= max <= cap(a),其他条件和简单表达式相同。

func main(){
    a := [5]int{1, 2, 3, 4, 5}
    s := a[1:3:5] //len=3-1  cap=5-1
    fmt.Printf("s:%v len(s):%v cap(s):%v\n", s, len(s), cap(s))
    //输出 s:[2 3] len(s):2 cap(s):4
}

2.4、使用make函数构造切片

上面都是基于数组来创建的切片，如果需要动态创建一个切片，就需要使用内置的make()函数，格式如下：

make([]T, size, cap) //T切片的元素类型  size切片中元素数量 cap切片容量

例子：

func main(){
    a := make([]int, 2, 10)
    fmt.Println(a)    	 // [0 0]
    fmt.Println(len(a))  // 2
    fmt.Println(cap(a))	 // 10
}

2.5、切片的本质

切片的本质就是对底层数组的封装，它包含了三个信息：底层数组的指针、切片的长度(len)和切片的容量(cap)

例：有个数组a := [8]int{0, 1, 2, 3, 4, 5, 6, 7},切片s := a[:5]，示意图如下：

切片s2 := a[3:6],示意图如下：

2.6、判断切片是否为空

要检查切片是否为空，请使用len(s) ==0来判断，而不应该使用s==nil来判断

2.7、切片不能直接比较

切片直接是不能比较的，我们不能使用==来比较两个切片是否全部相等元素，切片唯一合法的比较操作是和nil来比较。一个nil值得切片并没有底层数组，一个nil值得切片的长度和容量都为0，我们不能说一个长度和容量都是0的切片一定是nil

func main(){
	var s1 []int 			//len=0 cap=0 s1==nil
    s2 := []int{}			//len=0 cap=0 s2!=nil
    s3 := make([]int, 0)	//len=0 cap=0 s3!=nil
}

2.8、切片的赋值拷贝

下面代码中演示了拷贝前后两个变量共享底层数组，对一个切片的修改会影响另一个切片的内容。

func main(){
    s1 := make([]int, 3)  //[0 0 0]
    s2 := s1  			  //将s1直接赋值给s2，s1和s2共用一个底层数组
    s2[0] = 100
    fmt.Println(s1)  //[100 0 0]
    fmt.Println(s2)  //[100 0 0]
} 

2.9、切片遍历

切片的遍历方式和数组是一致的，支持索引遍历和for range遍历

func main(){
    s := []int{1, 2, 3}
    //for循环遍历
    for i:=0; i<len(s); i++{
        fmt.Println(i, s[i])
    }
    
    //for range遍历
    for index, value := range s{
        fmt.Println(index, value)
    }
}

2.10、append()方法为切片添加元素

go语言的内建函数append()可以为切片动态添加元素，可以一次添加一个元素，可以添加多个元素，也可以添加另一个切片中的元素(后面加...)。

func main(){
	var s []int //通过var声明的零值切片可以在append函数直接使用，无需初始化
    s = append(s, 1)		//[1]
    s = append(s, 2, 3, 4)	//[1 2 3 4]
    s2 := []int{5, 6, 7}
    s = append(s, s2...)	//[1 2 3 4 5 6 7]

}

每个切片会指向一个底层数组，这个数组的容量够用就添加新元素，当底层数组不能容纳新元素时，切片就会自动按照一定的策略进行"扩容",此时该切片指向的底层数组就会更换，"扩容"操作一般发生在append时，所以我们需要用原变量接收append函数的返回值。

2.11、切片的扩容策略

源码：$GOROOT/src/runtime/slice.go

newcap := old.cap
doublecap := newcap + newcap
if cap > doublecap {
	newcap = cap
} else {
	if old.len < 1024 {
		newcap = doublecap
	} else {
		// Check 0 < newcap to detect overflow
		// and prevent an infinite loop.
		for 0 < newcap && newcap < cap {
			newcap += newcap / 4
		}
		// Set newcap to the requested cap when
		// the newcap calculation overflowed.
		if newcap <= 0 {
			newcap = cap
		}
	}
}

从上面的代码可以看出以下内容:

• 首先判断，如果新申请容量cap大于2倍的就容量old.cap,最终容量newcap就是新申请的容量cap
• 否则判断，若果就切片的长度小于1024，则最终容量newcap就是旧容量old.cap的两倍，既 newcap=doublecap
• 否则判断，如果旧切片长度大于等于1024，则最终容量newcap从旧容量old.cap开始循环增加原来的1/4，既newcap=old.cap,for{newcap+=newcap/4}，直到最终容量newcap大于等于新申请的容量cap，既newcap>=cap
• 如果最终容量cap计算值溢出，则最终容量cap就是新申请容量cap

需要注意的是，切片扩容还会根据切片中元素的类型不同而做不同的处理，比如int和string类型的处理方式就不一样。

2.12、使用copy()函数复制切片

首先来看一个问题

func main(){
    a := []int{1, 2, 3, 4, 5}
    b := a
    fmt.Println(a) //[1 2 3 4 5]
    fmt.Println(b) //[1 2 3 4 5]
    b[0] = 1000
	fmt.Println(a) //[1000 2 3 4 5]
    fmt.Println(b) //[1000 2 3 4 5]
}

由于切片是引用类型，所以a和b其实是指向同一块内存地址，修改b的同时a的值也会发生变化。

copy()函数可以迅速将一个切片的数据复制到另一个切片空间中，格式如下

copy(destSlice, srcSlice []T)  //destSlice目标切片 srcSlice数据来源切片  

例子：

func main(){
    a := []int{1, 2, 3, 4, 5}
    b := make([]int, 5, 5)
    copy(b, a) //使用copy函数将切片c中的元素复制到切片c
    fmt.Println(a) //[1 2 3 4 5]
	fmt.Println(b) //[1 2 3 4 5]
    b[0] = 1000
    fmt.Println(a) //[1 2 3 4 5]
    fmt.Println(b) //[1000 2 3 4 5]
}

2.13、从切片中删除元素

Go语言中没有删除切片元素的专用方法，可以使用切片本身的特性来删除元素

要从切片a中删除索引为index的元素，操作方法如下：
a = append(a[:index], a[index:]...)

例子：

func main(){
    a := []int{1, 2, 3, 4, 5, 6, 7}
	//删除索引为2的元素
    a = append(a[:2], a[3:]...)
    fmt.Println(a) //[1 2 4 5 6 7]
}