Go语言：https://golang.org/
Go语言中文网：https://studygolang.com/
注意事项
1 数组不可动态变化问题，一旦声明了，其长度就是固定的。
如果数组长度不确定可以使用...代替数组长度
2 数组赋值问题，同样类型的数组（长度一样且每个元素类型也一样）才可以相互赋值，反之不可以。
3 import 某个库时未使用时，会报错。比如.go文件头部引用了import "fmt"，而代码中未使用fmt会报错
# 数组简介
Go 语言提供了数组类型的数据结构。数组是具有相同唯一类型的一组已编号且长度固定的数据项序列，这种类型可以是任意的原始类型例如整型、字符串或者自定义类型。数组元素可以通过索引（位置）来读取（或者修改），索引从 0 开始，第一个元素索引为 0，第二个索引为 1，以此类推。
# 用法
Go 语言数组声明需要指定元素类型及元素个数，语法格式如下：
var variable_name [SIZE] variable_type
以上为一维数组的定义方式。例如以下定义了数组 balance 长度为 10 类型为 float32：
var balance [10] float32
# 初始化数组
以下演示了数组初始化：
var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
我们也可以通过字面量在声明数组的同时快速初始化数组：
balance := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
如果数组长度不确定，可以使用 ... 代替数组的长度，编译器会根据元素个数自行推断数组的长度：
var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
或
balance := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
# 演示：数组的声明、赋值、访问
// 示例一
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\n", j, n[j] )
}
}
运行结果：
C:\Go\www>go run dengyu.go
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
// 示例二
package main
import "fmt"
func main() {
var i,j,k int
// 声明数组的同时快速初始化数组
balance := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
/* 输出数组元素 */
for i = 0; i < 5; i++ {
fmt.Printf("balance[%d] = %f\n", i, balance[i] )
}
balance2 := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
/* 输出每个数组元素的值 */
for j = 0; j < 5; j++ {
fmt.Printf("balance2[%d] = %f\n", j, balance2[j] )
}
// 将索引为 1 和 3 的元素初始化
balance3 := [5]float32{1:2.0,3:7.0}
for k = 0; k < 5; k++ {
fmt.Printf("balance3[%d] = %f\n", k, balance3[k] )
}
}
运行结果：
C:\Go\www>go run dengyu.go
balance[0] = 1000.000000
balance[1] = 2.000000
balance[2] = 3.400000
balance[3] = 7.000000
balance[4] = 50.000000
balance2[0] = 1000.000000
balance2[1] = 2.000000
balance2[2] = 3.400000
balance2[3] = 7.000000
balance2[4] = 50.000000
balance3[0] = 0.000000
balance3[1] = 2.000000
balance3[2] = 0.000000
balance3[3] = 7.000000
balance3[4] = 0.000000
# 注意事项：数组不可动态变化问题，一旦声明了，其长度就是固定的
package main
import "fmt"
func main() {
var arr_1 = [5] int {1, 2, 3, 4, 5}
arr_1[5] = 6
fmt.Println(arr_1)
}
运行结果：
C:\Go\www>go run dengyu.go
# command-line-arguments
.\dengyu.go:6:7: invalid array index 5 (out of bounds for 5-element array)
# 注意事项：数组赋值问题，同样类型的数组（长度一样且每个元素类型也一样）才可以相互赋值，反之不可以
package main
func main() {
var arr = [5] int {1, 2, 3, 4, 5}
var arr_1 [5] int = arr
var arr_2 [6] int = arr
}
运行结果：
C:\Go\www>go run dengyu.go
# command-line-arguments
.\dengyu.go:7:6: cannot use arr (type [5]int) as type [6]int in assignment
# 多维数组声明
Go 语言支持多维数组，以下为常用的多维数组声明方式：
var variable_name [SIZE1][SIZE2]...[SIZEN] variable_type
以下实例声明了三维的整型数组：
var threedim [5][10][4]int
# 定义二维数组
二维数组是最简单的多维数组，二维数组本质上是由一维数组组成的。二维数组定义方式如下：
var arrayName [ x ][ y ] variable_type
# 二维数组示例
package main
import ("fmt")
func main() {
v := [][]int{}
arr_1 := []int{1,2,3}
arr_2 := []int{4,5,6}
v = append(v, arr_1)
v = append(v,arr_2)
fmt.Println("数组一")
fmt.Println(v[0])
fmt.Println("数组二")
fmt.Println(v[1])
fmt.Println("访问第一个元素")
fmt.Println(v[0][0])
}
运行结果：
C:\Go\www>go run dengyu.go
数组一
[1 2 3]
数组二
[4 5 6]
访问第一个元素
1
# 初始化二维数组
// 示例一
package main
import ("fmt")
func main() {
arr := [][]string{
{"onn","two","three"},
{"four","five","six"},
{"severn","eight","nigh"},
}
fmt.Println("打印二维数组")
fmt.Println(arr)
}
运行结果：
C:\Go\www>go run dengyu.go
打印二维数组
[[onn two three] [four five six] [severn eight nigh]]
// 示例二
package main
import ("fmt")
func main() {
arr := [][]string{
{"onn","two","three"},
{"four","five","six"},
{"severn","eight","nigh"}
}
fmt.Println("打印二维数组")
fmt.Println(arr)
}
运行结果：
C:\Go\www>go run dengyu.go
# command-line-arguments
.\dengyu.go:8:29: syntax error: unexpected newline, expecting comma or }
注意：以上代码中倒数第二行的 } 必须要有逗号，因为最后一行的 } 不能单独一行，也可以写成这样：
a := [3][4]int{
{0, 1, 2, 3} , /* 第一行索引为 0 */
{4, 5, 6, 7} , /* 第二行索引为 1 */
{8, 9, 10, 11}} /* 第三行索引为 2 */
（完）