Golang学习之路— 一文带你了解切片(slice）

切片的基本介绍

切片本身并不是动态数组或者数组指针。它内部实现的数据结构通过指针引用底层数组，设定相关属性将数据读写操作限定在指定的区域内。切片本身是一个只读对象，其工作机制类似数组指针的一种封装。

切片（slice）是对数组一个连续片段的引用，所以切片是一个引用类型（因此更类似于 C/C++ 中的数组类型，或者 Python 中的 list 类型）。这个片段可以是整个数组，或者是由起始和终止索引标识的一些项的子集。需要注意的是，终止索引标识的项不包括在切片内。切片提供了一个与指向数组的动态窗口。

给定项的切片索引可能比相关数组的相同元素的索引小。和数组不同的是，切片的长度可以在运行时修改，最小为 0 最大为相关数组的长度：切片是一个长度可变的数组。

切片定义的基本语法：

var 切片名[]类型
如：var a[]int

切片的快速入门

package main

import(
	"fmt"
)

func main(){
    
    

	var arr [5]int = [...]int{
    
    5,4,3,2,1}

	//定义一个切片
	//引用arr数组的起始下标为1，最后的下标为3（但不包括3）
	slice := arr[1:3]
	fmt.Println("arr=",arr)
	fmt.Println("slice 的元素是 =",slice)
	fmt.Println("slice 的元素个数 =",len(slice))
	fmt.Println("slice 的容量 =",cap(slice))//切片的容量是可以动态变化的

}

运行结果：

切片在内存中形式

切片的内存布局：

说明：

• slice是一个引用类型
• slice从底层来说，其实就是一个数据结构（struct结构体）

type slice struct{
    
    
   ptr *[2] int
   len int
   cap int
}

nil切片和空切片

nil切片和空切片也是常用的。

nil切片

var slice []int

nil 切片被用在很多标准库和内置函数中，描述一个不存在的切片的时候，就需要用到 nil 切片。比如函数在发生异常的时候，返回的切片就是 nil 切片。nil 切片的指针指向 nil。

空切片

空切片一般会用来表示一个空的集合。比如数据库查询，一条结果也没有查到，那么就可以返回一个空切片。

slice := make([]int, 0)
slice := []int{
    
    }

空切片和 nil 切片的区别在于，空切片指向的地址不是nil，指向的是一个内存地址，但是它没有分配任何内存空间，即底层元素包含0个元素。

最后需要说明的一点是。不管是使用 nil 切片还是空切片，对其调用内置函数 append，len 和 cap 的效果都是一样的。

切片的使用

方式1

定义一个切片，然后让切片去引用一个已经创建好的数组，比如前面的案例。

func main(){
    
    

	var arr [5]int = [...]int{
    
    5,4,3,2,1}

	//定义一个切片
	//引用arr数组的起始下标为1，最后的下标为3（但不包括3）
	slice := arr[1:3]
	fmt.Println("arr=",arr)
	fmt.Println("slice 的元素是 =",slice)
	fmt.Println("slice 的元素个数 =",len(slice))
	fmt.Println("slice 的容量 =",cap(slice))//切片的容量是可以动态变化的
}

方式2

通过make来创建切片。

基本语法：

var 切片名 []type = make([]type,len,[cap])

参数说明：

• type就是数据类型
• len:大小
• cap:指定切片容量，可选，如果分配了，则要求cap>=len

案例演示

package main

import(
	"fmt"
)

func main(){
    
    

   var slice []int = make([]int ,5,10)
   slice[1] = 10
   slice[2] = 20
   fmt.Println(slice)
   fmt.Println("slice的size =",len(slice))
   fmt.Println("slice的cap =",cap(slice))
}

运行结果：

说明：

• 通过make方式创建切片可指定切片的大小和容量
• 如果没有给切片的各个元素赋值，那么就是使用默认值。
• 通过make方式创建的切片对应的数组是由make底层维护，对外不可见，即只能通过slice去访问各个元素。

方式3

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

案例：

package main

import(
	"fmt"
)

func main(){
    
    

   var slice []string = []string{
    
    "Casey","Lily","Sally"}
   fmt.Println(slice)
   fmt.Println("slice的size =",len(slice))
   fmt.Println("slice的cap =",cap(slice))
}

运行结果：

方式1与方式2的区别（面试）

• 方式1是直接引用数组，这个数组是事先存在的，程序员可见的。
• 方式2是通过make来创建切片，make也会创建一个数组，是由切片在底层进行维护，程序员是看不见的。
  make创建切片的示意图：
  

切片的遍历

切片的遍历和数组一样，也是有两种方式，for循环常规方法遍历，for-range结构遍历切片。
案例演示：

package main

import(
	"fmt"
)

func main(){
    
    

  var slice []string = []string{
    
    "Casey","Lily","Sally"}
  //常规for循环遍历切片
  for i := 0; i < len(slice); i++{
    
    
	  fmt.Printf("slice[%d] = %v\n", i, slice[i])
  }

  //使用for-range结构遍历切片

  for index, value := range slice{
    
    
	  fmt.Printf("i = %v, v = %v\n", index, value)
  }

}

运行结果：

append内置函数对切片进行动态追加

案例演示

package main

import(
	"fmt"
)

func main(){
    
    

  var slice []string = []string{
    
    "Casey","Lily","Sally"}
  //通过append内置函数，可以对切片进行动态追加 
  slice = append(slice,"Jerry","Tom")
  fmt.Println("slice =",slice)

  //通过append将切片slice追加给slice
  slice = append(slice,slice...)
  fmt.Println("slice =",slice)

}

运行结果：

底层分析

示意图：

说明：

• 切片append操作的本质就是对数组扩容
• go底层会创建一个新的数组newArr(安装扩容后大小）
• 将slice原来包含的元素拷贝到新的数组newArr中，slice重新引用到newArr。

切片的拷贝操作

切片使用copy内置函数完成拷贝。
案例：

package main

import(
	"fmt"
)

func main(){
    
    

  var slice []string = []string{
    
    "Casey","Lily","Sally"}
  var slice1 = make([]string,5)
  copy(slice1,slice)
  fmt.Printf("slice = %v\n",slice)
  fmt.Printf("slice1 = %v\n", slice1)

  var slice2 []int = []int{
    
    10,20,30}
  var slice3 = make([]int,5)
  copy(slice3,slice2)
  fmt.Printf("slice2 = %v\n",slice2)
  fmt.Printf("slice3 = %v\n", slice3)

}

运行结果：

说明：

• copy(para1,para2)参数的数据类型是切片。
• 按照上面代码：slice和slice，slice2和slice3的数据空间是独立的，互不影响。

切片使用的注意事项

• 切片初始化时 var slice = arr[startIndex:endIndex]
  说明：从arr数组下标为startIndex，取到小标为endIndex的元素（不含endIndex）
• 切片初始化时，仍然不能越界，范围在0 ~ len(arr)-1,但是可以动态增长。

var slice = arr[0:end] 可简写 var slice = arr[:end]
var slice = arr[start:len(arr)]可简写var slice = arr[start:]
var slice = arr[0:len(str)] 可简写 var slice = arr[:]

• cap是一个内置函数，用于统计切片的容量，即最大可以存放多少个元素。
• 切片定义完后，还不能使用，因为本身是一个空的，需要让其引用到一个数组，或者make一个空间供切片来使用。
• 切片可以继续切片。
  案例：

package main

import(
	"fmt"
)

func main(){
    
    

  var slice []string = []string{
    
    "Casey","Lily","Sally"}
  slice1 := slice[0:2]
  //slice 和 slice1指向的数据空间是同一个，因此slice[1] = "abc"
  slice1[1] = "abc"

  fmt.Println("slice =",slice)
  fmt.Println("slice1 =",slice1)

}

运行结果：

• 切片是引用类型，在传递时，遵守引用传递机制。