数组是具有相同唯一类型的一组已编号且长度固定的数据项序列（这是一种同构的数据结构）；这种类型可以是任意的原始类型例如整型、字符串或者自定义类型。

数组长度必须是一个常量表达式，并且必须是一个非负整数。

数组长度也是数组类型的一部分，所以[5]int和[10]int是属于不同类型的。

一维数组

一维数组声明以及初始化常见方式如下：

var arrAge  = [5]int{18, 20, 15, 22, 16}
var arrName = [5]string{3: "Chris", 4: "Ron"} //指定索引位置初始化
                                              // {"","","","Chris","Ron"}

var arrCount = [4]int{500, 2: 100} //指定索引位置初始化 {500,0,100,0}

var arrLazy = [...]int{5, 6, 7, 8, 22} //数组长度初始化时根据元素多少确定

var arrPack = [...]int{10, 5: 100} //指定索引位置初始化，数组长度与此有关 {10,0,0,0,0,100}

var arrRoom [20]int

var arrBed = new([20]int)

数组在声明时需要确定长度，但是也可以采用上面不定长数组的方式声明，在初始化时会自动确定好数组的长度。上面 arrPack 声明中 len(arrPack) 结果为6 ，表明初始化时已经确定了数组长度。而arrRoom和arrBed这两个数组的所有元素这时都为0，这是因为每个元素是一个整型值，当声明数组时所有的元素都会被自动初始化为默认值 0。

Go 语言中的数组是一种值类型（不像 C/C++ 中是指向首元素的指针），所以可以通过 new() 来创建：

var arr1 = new([5]int)

那么这种方式和 var arr2 [5]int 的区别是什么呢？arr1 的类型是 *[5]int，而 arr2的类型是 [5]int。在Go语言中，数组的长度都算在类型里。

package main

import "fmt"

func main() {
    var arr1 = new([5]int)
    arr := arr1
    arr1[2] = 100
    fmt.Println(arr1[2], arr[2])

    var arr2 [5]int
    newarr := arr2
    arr2[2] = 100
    fmt.Println(arr2[2], newarr[2])
}

输出结果：

100 100
100 0

从上面代码结果可以看到，new([5]int)创建的是数组指针，arr其实和arr1指向同一地址，故而修改arr1时arr同样也生效。而newarr是由arr2值传递（拷贝），故而修改任何一个都不会改变另一个的值。在写函数或方法时，如果参数是数组，需要注意参数长度不能过大。

由于把一个大数组传递给函数会消耗很多内存（值传递），在实际中我们通常有两种方法可以避免这种现象：

• 使用数组的指针
• 使用切片

通常使用切片是第一选择。

多维数组

多维数组在Go语言中也是支持的，例如：

[...][5]int{ {10, 20}, {30, 40} }  // len() 长度根据实际初始化时数据的长度来定，这里为2
[3][5]int                          // len() 长度为3
[2][2][2]float64                   // 可以这样理解 [2]([2]([2]float64))

在定义多维数组时，仅第一维允许使用…，而内置函数len和cap也都返回第一维度长度。定义数组时使用…表示长度，表示初始化时的实际长度来确定数组的长度。

b := [...][5]int{ { 10, 20 }, { 30, 40, 50, 60 } }
fmt.Println(b[1][3], len(b)) //60 2

数组元素可以通过索引（下标）来读取（或者修改），索引从 0 开始，第一个元素索引为 0，第二个索引为 1，以此类推。（数组以 0 开始在所有类 C 语言中是相似的）。元素的数目，也称为长度或者数组大小必须是固定的并且在声明该数组时就给出（编译时需要知道数组长度以便分配内存）；数组大小最大为 2 GB。

遍历数组的方法既可以for条件循环，也可以使用 for-range。这两种 for 结构对于切片（slices）来说也同样适用。

另外，如数组元素类型支持==，!=操作符，那么数组也支持此操作，但如果数组类型不一样则不支持（需要长度和数据类型一致，否则编译不通过）。

切片（slice） 是对底层数组一个连续片段的引用，所以切片是一个引用类型。切片提供对该数组中编号的元素序列的访问。未初始化切片的值为nil。

与数组一样，切片是可索引的并且具有长度。切片s的长度可以通过内置函数len() 获取;与数组不同，切片的长度可能在执行期间发生变化。元素可以通过整数索引0到len(s)-1来寻址。我们可以把切片看成是一个长度可变的数组。

切片提供了计算容量的函数 cap() ，可以测量切片最大长度。切片的长度永远不会超过它的容量，所以对于切片 s 来说，这个不等式永远成立：0 <= len(s) <= cap(s)。

多个切片如果表示同一个数组的片段，它们可以共享数据；因此一个切片和相关数组的其他切片是共享存储的，相反，不同的数组总是代表不同的存储。数组实际上是切片的构建块。

切片可以延伸超过切片的末端，容量是切片长度与切片之外的数组长度的总和。

使用内置函数make()可以给切片初始化，该函数指定切片类型和指定长度和可选容量的参数。

注意 绝对不要用指针指向 slice。切片本身已经是一个引用类型，所以它本身就是一个指针!!

切片初始化：

var slice1 []type = arr1[start:end]
var x = []int{2, 3, 5, 7, 11}

make创建切片

当相关数组还没有定义时，我们可以使用 make() 函数来创建一个切片 同时创建好相关数组

slice1 := make([]type, len)
slice1 := make([]type, len, cap)

如果从数组或者切片中生成一个新的切片，我们可以使用下面的表达式：

a[low : high : max]

max-low的结果表示容量，high-low的结果表示长度。

切片重组

通过改变切片长度得到新切片的过程称之为切片重组 (reslicing)

slice1 := make([]type, start_length, capacity)

当我们在一个切片基础上重新划分一个切片时，新的切片会继续引用原有切片的数组。如果你忘了这个行为的话，在你的应用分配大量临时的切片用于创建新的切片来引用原有数据的一小部分时，会导致难以预期的内存使用。

简单说，有一个切片长度和容量都是10000，你现在却只需要使用其中的三个元素，如下所示：

package main

import "fmt"

func get() []byte {
    raw := make([]byte, 10000)
    fmt.Println(len(raw), cap(raw), &raw[0]) // 显示: 10000 10000 数组首字节地址
    return raw[:3]  // 10000个字节实际只需要引用3个，其他空间浪费
}

func main() {
    data := get()
    fmt.Println(len(data), cap(data), &data[0]) // 显示: 3 10000 数组首字节地址
}

上面的代码原因很简单，对切片进行切片，由于切片是引用类型，所以如果你原切片占用空间很多，而现在只需要一点点的数据，那么最好不要用切片，而应该用copy函数，将少部分的数据复制出来，这样就可以释放原切片空间。

func get() []byte {
    raw := make([]byte, 10000)
    fmt.Println(len(raw), cap(raw), &raw[0]) // 显示: 10000 10000 数组首字节地址
    res := make([]byte, 3)
    copy(res, raw[:3]) // 利用copy 函数复制，raw 可被GC释放
    return res
}

顺带说一下append内置函数：

func append(s S, x ...T) S  // T是S元素类型

append()函数将 0 个或多个具有相同类型S的元素追加到切片s后面并且返回新的切片；追加的元素必须和原切片的元素同类型。如果s的容量不足以存储新增元素，append()会分配新的切片来保证已有切片元素和新增元素的存储。

因此，append()函数返回的切片可能已经指向一个不同的相关数组了。append()函数总是返回成功，除非系统内存耗尽了。

s0 := []int{0, 0}
s1 := append(s0, 2)  // append 单个元素 s1 == []int{0, 0, 2}
s2 := append(s1, 3, 5, 7)  // append 多个元素 s2 == []int{0, 0, 2, 3, 5, 7}
s3 := append(s2, s0...)  // append 一个切片 s3 == []int{0, 0, 2, 3, 5, 7, 0, 0}
s4 := append(s3[3:6], s3[2:]...)  // append 切片片段 s4 == []int{3, 5, 7, 2, 3, 5, 7, 0, 0}

append()函数操作如果导致分配新的切片来保证已有切片元素和新增元素的存储，也就是返回的切片可能已经指向一个不同的相关数组了，那么新的切片已经和原来切片没有任何关系，即使修改了数据也不会同步。

append()函数操作后，有没有生成新的切片需要看原有切片的容量是否足够。

append()函数操作如果导致分配新的切片来保证已有切片元素和新增元素的存储，也就是返回的切片可能已经指向一个不同的相关数组了，那么新的切片已经和原来切片没有任何关系，即使修改了数据也不会同步。

有一个奇特之处，对一个切片s=[]int{1,2,3,4,5}：

package main

import "fmt"

func main() {
    s := []int{1, 2, 3, 4, 5}
    p := s[1:]
    q := s[:4]
    fmt.Println(len(p), cap(p)) // 4  4
    fmt.Println(len(q), cap(q)) // 4  5
}