GO的Slice切片是如何工作的

介绍

首先这么想，GO有数组，但长度是固定的，而且数组是值类型，赋值和传参都是整体复制数据，当然你可以使用数组的指针作为参数来传递，但是他仍然不是动态的，你可以重新定义数组，但那太繁琐，而且对于GO语言来说，不同长度的数组指针类型是不同的！！！。GO中切片作用类似于动态数组，但又有不同，更像是类，这个类包含一个数组头指针，数组长度和数组容量三个字段，当然，对于go来说，这是个特殊的类。你可以用切片来存储一组数量动态变化的数据。下面用一段代码来描述数组和切片的传递。

type slice struct {
    array unsafe.Pointer
    len   int
    cap   int
}

这里的unsafe.Pointer是特别定义的一种指针类型，它可以包含任意类型变量的地址（类似 C 语言中的 void 类型指针）。Go 官方文档对这个类型有如下四个描述：

    任何类型的指针都可以被转化为 unsafe.Pointer；

    unsafe.Pointer 可以被转化为任何类型的指针；

    uintptr 可以被转化为 unsafe.Pointer；

    unsafe.Pointer 可以被转化为 uintptr。

这里我就不过多介绍了，反正这个指针很特别,用了这个再加上uintptr后在go里就可以随意操纵地址了，所以很不安全。

再介绍另一个类型，uintptr这个类型可以存储指针并且对指针进行运算。

数组和切片参数传递代码

package main
import "fmt"
func main() {
    arrayA := [2]int{100, 200}
	fmt.Printf("%p,%p\n",&arrayA,&arrayA[0])
    testArrayPoint1(&arrayA)   // 1.传数组指针
    arrayB := arrayA[:]
	fmt.Printf("%p,%p\n",&arrayB,&arrayB[0])
    testArrayPoint2(&arrayB)   // 2.传切片
    fmt.Printf("arrayA : %p , %v\n", &arrayA, arrayA)
}
func testArrayPoint1(x *[2]int) {
	fmt.Printf("func Array : %p , %T,%p\n", x, *x,&((*x)[0]))
    (*x)[1] += 100
}
func testArrayPoint2(x *[]int) {
	fmt.Printf("func Array : %p ,%T, %p\n", x, *x,&((*x)[0]))
    (*x)[1] += 100
}

执行结果如下：，其中%p表示输出地址，%T表示输出数据类型，%v输出值，可以看到数组的地址就是数组首个元素的地址，但是切片不是，切片地址和切片包含的首个元素的地址不一样，而是切片创建时引用的数组的地址，这里也说明了切片创建是对原数组的一个引用。

 空切片和nil切片

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

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

package main

import (
	"fmt"

)
func main(){
	var slicenil []int
	slicekong := make([]int,0)//或者slice := []int{}
	fmt.Println(slicenil)
	fmt.Println(slicekong)
	fmt.Printf("%p,%p,%p,%p",&slicenil,slicenil,&slicekong,slicekong)


}

 运行结果：同样为空，但是nil没有指定切片引用的数组。

切片扩容

切片的扩容其实没有什么特殊，就是创建一个容量更大的数组，然后把切片引用的数组替换成这个数组，元素进行copy。

主要在于其规则：

Go 中切片扩容的策略是这样的：

如果切片的容量小于 1024 个元素，于是扩容的时候就翻倍增加容量。

一旦元素个数超过 1024 个元素，那么增长因子就变成 1.25 ，即每次增加原来容量的四分之一。

注意：扩容扩大的容量都是针对原来的容量而言的，而不是针对原来数组的长度而言的。

但是有一个时候是特别的，那就是当切片引用一个数组时，用append添加元素却不超过容量时，这个时候我们发现slice和newslice引用的还是一个数组，而两者的操作都会映射到原数组上去，wcao，恐怖，

其实就是因为原数组还有容量可以扩容，所以执行 append() 操作以后，会在原数组上直接操作，所以这种情况下，扩容以后的数组还是指向原来的数组。

例如slice虽然两个元素但事实容量是4，想想把，只有容量超了才会创建新数组，不然就是原数组。

package main

import (
	"fmt"

)

func main() {
    array := [4]int{10, 20, 30, 40}
    slice := array[0:2]
    newSlice := append(slice, 50)
    fmt.Printf("Before slice = %v, Pointer = %p, len = %d, cap = %d\n", slice, &slice, len(slice), cap(slice))
    fmt.Printf("Before newSlice = %v, Pointer = %p, len = %d, cap = %d\n", newSlice, &newSlice, len(newSlice), cap(newSlice))
    newSlice[1] += 10
    fmt.Printf("After slice = %v, Pointer = %p, len = %d, cap = %d\n", slice, &slice, len(slice), cap(slice))
    fmt.Printf("After newSlice = %v, Pointer = %p, len = %d, cap = %d\n", newSlice, &newSlice, len(newSlice), cap(newSlice))
    fmt.Printf("After array = %v\n", array)
}

 

 切片COPY

其实这里倒是没啥坑，就是简单的copy(drcslice,sourecslice)

然后选择二者中短的那个的元素个数进行元素的复制copy。