为什么用切片？

  1. 数组的容量固定，不能自动拓展。
    2. 值传递。 数组作为函数参数时，将整个数组值拷贝一份给形参。

在Go语言当，我们几乎可以在所有的场景中，，使用 切片替换数组使用，数据结构是切片，即动态数组，其长度并不固定。

我们可以向切片中追加元素，它会在容量不足时自动扩容。

切片的本质

不是一个数组的指针，是一种数据结构体，用来操作数组内部元素。

https://github.com/golang/go/blob/3b2a578166/src/runtime/slice.go

  1. type slice struct {
  2.     array unsafe.Pointer
  3.     len   int
  4.     cap   int
  5. }

切片数据结构

Go中的slice依赖于数组，它的底层就是数组，所以数组具有的优点，slice都有。

且slice支持可以通过append向slice中追加元素，长度不够时会动态扩展，通过再次slice切片，可以得到得到更小的slice结构，可以迭代、遍历等。

编译期间的切片是 cmd/compile/internal/types.Slice 类型的，但是在运行时切片可以由如下的 reflect.SliceHeader 结构体表示，其中:

  • Data 是指向数组的指针;
  • Len 是当前切片的长度；
  • Cap 是当前切片的容量，即 Data 数组的大小：
  1. type SliceHeader struct {     
  2.     Data uintptr     
  3.     Len  int     
  4.     Cap  int 
  5. }

Data 是一片连续的内存空间，这片内存空间可以用于存储切片中的全部元素，数组中的元素只是逻辑上的概念，底层存储其实都是连续的，所以我们可以将切片理解成一片连续的内存空间加上长度与容量的标识。

  1. slice := []int{10, 20, 30, 0, 0}

image.png

声明

在 Go 语言中，切片类型的声明方式与数组有一些相似，不过由于切片的长度是动态的，所以声明时只需要指定切片中的元素类型：

  1. []int
  2. []interface{}

数组和切片的声明方式区别

使用字面量来声明切片时，其语法与使用字面量声明数组非常相似。
二者的区别是：

  • [] 运算符里指定值，创建数组

  • [] 中不指定值，创建切片。

    1. myArray := [3]int{10, 20, 30}         // 创建有 3 个元素的整型数组
    2. myArray := [...]int{10, 20, 30}    // 创建有 3 个元素的整型数组 通过初始化元素的个数确定数组长度
    4. mySlice := []int{10, 20, 30}          // 创建长度和容量都是 3 的整型切片

    创建切片

    通过 make() 函数创建切片
    通过字面量创建切片

Go 语言中包含三种初始化切片的方式：

  1. make 创建切片
  2. 字面量 创建切片
  3. 从数组创建切片

make 创建切片

make() 比new()函数多一些操作

  • new()函数只会进行内存分配并做默认的赋0初始化
  • make()可以先为底层数组分配好内存，然后从这个底层数组中再额外生成一个slice并初始化。
  • make只能构建slice、map和channel这3种结构的数据对象，因为它们都指向底层数据结构，都需要先为底层数据结构分配好内存并初始化

语法：

  1. func make(Type, size ...IntegerType) Type
  1. Type 切片类型
  2. size 切片长度 ，实际存储元素的数量，只有在长度的范围内才会初始化零值
  3. 第三个参数为容量，容量是指最多能存储多少个数据

注意事项：

  1. 长度必须<=容量
  2. 通过下标只能读写长度范围内的数据
  3. 只能通过append向切片追加数据 ```go / 创建一个length和capacity都等于5的slice slice := make([]int,5)

// length=3,capacity=5的slice slice := make([]int,3,5)

  1. <a name="YbEXK"></a>
  2. ## 字面量创建切片
  3. 如果使用字面量的方式创建切片，大部分的工作都会在编译期间完成
  4. ```go
  5. // 创建长度和容量都为4的slice，并初始化赋值
  6. colorSlice := []string{"red","blue","black","green"}
  8. // 创建长度和容量为100的slice，并为第100个元素赋值为3
  9. slice := []int{99:3}

从数组创建切片

语法

  1. var sliceName = arr[index1:index2]

参数

参数 描述
var 定义切片变量使用的关键字
sliceName 切片变量名
arr 数组名
index1 数组的开始索引
index2 数组的结束索引

说明
创建一个切片 sliceName，该切片元素的内容是从数组 arr 的索引 index1 开始到索引 index2 结束。

  1. //array直接就是slice的底层数组
  2. array := [...]int{1,2,3}
  4. slice := array[start:end] //左闭右开， array[start]~array[end-1]
  5. slice := array[start:] //array[start]~最后一个元素
  6. slice := array[:end] //第一个元素~array[end-1]
  7. slice := array[:] //全部的array元素
  • 切片长度: 切片对应数组片段的长度
  • 切片容量: 切片第一个元素在数组中的起始位置到数组最后一个元素的长度

切片的长度(len) & 容量(cap) & 遍历

长度 & 容量

  • len n := len(slice)
  • cat n := cap(slice)

遍历

for

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

通过 len 函数，获取切片元素的个数，然后通过 for 循环加索引的形式获取每一个切片元素的值。

for range

通过 for range 的形式来遍历切片元素:

  • index 即是切片的索引
  • value 是切片的索引 index 处对应的切片的值

如果我们不需要索引或者值，可以通过 _ 的形式忽略。

  1. for index, value := range sliceHaiCoder{
  3. }
  5. for _, value := range sliceHaiCoder{
  7. }
  1. package main
  3. import (
  4.     "fmt"
  5.     "reflect"
  6. )
  8. func main()  {
  9.     color := []string{"red","blue","black","green"}
  10.     fmt.Println("color:", color)
  11.     fmt.Printf("len = %d, cap = %d\n", len(color), cap(color))
  12.     // 遍历切片 空切片 不会有任元素
  13.     for i := 0; i < len(color); i++ {
  14.         fmt.Printf("color[%d] = %q\n", i, color[i])
  15.     }
  17.     // 获取切片类型
  18.     fmt.Println("color type =", reflect.TypeOf(color))
  20.     /**
  21.     color: [red blue black green]
  22.     len = 4, cap = 4
  24.     color[0] = "red"
  25.     color[1] = "blue"
  26.     color[2] = "black"
  27.     color[3] = "green"
  29.     color type = []string
  30.     */
  34.     list := []int{}
  35.     fmt.Println("list:", list)
  36.     fmt.Printf("len = %d, cap = %d\n", len(list), cap(list))
  38.     // 遍历切片 空切片不会有任何打印，空数组会打印类型的默认值
  39.     for index,value := range list {
  40.         fmt.Printf("list[%d] = %d\n", index, value)
  41.     }
  43.     /**
  44.     list: []
  45.     len = 0, cap = 0
  46.     */
  50.     list2 := []int{4:100}
  51.     fmt.Println("list2:", list2)
  52.     fmt.Printf("len = %d, cap = %d\n", len(list2), cap(list2))
  54.     // 遍历切片
  55.     for index,value := range list2 {
  56.         fmt.Printf("list2[%d] = %d\n", index, value)
  57.     }
  59.     /**
  60.     list2: [0 0 0 0 100]
  61.     len = 5, cap = 5
  63.     list2[0] = 0
  64.     list2[1] = 0
  65.     list2[2] = 0
  66.     list2[3] = 0
  67.     list2[4] = 100
  68.     */
  69. }

切片的截取

通过切片创建新的切片

  1. slice[start:end]
  2. slice[start:end:max]
  • start 表示从 slice 的第几个元素开始切
  • end 控制切片的长度 len = end-start
  • max 控制切片的容量 cap = max-start 如果没有给定 max，则表示切到底层数组的最尾部

下面是几种常见的简写形式：

  1. slice[start:]   // 从 start 切到最尾部
  2. slice[:end]  // 从最开头切到 end(不包含 end)
  3. slice[:]      // 从头切到尾，等价于复制整个 slice
  1. // 创建一个整型切片
  2. // 其长度和容量都是 5 个元素
  3. myNum := []int{10, 20, 30, 40, 50}
  5. // 创建一个新切片
  6. // 其长度为 2 个元素 len=3-1，容量为 4 个元素 cap=5-1
  7. newNum := myNum[1:3]
  1. package main
  3. import "fmt"
  5. func main() {
  7.     // 整切切片 array
  8.     array := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
  10.     // 复制整个切片
  11.     slice1 := array[:]
  12.     fmt.Println("slice1 = ", slice1)
  13.     fmt.Printf("slice1 len = %d, slice1 cap = %d\n", len(slice1), cap(slice1))
  15.     /**
  16.     slice1 =  [0 1 2 3 4 5 6 7 8 9]
  17.     slice1 len = 10, slice1 cap = 10
  18.     */
  21.     // 从下标第2个位置开始截取所有元素
  22.     slice2 := array[2:]
  23.     fmt.Println("slice2 = ", slice2)
  24.     fmt.Printf("slice2 len = %d, slice2 cap = %d\n", len(slice2), cap(slice2))
  25.     /**
  26.     slice2 =  [2 3 4 5 6 7 8 9]
  27.     slice2 len = 8, slice2 cap = 8
  28.     */
  30.     // 从下标0开始，截取到第2个元素
  31.     // len=2-0 cap=10-0
  32.     slice3 := array[:2]
  33.     fmt.Println("slice3 = ", slice3)
  34.     fmt.Printf("slice3 len = %d, slice3 cap = %d\n", len(slice3), cap(slice3))
  35.     /**
  36.     slice3 =  [0 1]
  37.     slice3 len = 2, slice3 cap = 10
  38.     */
  41.     //a[3], a[4], a[5]   len = 6-3=3    cap = 7-3=4
  42.     slice4 := array[3:6:7]
  43.     fmt.Println("slice4 = ", slice4)
  44.     fmt.Printf("slice4 len = %d, slice4 cap = %d\n", len(slice4), cap(slice4))
  46.     /*
  47.     slice4 =  [3 4 5]
  48.     slice4 len = 3, slice4 cap = 4
  49.     */
  51.     // len=3-1 cap=10-1
  52.     slice5 := array[1:3]
  53.     fmt.Println("slice5 = ", slice5)
  54.     fmt.Printf("slice5 len = %d, slice5 cap = %d\n", len(slice5), cap(slice5))
  55.     /**
  56.     slice5 =  [1 2]
  57.     slice5 len = 2, slice5 cap = 9
  58.     */
  59. }

切片访问

  1. // 访问单个切片元素 
  2. sliceName[index] // 获取切片 sliceName 的索引为 index 处的元素
  4. //索引切片获取切片元素
  5. sliceName[start:end] // index1 开始索引 结束索引
  1. package main
  3. import "fmt"
  5. func main()  {
  6.     //使用索引的形式，访问单个切片元素
  7.     var goFrameList = []string{"gin", "go-frame", "beego"}
  8.     for i:=0; i<len(goFrameList); i++ {
  9.         // slice[0] slice[1] slice[2]
  10.         fmt.Printf("slice[%d]=%q\n", i, goFrameList[i])
  11.     }
  13.     /**
  14.     slice[0]="gin"
  15.     slice[1]="go-frame"
  16.     slice[2]="beego"
  17.     */
  20.     // 索引切片获取切片元素
  21.     list := goFrameList[0:2]
  22.     fmt.Println("list =", list)
  23.     /**
  24.     list = [gin go-frame]
  25.     */
  27.  }

添加 删除 复制

append函数详解

语法

  1. func append(slice []Type, elems ...Type) []Type

参数

参数 描述
slice 要追加元素的切片。
elems 要追加的元素列表。

返回值

返回追加元素之后的切片。

说明

append 函数的

  1. 第一个参数是需要被添加元素的切片
  2. 第二个参数是一个 可变参数，传入任意个数的切片的元素
  3. 最后返回一个新的切片

添加

  1. package main
  3. import "fmt"
  5. func main()  {
  7.     goFrameList := []string{"Gin", "Go-frame", "Beego"}
  9.     goFrameList = append(goFrameList, "Martini")
  11.     fmt.Println("goFrameList", goFrameList) //goFrameList [Gin Go-frame Beego Martini]
  14.     // 添加多个元素
  15.     goFrameList = append(goFrameList, "Iris", "Echo")
  16.     fmt.Println("goFrameList", goFrameList) //goFrameList [Gin Go-frame Beego Martini Iris Echo]
  18.     //添加一个切片 相当于尾部添加
  19.     // append 函数的第二个参数是一个可变参数，要在追加的切片 appendSlice 末尾加上 …
  20.     goFrameList = append(goFrameList, []string{"ueumd", "yuque"}...)
  21.     fmt.Println("goFrameList", goFrameList) //goFrameList [Gin Go-frame Beego Martini Iris Echo ueumd yuque]
  24.     // 在切片头部添加元素
  25.     goFrameList = append([]string{"Golang"}, goFrameList...)
  26.     fmt.Println("goFrameList", goFrameList)
  28.     // 在index处插入切片
  29.     js := []string{"Vue","React"}
  30.     goFrameList = append(goFrameList[:1], append(js, goFrameList[1:]...)...)
  31.     fmt.Println("goFrameList", goFrameList)
  33.     /**
  34.     goFrameList [Gin Go-frame Beego Martini]
  35.     goFrameList [Gin Go-frame Beego Martini Iris Echo]
  36.     goFrameList [Gin Go-frame Beego Martini Iris Echo ueumd yuque]
  37.     goFrameList [Golang Gin Go-frame Beego Martini Iris Echo ueumd yuque]
  38.     goFrameList [Golang Vue React Gin Go-frame Beego Martini Iris Echo ueumd yuque]
  40.     */
  41. }

删除

Go 语言 的 切片 删除元素使用 append 函数 来间接的实现。

删除索引 index 处的元素

  1. slice = append(slice[:index], slice[index+1:]...)

删除索引 start 到 end 处的元素

  1. slice = append(slice[:start], slice[end:]...)
  1. package main
  3. import "fmt"
  5. func main()  {
  7.     goFrameList := []string{"Gin", "Go-frame", "Beego", "Martini", " Iris", "Echo"}
  9.     // 删除索引 index 处的元素 Go-frame
  10.     goFrameList = append(goFrameList[:1], goFrameList[1+1:]...)
  11.     fmt.Println("goFrameList", goFrameList) // goFrameList [Gin Beego Martini  Iris Echo]
  13.     // 删除索引 start 到 end 处的元素 删除 Beego Martini
  14.     goFrameList = append(goFrameList[:1], goFrameList[3:]...)
  15.     fmt.Println("goFrameList", goFrameList) //goFrameList [Gin  Iris Echo]
  17.     /**
  18.     goFrameList [Gin Beego Martini  Iris Echo]
  19.     goFrameList [Gin  Iris Echo]
  20.     */
  21. }

切片作为函数参数

前面说过，虽然slice实际上包含了3个属性，它的数据结构类似于[3/5]0xc42003df10，但仍可以将slice看作一种指针。这个特性直接体现在函数参数传值上。

Go中函数的参数是按值传递的，所以调用函数时会复制一个参数的副本传递给函数。

如果传递给函数的是slice，它将复制该slice副本给函数，这个副本实际上就是[3/5]0xc42003df10，所以传递给函数的副本仍然指向源slice的底层数组。

  1. package main
  3. import "fmt"
  5. func main()  {
  6.     slice := []int{1, 2, 3, 4, 5}
  7.     fmt.Println("slice:", slice)
  8.     fmt.Printf("&slice: %p\n", &slice) 
  10.     fmt.Println("\n------修改后-----\n")
  13.     modifySlice(&slice)
  14.     fmt.Println("slice:", slice)
  16.     add(slice)
  17.     fmt.Println("slice:", slice)
  19.     /**
  20.     slice: [1 2 3 4 5]
  21.     &slice: 0xc000194000
  23.     ------修改后-----
  25.     &slice: 0xc00018a020
  26.     slice: [1 200 3 4 5]
  27.     slice: [2 201 4 5 6]
  28.     */
  30. }
  32. func modifySlice(slice *[]int)  {
  33.     fmt.Printf("&slice: %p\n", &slice) 
  34.     (*slice)[1] = 200
  35. }
  37. func add(s []int) {
  38.     for index, _ := range s {
  39.         s[index] += 1
  40.     }
  41. }

打印结果里看出：

  • 两个切片的地址不一样，所以可以确认切片在函数间传递是复制的。
  • 而我们修改一个索引的值后，发现原切片的值也被修改了，说明它们共用一个底层数组。

在函数间传递切片非常高效，而且不需要传递指针和处理复杂的语法，只需要复制切片，然后根据自己的业务修改，最后传递回一个新的切片副本即可，这也是为什么函数间传递参数，使用切片，而不是数组的原因。
�

切片扩容

append函数会智能的增长底层数组的容量。目前的算法是：

  • 容量小于1000个时，总是成倍的增长
  • 容量超过1000个，增长因子设为1.25，也就是说每次会增加25%的容量

image.png

  1. package main
  2. import "fmt"
  4. func main() {
  5.     //如果超过原来的容量，通常以2倍容量扩容
  6.     slice := make([]int, 0, 1) //容量为1
  7.     oldCap := cap(slice)
  9.     for i := 0; i < 20; i++ {
  10.         slice = append(slice, i)
  11.         if newCap := cap(slice); oldCap < newCap {
  12.             fmt.Printf("cap: %d ===> %d\n", oldCap, newCap)
  13.             oldCap = newCap
  14.         }
  15.     }
  16. }
  18. /*
  19. cap: 1 ===> 2
  20. cap: 2 ===> 4
  21. cap: 4 ===> 8
  22. cap: 8 ===> 16
  23. cap: 16 ===> 32
  24. */

练习代码

  1. package main
  3. import (
  4.     "fmt"
  5.     "unsafe"
  6. )
  8. type slice struct {
  9.     array unsafe.Pointer // 指向数组的指针
  10.     len   int            //    切片中元素数量
  11.     cap   int            //    array 数组的总容量
  12. }
  14. // 深度拷贝: copy(sliceA, sliceB)
  15. // 浅拷贝: sliceA = sliceB
  17. // 1. 通过数组创建切片 array[startIndex:endIndex]
  18. func createSliceByArray() {
  19.     var arr = [5]int{1, 3, 5, 7, 9}
  21.     // 从数组0下标开始取,一直取到2下标前面一个索引
  22.     var sce1 = arr[0:2]
  23.     fmt.Println(sce1) //[1 3]
  25.     // 切片len = 结束位置 - 开始位置
  26.     fmt.Println(len(sce1)) //2 2-0 = 2
  28.     // 切片cap = 数组长度 - 开始位置
  29.     fmt.Println(cap(sce1)) //5 5-0=5
  31.     fmt.Printf("%p\n", &arr)
  32.     fmt.Printf("%p\n", &arr[0])
  34.     // 切片底层是指针数组，指向的是一块内存地址，前面无须加地址符号 &
  35.     fmt.Printf("%p\n", sce1)
  36. }
  38. // 2. 通过make函数创建 make([]类型, 长度, 容量)
  39. func createSliceByMake() {
  40.     var sce = make([]int, 3, 5)
  41.     fmt.Println(sce) //[0 0 0]
  42. }
  44. // 3. Go语法糖快速创建
  45. // 3.1 不能指长度
  46. // 3.2 长度和容量相等
  48. func createSliceByQuickly() {
  49.     // 这是数组 暗示长度
  50.     var arr = [...]int{1, 3, 5}
  51.     fmt.Println(arr)
  53.     // 这是切片
  54.     var sce = []int{1, 3, 5}
  55.     fmt.Println(sce)                // [1 3 5]
  56.     fmt.Println(len(sce), cap(sce)) // 3 3
  57. }
  59. /**
  60. append函数会在切片末尾添加一个元素, 并返回一个追加数据之后的切片
  61. 利用append函数追加数据时,如果追加之后没有超出切片的容量,那么返回原来的切片, 如果追加之后超出了切片的容量,那么返回一个新的切片
  62. append函数每次给切片扩容都会按照原有切片容量*2的方式扩容
  63. 如果希望切片自动扩容,那么添加数据时必须使用append方法
  64. 和数组一样, 如果通过切片名称[索引]方式操作切片, 不能越界
  65. 切片的基本使用方式和数组一样, 可以通过切片名称[索引]方式操作切片
  66. */
  67. func appendEle() {
  68.     sce := []int{0}
  69.     sce[0] = 1
  70.     fmt.Println(sce)
  72.     // append函数会在切片末尾添加一个元素, 并返回一个追加数据之后的切片
  73.     sce = append(sce, 200, 300, 400) // [1 200 300 400]
  74.     fmt.Println(sce)
  75. }
  77. func init() {
  78.     // createSliceByArray()
  79.     // createSliceByMake()
  80.     // createSliceByQuickly()
  81. }
  83. type ConfigBanWord struct {
  84.     Id  int
  85.     Txt string
  86. }
  88. // 这是一个切片 相当于一个指针数组，但不用初始化
  89. var configBanWordSlice []*ConfigBanWord
  91. // 这是一个指针数组 编译错误
  92. // var configBanWordArray [...]*ConfigBanWord
  93. // 只能这样定义，要初始化
  94. var configBanWordArray = [...]*ConfigBanWord {&ConfigBanWord{Id: 1, Txt: "外挂"}, &ConfigBanWord{Id: 5, Txt: "赚钱"}}
  95. func demo() {
  96.     configBanWordSlice = append(configBanWordSlice,
  97.         &ConfigBanWord{Id: 1, Txt: "外挂"},
  98.         &ConfigBanWord{Id: 2, Txt: "辅助"},
  99.         &ConfigBanWord{Id: 3, Txt: "微信"},
  100.         &ConfigBanWord{Id: 4, Txt: "代练"},
  101.         &ConfigBanWord{Id: 5, Txt: "赚钱"},
  102.     )
  104.     for index, data := range configBanWordSlice {
  105.         fmt.Println(index, data.Txt)
  106.         /**
  107.         0 外挂
  108.         1 辅助
  109.         2 微信
  110.         3 代练
  111.         4 赚钱
  112.          */
  113.     }
  115.     for index, data := range configBanWordArray {
  116.         /**
  117.         0 外挂
  118.         1 赚钱
  119.          */
  120.         fmt.Println(index, data.Txt)
  121.     }
  122. }
  124. func main() {
  125.     appendEle()
  126.     demo()
  127. }

参考：
https://www.cnblogs.com/f-ck-need-u/p/9854932.html
https://www.jianshu.com/p/354fce23b4f0
https://draveness.me/golang/docs/part2-foundation/ch03-datastructure/golang-array-and-slice/