数组：

语法：

//value := [数据长度]类型 {}

arr := [1]string{"1"}// 声明并且赋值

arr = [1]string{}// 声明未赋值
arr[0]="1"

数组类型的值（以下简称数组）的长度是固定的数组的长度在声明它的时候就必须给定，并且在之后不会再改变。可以说，数组的长度是其类型的一部分（数组的容量永远等于其长度，都是不可变的）

切片：

语法：

//value := []类型 {}

// 创建长度容量都为0的切片
value :=[]string{}// []string{"1"} 长度容量为1的切片
value :=append(value,"1")

//数据转切片
arr := [1]string{"1"}
slice :=arr[:]

// 创建长度容量为1的切片
slice = make([]string, 1)
// 创建长度为1，容量为2的切片
slice = make([]string, 1，2)

切片类型的值是可变长的。而切片的类型字面量中只有其元素的类型，而没有其长度。切片的长度可以自动地随着其中元素数量的增长而增长，但不会随着元素数量的减少而减少。

在每一个切片的底层数据结构中，会包含一个数组，可以被叫做底层数据，而切片就是对底层数组的引用，故而切片类型属于引用类型

切片理解

底层数据类似一个窗户，窗户的宽度就类似与底层数据的长度，而切片就是窗口（该窗口只能往一个方向移动），可以通过该窗口看到一个数组，但不一定能看到该数组中所有的元素，有时候只能看待连续的一部分元素

代码：

/*
// 切片的结构体
type slice struct {
    array unsafe.Pointer // 底层数据的指针
    len   int // 切的长度
    cap   int // 截取底层数据的容量
}

*/

arr := [8]int{1, 2, 3, 4, 5, 6, 7, 8}//定义一个数组，作为底层数组
/*
    进行切片操作，将 索引为3开始到后面的元素截取出来
    sli := slice{
        array: unsafe.Pointer(&arr),
        len:   6 - 3,
        cap:   cap(arr) - 3,
    }
    sli容量 表示arr中的 { 4, 5, 6, 7, 8}这部分元素
    sli：表示arr中的 {4，5，6}，因为长度是3 就取容量表示的三个元素
*/

sli := arr[3:6]
fmt.Printf("slice: %d\n", sli)//slice: [4 5 6

/*
    再进行切片操作的时候，
    sli[:cap(sli)]
    slitemp := slice{
        array: unsafe.Pointer(&sli),
        len:   cap(sli) - 0, // 5 -0
        cap:   cap(arr) - 0,// 5-0
    }
    slitemp: 表示arr中的 { 4, 5, 6, 7, 8}这部分元素

*/
fmt.Printf("slice: %d\n", sli[:cap(sli)])//slice: [4 5 6 7 8]

共同点：

都属于集合类的类型，它们的值也都可以用来存储某一种类型的值（或者说元
素）。

扩展：

一个切片无法容纳更多的元素，Go 语言就会想办法扩容。但它并不会改变原来的切片，而
是会生成一个容量更大的切片，然后将把原有的元素和新元素一并拷贝到新切片中。
在一般的情况下，你可以简单地认为新切片的容量（以下简称新容量）将会是原切片容量（以下
简称原容量）的 2 倍。
但是，当原切片的长度（以下简称原长度）大于或等于1024时，Go 语言将会以原容量的1.25
倍作为新容量的基准（以下新容量基准）。
新容量基准会被调整（不断地与1.25相乘），直到结果不小于原长度与要追加的元素数量之和
（以下简称新长度）。

只要新长度不会超过切片的原容量，那么使用append函数对其追加元素的时候就
不会引起扩容。这只会使紧邻切片窗口右边的（底层数组中的）元素被新的元素替换掉。