一、数组及声明

数组不难理解，就是array类型的数据，Go不允许在数组中混合使用不同类型的元素（比如整数和字符串）。所以数组是类型相同的元素的集合。例如，整数 5, 8, 9, 79, 76 的集合就构成了一个数组。var a [3]int 这里就命名了一个名称为a，里面包含三个值的整型数组。所以我们总结为：数组的类型为 n[T]，其中 n 表示数组中元素的个数，T 表示数组中元素的类型。

1package main
2import (
3    "fmt"
4)
5func main() {
6    var a [3]int //int array with length 3
7    fmt.Println(a)
8}

上面var a [3]int 声明了一个长度为 3 的整型数组。数组中的所有元素都被自动赋值为元素类型的 0 值。比如这里 a 是一个整型数组，因此 a 中的所有元素都被赋值为 0（即整型的 0 值）。运行上面的程序，输出为：[0 0 0]。数组的索引从 0 开始到 length – 1 结束，再看一个示例：

 1package main
 2import (
 3    "fmt"
 4)
 5func main() {
 6    var a [3]int //int array with length 3
 7    a[0] = 12    // array index starts at 0
 8    a[1] = 78
 9    a[2] = 50
10    fmt.Println(a)
11}

a[0]表示数组中的第一个元素。程序的输出为：[12 78 50]。同样可以利用速记声明（shorthand declaration）的方式来创建同样的数组，上面的数据a值的定义可以直接使用a := [3]int{12, 78, 50} 完成定义，这时候再打印a的输出是一样的。在速记声明中，没有必要为数组中的每一个元素指定初始值。看下面的代码：

1package main
2import (
3    "fmt"
4)
5func main() {
6    a := [3]int{12}
7    fmt.Println(a)
8}

上面程序的：a := [3]int{12} 声明了一个长度为 3 的数组，但是只提供了一个初值 12。剩下的两个元素被自动赋值为 0。程序 的输出为：[12 0 0]。

在声明数组时你可以忽略数组的长度并用 … 代替，让编译器为你自动推导数组的长度。比如下面的程序：

1package main
2import (
3    "fmt"
4)
5func main() {
6    a := [...]int{12, 78, 50} // ... makes the compiler determine the length
7    fmt.Println(a)
8}

上面已经提到，数组的长度是数组类型的一部分。因此 [5]int 和 [25]int 是两个不同类型的数组。正是因为如此，一个数组不能动态改变长度。看下面一个例子，如果我们把一个长度为3的数组和一个长度为5的数组进行赋值时就会报错。

1package main
2func main() {
3    a := [3]int{5, 78, 8}
4    var b [5]int
5    b = a //not possible since [3]int and [5]int are distinct types
6}

在上面程序的第 6 行，我们试图将一个 [3]int 类型的数组赋值给一个 [5]int 类型的数组，这是不允许的。编译会报错：main.go:6: cannot use a (type [3]int) as type [5]int in assignment。

二、数组的拷贝

在 Go 中数组是值类型而不是引用类型。这意味着当数组变量被赋值时，将会获得原数组（译者注：也就是等号右面的数组）的拷贝。新数组中元素的改变不会影响原数组中元素的值。

1package main
2import "fmt"
3func main() {
4    a := [...]string{"USA", "China", "India", "Germany", "France"}
5    b := a // a copy of a is assigned to b
6    b[0] = "Singapore"
7    fmt.Println("a is ", a)
8    fmt.Println("b is ", b)
9}

上面程序将数组 a 的拷贝赋值给数组 b。而后我们将 b 的第一个元素赋值为 Singapore。这将不会影响到原数组 a。程序的输出为：

1a is [USA China India Germany France]
2b is [Singapore China India Germany France]

同样的，如果将数组作为参数传递给函数，仍然是值传递，在函数中对（作为参数传入的）数组的修改不会造成原数组的改变。

 1package main
 2import "fmt"
 3func changeLocal(num [5]int) {
 4    num[0] = 55
 5    fmt.Println("inside function ", num)
 6}
 7func main() {
 8    num := [...]int{5, 6, 7, 8, 8}
 9    fmt.Println("before passing to function ", num)
10    changeLocal(num) //num is passed by value
11    fmt.Println("after passing to function ", num)
12}

上面的程序，数组 num 是通过值传递的方式传递给函数 changeLocal 的，因此该函数执行过程中不会造成 num 的改变。程序输出如下：

1before passing to function  [5 6 7 8 8]
2inside function  [55 6 7 8 8]
3after passing to function  [5 6 7 8 8]

使用 for 循环遍历数组中的元素（索引从 0 到 len(a) – 1）。

1package main
2import "fmt"
3func main() {
4    a := [...]float64{67.7, 89.8, 21, 78}
5    for i := 0; i < len(a); i++ { //looping from 0 to the length of the array
6        fmt.Printf("%d th element of a is %.2f\n", i, a[i])
7    }
8}

上面的程序上面的程序输出如下：

10 th element of a is 67.70
21 th element of a is 89.80
32 th element of a is 21.00
43 th element of a is 78.00

Go 提供了一个更简单，更简洁的遍历数组的方法：使用 range for。range 返回数组的索引和索引对应的值。让我们用 range for 重写上面的程序（除此之外我们还计算了数组元素的总和）。

 1package main
 2import "fmt"
 3func main() {
 4    a := [...]float64{67.7, 89.8, 21, 78}
 5    sum := float64(0)
 6    for i, v := range a { //range returns both the index and value
 7        fmt.Printf("%d the element of a is %.2f\n", i, v)
 8        sum += v
 9    }
10    fmt.Println("\nsum of all elements of a", sum)
11}

上面的程序中，for i, v := range a 是 range 形式的 for 循环。range 将返回数组的索引和相对应的元素。我们打印这些值并计算数组 a 中所有元素的总和。程序的输出如下：

10 the element of a is 67.70
21 the element of a is 89.80
32 the element of a is 21.00
43 the element of a is 78.00
5sum of all elements of a 256.5

如果你只想访问数组元素而不需要访问数组索引，则可以通过空标识符来代替索引变量：

1for _, v := range a { //ignores index
2}

上面的代码忽略了索引。同样也可以忽略值。

四、多维数组

上面我们用的都是一组数组，理解了一组数据，多维数组就比较好理解了，看下如下示例：

 1package main
 2import (
 3    "fmt"
 4)
 5func printarray(a [3][2]string) {
 6    for _, v1 := range a {
 7        for _, v2 := range v1 {
 8            fmt.Printf("%s ", v2)
 9        }
10        fmt.Printf("\n")
11    }
12}
13func main() {
14    a := [3][2]string{
15        {"lion", "tiger"},
16        {"cat", "dog"},
17        {"pigeon", "peacock"}, //this comma is necessary. The compiler will complain if you omit this comma
18    }
19    printarray(a)
20    var b [3][2]string
21    b[0][0] = "apple"
22    b[0][1] = "samsung"
23    b[1][0] = "microsoft"
24    b[1][1] = "google"
25    b[2][0] = "AT&T"
26    b[2][1] = "T-Mobile"
27    fmt.Printf("\n")
28    printarray(b)
29}

利用速记声明创建了一个二维数组 a。其中的逗号是必须的，这是因为词法分析器会根据一些简单的规则自动插入分号。如果你想了解更多，请阅读：https://golang.org/doc/effective_go.html#semicolons 。后面又通过赋值声明了另一个二维数组 b，并通过索引的方式给数组 b 中的每一个元素赋值。这是初始化二维数组的另一种方式。函数 printarray 通过两个嵌套的 range for 打印二维数组的内容。上面代码的执行结果如下：

1lion tiger
2cat dog
3pigeon peacock
4apple samsung
5microsoft google
6AT&T T-Mobile