切片

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

切片是一个**引用类型**，它的内部结构包含 地址 长度 和 容量。
```
var a []type
var a = []type{.....}
```

```
func main() {
	var a = [5]int{2, 3, 4, 5, 6}
	b := a[:] //b 等于 a数组
	fmt.Printf("b: %v\n  b type %T", b, b)
	/*
		b: [2 3 4 5 6]
		b type []int  b的类型是slice
	*/
}
```

**切片拥有自己的长度和容量，我们可以通过使用内置的len()函数求长度，使用内置的cap()函数求切片的容量。**
切片的长度就是它所包含的元素个数。
切片的容量是从它的一个元素开始数，到其底层数组元素末尾的个数。
切面s的长度和容量可通过表达式len(s) 和 cap(s) 来获取。
```
func main() {
	var a = []int{1, 2, 3, 4, 5, 6}
	fmt.Printf("a: %v  a切片的长度 %v  a切片的容量 %v \n", a, len(a), cap(a))
	b := a[2:]
	fmt.Printf("b: %v  b切片的长度 %v  b切片的容量 %v \n", b, len(b), cap(b))
	c := a[1:3]
	fmt.Printf("c: %v  c切片的长度 %v  c切片的容量 %v \n", c, len(c), cap(c))
	/*
		a: [1 2 3 4 5 6]  a切片的长度 6  a切片的容量 6
		b: [3 4 5 6]  b切片的长度 4  b切片的容量 4
		c: [2 3]  c切片的长度 2  c切片的容量 5
	*/
}
```

![](/media/202208/2022-08-01_183851_0012580.653041448741848.png)

![](/media/202208/2022-08-01_184149_0338480.6734949441083681.png)

## 使用make函数构造切片
```
make([]Type,Size,Cap)// 切片元素类型  元素数量 容量

```

## golang中如果需要给切片扩容需要使用append()方法
```
func main() {
	var a []int
	a = append(a, 12)
	fmt.Printf("a: %v  a长度  %v   a容量 %v \n", a, len(a), cap(a))
	a = append(a, 13)
	fmt.Printf("a: %v  a长度  %v   a容量 %v \n", a, len(a), cap(a))
	a = append(a)
	fmt.Printf("a: %v  a长度  %v   a容量 %v \n", a, len(a), cap(a))
}
/*
a: [12]  a长度  1   a容量 1 
a: [12 13]  a长度  2   a容量 2 
a: [12 13]  a长度  2   a容量 2 
*/
```

## append 方法合并切片
```
func main() {
	var sliceA = []string{"golong", "java"}
	var sliceB = []string{"php", "nodejs"}
	sliceA = append(sliceA, sliceB...)
	fmt.Printf("sliceA: %v\n", sliceA)
	/*
		sliceA: [golong java php nodejs]
	*/
}
```

## 切片的扩容策略
```
func main() {
	var sliceA []int
	for i := 1; i <= 20; i++ {
		sliceA = append(sliceA, i)
		fmt.Printf("sliceA: %v   sliceA长度 %v  sliceA容量 %v\n ", sliceA, len(sliceA), cap(sliceA))
	}
	/*
		[Running] go run "c:\Users\david\Desktop\mypro\main.go"
		sliceA: [1]   sliceA长度 1  sliceA容量 1
		 sliceA: [1 2]   sliceA长度 2  sliceA容量 2
		 sliceA: [1 2 3]   sliceA长度 3  sliceA容量 4
		 sliceA: [1 2 3 4]   sliceA长度 4  sliceA容量 4
		 sliceA: [1 2 3 4 5]   sliceA长度 5  sliceA容量 8		容量会翻倍
		 sliceA: [1 2 3 4 5 6]   sliceA长度 6  sliceA容量 8
		 sliceA: [1 2 3 4 5 6 7]   sliceA长度 7  sliceA容量 8
		 sliceA: [1 2 3 4 5 6 7 8]   sliceA长度 8  sliceA容量 8
		 sliceA: [1 2 3 4 5 6 7 8 9]   sliceA长度 9  sliceA容量 16     容量会翻倍
		 sliceA: [1 2 3 4 5 6 7 8 9 10]   sliceA长度 10  sliceA容量 16
		 sliceA: [1 2 3 4 5 6 7 8 9 10 11]   sliceA长度 11  sliceA容量 16
		 sliceA: [1 2 3 4 5 6 7 8 9 10 11 12]   sliceA长度 12  sliceA容量 16
		 sliceA: [1 2 3 4 5 6 7 8 9 10 11 12 13]   sliceA长度 13  sliceA容量 16
		 sliceA: [1 2 3 4 5 6 7 8 9 10 11 12 13 14]   sliceA长度 14  sliceA容量 16
		 sliceA: [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15]   sliceA长度 15  sliceA容量 16
		 sliceA: [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16]   sliceA长度 16  sliceA容量 16
		 sliceA: [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17]   sliceA长度 17  sliceA容量 32	   容量会翻倍
		 sliceA: [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18]   sliceA长度 18  sliceA容量 32
		 sliceA: [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19]   sliceA长度 19  sliceA容量 32
		 sliceA: [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20]   sliceA长度 20  sliceA容量 32
	*/
}
```
## 使用copy()函数 复制slice
切片就是引用数据类型
```
func main() {
	var sliceA = []int{1, 2, 3, 4, 5, 6}
	sliceB := sliceA
	sliceB[0] = 11
	fmt.Printf("sliceA: %v\n", sliceA)
	fmt.Printf("sliceB: %v\n", sliceB)
	/*
		sliceA: [11 2 3 4 5 6]
		sliceB: [11 2 3 4 5 6]
		当sliceB 修改时 sliceA 内容也更改了
	*/
}
sliceA 与 sliceB 使用同一个存储空间
```
使用 copy 函数来复制 slice 切片
```
func main() {
	var sliceA = []int{1, 2, 3, 4, 5, 6}
	sliceACopy := make([]int, len(sliceA))
	copy(sliceACopy, sliceA)
	fmt.Printf("sliceA: %v\n", sliceA)
	fmt.Printf("sliceACopy: %v\n", sliceACopy)
	sliceA[0] = 11 //修改 sliceA[0] 为 11
	//输出 sliceA  and sliceACopy
	fmt.Printf("sliceA: %v\n", sliceA)
	fmt.Printf("sliceACopy: %v\n", sliceACopy)
	/*
		sliceA: [1 2 3 4 5 6]
		sliceACopy: [1 2 3 4 5 6]
		copy 修改后
		sliceA: [11 2 3 4 5 6]
		sliceACopy: [1 2 3 4 5 6]
	*/
}
```

## 从切片中删除元素
go 语言中并没有删除切片元素的专用方法,我们可以使用切片本身的特性来删除元素。
```
func main() {
	var sliceA = []int{1, 2, 3, 4, 5, 6}
	//删除下标为2的数据  
	sliceA = append(sliceA[:2], sliceA[3:]...) // 注意append 的参数后面的...
	fmt.Printf("sliceA: %v\n", sliceA)
	//sliceA: [1 2 4 5 6]
}
```