Go语言数组
Go语言提供了数组类型的数据结构。数组时具有相同唯一类型的一组已编号且长度固定的数据项序列，中类型可以是任意的原始类型如整形、字符串或者自定义类型。
相对于声明number0，number1，...，and number99的变量，使用数组形式numbers[0]，numbers[1]，...，numbers[99]更加方便且易于扩展。数组元素可以通过索引(位置)来读取(或者修改)，索引从0开始，第一个元素索引为0，第二个索引为1，以此类推，如下图所示：
声明数组
Go语言数组声明需要指定元素类型及元素个数，语法格式如下：
var variable_name [SIZE] variable_type
以上为一维数组的定义方式，数组长度必须是整数且大于0。例如以下定义了数组balance长度为10类型为float32：
var balance [10] float32
初始化数组
以下演示了数组初始化：
var balance = [5] float{1000.0, 2.0, 3.4, 7.0, 50.0}
初始化数组{}中的元素个数不能大于[]中的数字，如果忽略[]中的数字不设置大小，Go语言会根据元素的个数来设置数组的大小：
var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
该实例与上面的实例是一样的，虽然没有设置数组的大小：
balance[4] = 50.0
以上实例读取了第五个元素，数组元素可以通过索引(位置)来读取(或者修改)，索引从0开始，第一个元素索引为0，第二个索引为1，以此类推，如下图所示：
访问数组元素
数组元素可以通过索引(位置)来读取，格式为数组名后加中括号，中括号中为索引值，例如：
float32 salary = balance[9]
以上实例读取了数组balance第10个元素的值，以下演示了数组完整操作(声明、赋值、访问)的实例：
package main
import "fmt"
func main(){
var n [10] int /* n 是一个长度为10的数组 */
var i, j int
/* 为数组 n 初始化元素 */
for i = 0; i < 10; i++ {
n[i] = i + 100 /* 设置元素为 i + 100 */
}
/* 输出每个数组元素的值 */
for j = 0; j < 10; j++ {
fmt.Printf("Element[%d] = %d
", j, n[j]
}
}
以上实例运行结果为：
Element[0] = 100
Element[1] = 101
Element[2] = 102
Element[3] = 103
Element[4] = 104
Element[5] = 105
Element[6] = 106
Element[7] = 107
Element[8] = 108
Element[9] = 109
跟过内容
数组对Go语言来说是非常重要的，以下介绍将介绍数组更多类容：
| 内容 | 描述 |
|---|---|
| 多维数组 | Go语言支持多维数组，最简单的多维数组是二维数组 |
| 向函数传递数组 | 可以像函数传递数组参数 |
Go语言多维数组
Go语言支持多维数组，以下为常用的多维数组声明方式：
var variable_name [SIZE1][SIZE2]...[SIZEN] variable_type
以下实例声明了三维的整形数组：
var threedim [5][10][4] int
二维数组
二维数组是最简单的多维数组，二维数组本质上是由一维数组组成的，二维数组定义方式如下：
var arrayName [x][y] variable_type
variable_type 为Go语言的数据类型，arrayName为数组名，二维数组可以认为是一个表格，x为行，y为列，下图演示了一个二维数组a为三行四列：
二维数组中的元素可以通过a[i][j]来访问。
初始化二维数组
多维数组可以通过大括号来初始化，以实例为一个3行4列的二位数组：
a = [3][4]int {
{0, 1, 2, 3} , /* 第一行索引为 0 */
{4, 5, 6, 7} , /* 第二行索引为 1 */
{8, 9, 10, 11} /* 第三行索引为 2 */
}
访问二维数组
二维数组通过指定坐标来访问，如数组中的行索引与列索引，例如：
int val = a[2][3]
以上实例访问了二维数组val第三行第四列的元素(第三行的第四个元素)，二维数组可以使用循环嵌套来输出元素：
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
", i, j, a[i][j])
}
}
}
以上实例运行输出结果为：
a[0][0] = 0
a[0][1] = 0
a[1][0] = 1
a[1][1] = 2
a[2][0] = 2
a[2][1] = 4
a[3][0] = 3
a[3][1] = 6
a[4][0] = 4
a[4][1] = 8
Go语言向函数传递数组
如果我们想向函数传递数组参数，需要在函数定义时，声明形参为数组，可以通过以下两种方式来声明：
方式一：形参设定数组大小
void myFunction(param [10] int) {
.
.
.
}
方式二：形参未设定数组大小
void myFunction(param [] int) {
.
.
.
}
以下实例中函数接收整形数组参数，另一个参数指定了数组元素的个数，并返回平均值：
func getAverage(arr []int, size int) float32 {
var i int
var avg, sum float32
for i = 0; i < size; ++i {
sum += arr[i]
}
avg = sum / size
return avg
}
接下来我们调用这个函数：
package main
import "fmt"
func main() {
/* 数组长度为 5 */
var balance = []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;
}
以上实例执行结果为：
平均值为: 214.399994
以上实例中我们是以哦那个的形参并为设定数组大小，浮点数计算输出有一定的偏差，我们也可以转整形来设置精度，代码如下：
package main
import (
"fmt"
)
func main() {
a := 1.69
b := 1.7
c := a * b // 结果应该是2.873
fmt.Println(c) // 输出的是2.8729999999999998
}
设定固定精度：
package main
import (
"fmt"
)
func main() {
a := 1690 // 表示1.69
b := 1700 // 表示1.70
c := a * b // 结果应该是2873000表示 2.873
fmt.Println(c) // 内部编码
fmt.Println(float64(c) / 1000000) // 显示
}