1.简介

切片是数组的一个引用，因此切片是引用类型，在进行传递时，遵守引用传递的机制。切片的使用和数组类似，遍历切片、访问切片的元素和切片的长度都一样。。切片的长度是可以变化的，因此切片是一个可以动态变化的数组。

2.切片的定义基本语法

var 切片名 []类型

比如：var a []int

3.切片的初始化

3.1方式一

第一种方式：定义一个切片，然后让切片去引用一个已经创建好的数组。

    var arr = [...]int{1, 2, 3, 4, 5, 6}slice := arr[1:3]slice[0] = 100fmt.Println("arr:", arr)fmt.Println("slice:", slice)fmt.Println("slice长度:", len(slice))fmt.Println("slice容量:", cap(slice))

结果：

arr: [1 100 3 4 5 6]
slice: [100 3]
slice长度: 2
slice容量: 5

根据上面结果分析：切片的确是一个引用类型，改变slice的值会影响原数组。

其实切片底层其实就是一个数据结构

type slice struct{

ptr *[2]int

len int

cap int  }

3.2方式二

第二种方式：通过make来创建切片。

基本语法：var 切片名 []type=make([]type ,len,cap)

参数说明：type：就是数据类型 len：大小 cap：值切片的容量，可选，如果你分配了cap，则要求cap>=len。

    var SliceA = make([]int, 5, 6)SliceA[0] = 1fmt.Println(SliceA) //[0 0 0 0 0]fmt.Printf("长度：%d-容量%d", len(SliceA), cap(SliceA))

结果：

[1 0 0 0 0]
长度：5-容量6

对上面代码小结：

1.通过make方式创建切片可以指定切片的大小和容量。

2.如果没给切片的各个元素赋值，那么就会使用使用默认值 int 0 float 0  string “” bool false。

3.通过make方式船舰的切片对应的数组由make底层维护，对外不可见，即只能通过slice去访问各个元素。

3.3方式三

定义一个切片，直接指定具体的数组，使用原理类似make的方式。

    var strSlice = []string{"java", "php", "golang"}fmt.Println(strSlice)fmt.Printf("类型：%T\n", strSlice)fmt.Println("长度：", len(strSlice))fmt.Println("容量：", cap(strSlice))

 结果：

[java php golang]
类型：[]string
长度： 3
容量： 3

3.4方式一和方式二的区别

1.方式一是直接引用数组，这个数组是事先存在的，程序员可见的。

2.方式二是通过make来创建切片，make也会船舰一个数组，是由七篇在底层进行维护的，程序员是看不见的。make创建切片的示意图：

4.切片的扩容 

4.1append扩容

声明一个切片，golang中没办法通过下标方式给切片扩容,需要用到append()方法.比如

    var sliceB []intsliceB[0] = 2 //golang中没办法通过下标方式给切片扩容,需要用到append()方法.

会报错：panic: runtime error: index out of range [0] with length 0

    var sliceB []intsliceB = append(sliceB, 1)sliceB = append(sliceB, 123, 35, 67)fmt.Println(sliceB)fmt.Printf("长度：%v-容量：%v-%v-%T\n", len(sliceB), cap(sliceB), sliceB, sliceB)

结果：

[1 123 35 67]
长度：4-容量：4-[1 123 35 67]-[]int

4.2append方法合并切片

    sliceC := []string{"java", "go", "php"}sliceD := []string{"javad", "god", "phpd"}sliceC = append(sliceC, sliceD...)fmt.Println(sliceC)

 结果：

[java go php javad god phpd]

4.3切片的copy

已知切片是引用类型，更改切片的值会影响其他使用该切片的地方。

    sliceA := []string{"java", "php"}sleceB := sliceAvar sliceC = make([]string, 2, 2)//copy()切片的复制copy(sliceC, sliceA)sleceB[0] = "golang"fmt.Println("sliceA:", sliceA)fmt.Println("sleceB:", sleceB)fmt.Println("sliceC:", sliceC)

结果：由结果可以看出，当sliceB改变了，对sliceC没有任何影响。

sliceA: [golang php]
sleceB: [golang php]
sliceC: [java php]

4.4切片的删除

删除下标为二的数据。

a := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}a = append(a[:2], a[3:]...)fmt.Println(a)

 结果：

[1 2 4 5 6 7 8 9 0]

 4.5切片cap容量的理解

切片的容量是从他的第一个元素开始数，到其底层数组元素末尾的个数。

示例1：

    a := [8]int{0, 1, 2, 3, 4, 5, 6, 7} // 引用的底层数组s1 := a[0:5]fmt.Printf("长度：%v-容量：%v\n", len(s1), cap(s1))

结果：由结果可知长度5容量8，a[0:5],从数组a第一个下标一直数到a数组的末尾个数0-7即cap=8.

长度：5-容量：8

 

 示例2：

    a := [8]int{0, 1, 2, 3, 4, 5, 6, 7} // 引用的底层数组s2 := a[3:6]fmt.Printf("长度：%v-容量：%v\n", len(s2), cap(s2))

结果：由结果可知长度3容量5，a[3:6],从数组a第一个下标一直数到a数组的末尾个数3-7即cap=5.

长度：3-容量：5

5.切片的遍历 

切片的遍历和数组一样，也有两种方式。

方式1：

for i := 0; i < len(slice); i++ {fmt.Println(slice[i])}

方式2：

    slice := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}for _, value := range slice {fmt.Println(value)}

结果：

1
2
3
4
5
6
7
8
9

6.切片的使用注意事项和细节讨论

7.1切片初始化是var slice=arr[stratIndex:endIndex]

说明：从arr数组小标围殴startIndex，取到下标为endIndex的元素，不包含arr[endIndex]

7.2切片初始化是，仍然不能越界。范围在[0-len(arr)]之间，但可以动态增长。

参考4.1append扩容

7.3cap是一个内置函数，用于统计切片的容量，即最大可以存放多少个元素。

 参考：4.5切片cap容量的理解

7.4切片定义完后，还不能直接使用，因为本身是一个空的，需要让你、昂起引用到一个数组，或者，make 一个空间供切片使用。

7.5切片可以继续切片

	A := []int{1, 2, 3, 4, 5, 6, 7, 8}B := A[3:8]C := A[:5]fmt.Println("B:", B)fmt.Println("C:", C)

结果：

B: [4 5 6 7 8]
C: [1 2 3 4 5]

7.6append()内置函数，可以对切片进行动态追加

用法：参考4.1、4.2

 切片append操作的底层原理分析：

切片append操作的本质就是对数组扩容，go底层会创建新的数组newArr（安装扩容后的大小），

将slice原来包含的元素拷贝到新的数组newArr，slice重新引用到newArr，注意newarr是底层来维护的，程序员不可见。

7.7 关于拷贝的注意事项

var a []int = []int{1, 2, 3, 4, 5}var slice = make([]int, 1)copy(slice, a)fmt.Println(slice)

结果：

[1]

说明，上面代码没有问题，可以运行，最后输出的是[1]