1. 数组定义
数组是具有相同唯一类型的一组已编号且长度固定的数据项序列，这种类型可以是任意的原始类型例如整形、字符串或者自定义类型。
2. 声明数组
Go 语言数组声明需要指定元素类型及元素个数，语法格式如下：
var varName [SIZE]varType语法说明如下所示：
- varName（数组变量名）：数组声明及使用时的变量名。
- SIZE（元素数量）：数组的元素数量，可以是一个表达式，但最终通过编译期计算的结果必须是整型数值，元素数量不能含有到运行时才能确认大小的数值。
- Type（数组类型）：可以是任意基本类型，包括数组本身，类型为数组本身时，可以实现多维数组。
例如以下定义了数组 a 长度为 10， 类型为 float32：
var a [10]float323. 初始化数组
- 指定长度和初始化值，初始化数组中 {} 中的元素个数不能大于 [] 中的数字：
var a = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}默认情况下，数组的每个元素都会被初始化为元素类型对应的零值，对于数字类型来说就是 0，同时也可以使用数组字面值语法，用一组值来初始化数组：
var q [3]int = [3]int{1, 2, 3}
var r [3]int = [3]int{1, 2}
fmt.Println(r[2]) // "0"- 不指定数组长度，
Go语言会根据元素的个数来设置数组的大小：
var a = []float32{1000.0, 2.0, 3.4, 7.0, 50.0}- 指定长度，通过索引值进行初始化，没有初始化的元素使用类型默认值：
a := [3]int{1:1, 3:3}- 不指定长度，通过索引值进行初始化，数组长度由最后一个索引值确定，没有指定索引的元素被初始化为类型默认值：
a := []int{1:1, 2:3}4. 访问数组
数组的每个元素都可以通过索引下标来访问，索引下标的范围是从 0 开始到数组长度减 1 的位置，内置函数 len() 可以返回数组中元素的个数。
var a [3]int // 定义三个整数的数组
fmt.Println(a[0]) // 打印第一个元素
fmt.Println(a[len(a)-1]) // 打印最后一个元素
var salary float32 = balance[9]5. 数组相等
数组的长度是数组类型的一个组成部分，因此 [3]int 和 [4]int 是两种不同的数组类型，数组的长度必须是常量表达式，因为数组的长度需要在编译阶段确定。
q := [3]int{1, 2, 3}
q = [4]int{1, 2, 3, 4} // 编译错误：无法将 [4]int 赋给 [3]int如果两个数组类型相同（包括数组的长度，数组中元素的类型）的情况下，我们可以直接通过较运算符（==和!=）来判断两个数组是否相等，只有当两个数组的所有元素都是相等的时候数组才是相等的，不能比较两个类型不同的数组，否则程序将无法完成编译。
a := [2]int{1, 2}
b := [...]int{1, 2}
c := [2]int{1, 3}
fmt.Println(a == b, a == c, b == c) // "true false false"
d := [3]int{1, 2}
fmt.Println(a == d) // 编译错误：无法比较 [2]int == [3]int6. 使用示例
package main
import "fmt"
func main() {
// var n [5]int，声明一个含有 5 个元素的数组，但元素默认都是 0， 一般很少这样使用
var n = []int{10, 20, 30, 40, 50}
average_value := get_average(n)
fmt.Printf("average_value is %v\n", average_value)
for j := 0; j < len(a); j++ { // len(a) 获取数组长度
fmt.Printf("origin array n[%v] is %v\n", j, n[j])
}
fmt.Printf("###############\n")
for i := 0; i < 5; i++ {
n[i] = i
}
for index, value := range n { // 遍历数组
fmt.Printf("new array n[%v] is %v\n", index, value)
}
}
func get_average(array []int) int {
array_length := len(array)
var sum int = 0
for i := 0; i < array_length; i++ {
sum += array[i]
}
average := sum / array_length
return average
}7. 多维数组
Go 语言支持多维数组，以下为常用的多维数组声明方式：
var variable_name [SIZE1][SIZE2]...[SIZEN] variable_type示例
var threedim [5][10][4]int二维数组是最简单的多维数组，二维数组本质上是由一维数组组成的。二维数组定义方式如下：
var arrayName [x][y]variableTypearrayName 为数组名，variableType为 Go 语言的数据类型。二维数组中的元素可通过 a[i][j] 来访问。
7.1 初始化二维数组
// 使用数组字面量来声明并初始化一个二维整型数组
array = [4][2]int{{10, 11}, {20, 21}, {30, 31}, {40, 41}}
// 声明并初始化数组中索引为 1 和 3 的元素
array = [4][2]int{1: {20, 21}, 3: {40, 41}}
// 声明并初始化数组中指定的元素
array = [4][2]int{1: {0: 20}, 3: {1: 41}}下图展示了上面示例中声明的二维数组在每次声明并初始化后包含的值。
7.2 访问二维数组
二维数组通过指定坐标来访问。如数组中的行索引与列索引，例如：
val := a[2][3]
/* 或 */
var value int = a[2][3]
// 声明两个二维整型数组
var array1 [2][2]int
// 将 array1 的索引为 1 的维度复制到一个同类型的新数组里
var array3 [2]int = array1[1]使用示例
package main
import "fmt"
func main() {
/* 数组 - 5 行 2 列*/
var a = [5][2]int{ {0,0}, {1,2}, {2,4}, {3,6},{4,8}}
var i, j int
/* 输出数组元素 */
for i = 0; i < 5; i++ {
for j = 0; j < 2; j++ {
fmt.Printf("a[%d][%d] = %d\n", i,j, a[i][j] )
}
}
}8. 向函数传递数组
向函数传递数组参数，需要在函数定义时，声明形参为数组，有以下两种形式：
（1） 形参设定数组大小
void func(param [10]int)
{
.
.
.
}（2） 形参未设定数组大小
void func(param []int)
{
.
.
.
}使用示例，函数接收整型数组参数，另一个参数指定了数组元素的个数，并返回平均值。
package main
import "fmt"
func main() {
/* 数组长度为 5 */
var balance = [5]int {1000, 2, 3, 17, 50}
var avg float32
/* 数组作为参数传递给函数 */
avg = getAverage(balance, 5) ;
/* 输出返回的平均值 */
fmt.Printf( "平均值为: %f ", avg );
}
func getAverage(arr []int, size int) float32 {
var i, sum int
var avg float32
for i = 0; i < size;i++ {
sum += arr[i]
}
avg = float32(sum) / float32(size)
return avg
}
