如果我们在程序中只需要保存一两个数字,直接定义变量 a := 10、b := 20 就足够了。但如果要保存全班 50 名同学的考试成绩,总不能连续定义 50 个变量吧?那样不仅写起来繁琐,管理起来也很麻烦。
为了解决这个问题,Go 语言提供了 “数组(Array)”。数组可以用来按顺序保存一组类型相同、数量固定的数据。你可以把数组想象成一排带有编号的储物柜:每个格子里只能存放同一种类型的物品,而且柜子的总格数在创建时就固定下来了,后面不能再增加或减少。
声明与初始化数组
在 Go 语言中,使用数组一般分为两步:先声明数组,再给数组赋初始值。当然,我们也可以在声明数组的同时直接完成初始化。
语法:
// 只声明
var 数组名 [长度]类型
// 指定长度初始化
数组名 := [长度]类型{元素1, 元素2, ..., 元素n}
// 自动推导长度
数组名 := [...]类型{元素1, 元素2, ..., 元素n}说明:
在 Go 语言中,中括号 [长度] 要写在元素类型的前面,比如 [3]int 就表示包含 3 个整数的数组。常见的创建方式有以下 3 种:
- 只声明不赋初始值:使用
var 数组名 [长度]类型声明数组后,Go 语言会自动把每个元素初始化为对应数据类型的默认零值。比如整数和浮点数默认为0,布尔值默认为false,字符串默认为空字符串""。 - 指定长度并赋初始值:在花括号
{}中填入初始元素,元素之间用英文逗号(,)隔开,且元素个数不能超过指定的长度。如果填入的元素少于数组长度,后面没赋值的位置会自动补上默认零值。 - 自动推导数组长度:如果我们不想手动去数花括号里有多少个元素,可以在中括号里写三个点
[...],编译器会根据初始元素的实际个数自动算出数组长度。
示例 1:声明数组与默认零值
package main
import "fmt"
func main() {
var nums [3]int
var flags [2]bool
fmt.Println(nums)
fmt.Println(flags)
}运行结果如下。
[0 0 0]
[false false]分析:
在这个例子中,我们声明了长度为 3 的整型数组 nums 和长度为 2 的布尔数组 flags。因为没有赋初始值,nums 里的元素默认都是 0,flags 里的元素默认都是 false。如果是 string 类型的数组,每个元素默认则是空字符串 ""。
需要注意的是,定义数组时中括号里的长度必须在编译阶段就能确定。也就是说,长度只能写正整数或者通过 const 定义的常量,不能把普通变量放进中括号里。
// 正确方式
const n = 3
var a [n]int
// 错误方式
n := 3
var b [n]int在上面的错误方式中,n := 3 定义的是普通变量,编译时会直接报 invalid array length n(无效的数组长度 n)错误。
示例 2:定义数组并赋初始值
package main
import "fmt"
func main() {
a := [3]int{10, 20, 30} // 完整初始化
b := [5]int{10, 20} // 部分初始化
fmt.Println(a)
fmt.Println(b)
}运行结果如下。
[10 20 30]
[10 20 0 0 0]分析:
数组 a 的长度为 3,花括号中正好提供了 3 个整数,每个位置都按顺序填入了对应的值。数组 b 的长度为 5,花括号里只给出了前两个元素的值,后面剩下的 3 个位置就会自动补 0。
在函数内部定义并初始化数组时,对于上面的数组 a 来说,下面 2 种方式是等价的。
// 方式 1(推荐)
a := [3]int{10, 20, 30}
// 方式 2
var a = [3]int{10, 20, 30}其中,方式 1 使用短变量声明 := 省去了 var 关键字,写起来更加简练,平时写代码时我们更推荐使用方式 1。
示例 3:自动推导数组长度
package main
import "fmt"
func main() {
names := [...]string{"Jack", "Lucy", "Tony"}
fmt.Println(names)
}运行结果如下。
[Jack Lucy Tony]分析:
在定义 names 时,我们在中括号里写了 [...],编译器看到后面花括号里有 3 个字符串,就会自动将其推算为 [3]string 类型。如果后面需要在代码里获取数组的长度,直接调用内置的 len() 函数即可。
这里小伙伴们要注意,定义数组时中括号里面必须写明具体的长度或者 ...,千万不要把中括号留空。如果写成 []string{"Jack", "Lucy", "Tony"},那定义的就不再是数组,而是后面章节会学到的切片。
提示: 在实际开发中,如果我们一开始就已经确定了数组里的所有初始元素,推荐使用 [...] 让编译器自动统计个数。这样既不用自己去数元素个数,以后增删初始元素时也不用手动修改中括号里的数字。
访问与修改数组元素
数组创建好之后,如果我们想要读取或修改里面某一项的值,可以通过 “数组下标” 来实现,下标在编程中也常称为 “索引”。
在 Go 语言中,数组的下标是从 0 开始编号的(注意从 0 开始)。也就是说,第 1 个元素的下标是 0,第 2 个元素的下标是 1,每个位置与下标的对应关系如下图所示。

语法:
// 读取元素
变量名 := 数组名[下标]
// 修改元素
数组名[下标] = 新值说明:
如果一个数组的长度为 n,那么它合法的下标范围就是 0 到 n - 1,每个元素的下标永远等于它的位置序号减 1。比如长度为 3 的数组,它的 3 个元素依次是 arr[0]、arr[1] 和 arr[2]。
示例 4:访问与修改数组元素
package main
import "fmt"
func main() {
nums := [3]int{10, 20, 30}
fmt.Println(nums[0]) // 获取第 1 个元素
fmt.Println(nums[2]) // 获取第 3 个元素
nums[1] = 200 // 修改第 2 个元素
fmt.Println(nums)
}运行结果如下。
10
30
[10 200 30]分析:
nums[0] 表示获取数组 nums 的第 1 项,也就是 10。nums[2] 表示获取第 3 项,也就是 30。接着我们执行 nums[1] = 200,把下标为 1 的第 2 项从原来的 20 修改成了 200。
访问数组时,下标不能超出最大合法范围。对于长度为 3 的数组 nums 来说,最大合法下标是 2。如果我们把下标写死成 nums[3],编译时就会直接报 invalid argument: index 3 out of bounds [0:3](下标 3 超出范围)错误:
fmt.Println(nums[3])这里小伙伴们可以记住一个细节:如果下标是写死的常量数字(如 nums[3]),越界在编译阶段就会直接报错;如果下标是变量(比如循环里不小心多跑了一轮),编译器没法提前算出来,程序就会在运行期间直接报错崩溃(panic)。
清楚了数组的下标从 0 开始编号之后,我们在初始化数组时,还可以在花括号里通过 “下标: 值” 的形式,只给某几个指定下标的位置赋初始值。下面我们来看一个例子。
示例 5:指定下标初始化
package main
import "fmt"
func main() {
arr := [5]int{1: 10, 3: 30}
fmt.Println(arr)
}运行结果如下。
[0 10 0 30 0]分析:
arr := [5]int{1: 10, 3: 30} 表示定义一个长度为 5 的整型数组。其中 1: 10 表示把下标为 1(第 2 项)的值设为 10,3: 30 表示把下标为 3(第 4 项)的值设为 30,其余没指定的位置保持默认值 0。
数组的类型与比较
学习 Go 数组时,有一个规则小伙伴们一定要重点记牢:在 Go 语言中,数组的长度属于数组类型的一部分。
这是什么意思呢?简单来说,只有当两个数组的 “元素类型” 和 “数组长度” 都完全相同时,它们才属于同一种类型。下面我们通过一个例子来看看。
示例 6:不同长度的数组类型不同
package main
import "fmt"
func main() {
var a [3]int
var b [5]int
a = b
fmt.Println(a)
}运行结果如下。
(报错)cannot use b (variable of type [5]int) as [3]int value in assignment分析:
可能有些小伙伴会问:“a 和 b 里面装的不都是 int 整数吗?为什么不能把 b 赋值给 a 呢?”
这是因为在 Go 编译器看来,变量 a 的类型是 [3]int,而变量 b 的类型是 [5]int。因为中括号里的长度一个是 3、一个是 5,它们属于两种完全不同的数据类型,编译时就会提示无法把 [5]int 类型的值赋给 [3]int 类型的变量。
反过来,只要两个数组的长度和元素类型都完全相同,我们就可以直接使用 == 或 != 来判断它们是否相等。
示例 7:比较两个数组是否相等
package main
import "fmt"
func main() {
a := [3]int{10, 20, 30}
b := [3]int{10, 20, 30}
c := [3]int{10, 20, 40}
fmt.Println(a == b)
fmt.Println(a == c)
}运行结果如下。
true
false分析:
使用 == 比较两个同类型数组时,程序会按顺序逐一比对它们相同下标位置上的元素。只有当每一个位置上的元素都相等时,结果才会返回 true;只要有任意一个位置的值不同,结果就会返回 false。
需要注意的是,如果两个数组长度不同(如 [3]int 和 [5]int),因为属于不同类型,直接使用 == 或 != 比较同样会编译报错。
数组的赋值与值拷贝
当两个数组的类型(元素类型与长度)完全相同时,我们还可以直接把一个数组赋值给另一个数组。下面我们来看看赋值之后,修改新数组会不会影响原来的数组。
示例 8:数组的赋值与复制
package main
import "fmt"
func main() {
a := [3]int{10, 20, 30}
b := a
b[0] = 100
fmt.Println(a)
fmt.Println(b)
}运行结果如下。
[10 20 30]
[100 20 30]分析:
在这个例子中,我们先执行 b := a 把数组 a 赋值给 b,再把 b[0] 改为 100。从运行结果可以看出,原数组 a 依然是 [10 20 30],并没有跟着变化。
这是因为 b := a 会把 a 里的所有元素完整复制一份放到新空间里给 b,两者互不干扰,内存关系如下图所示。

Go 数组是值类型
如果大家之前学过其他编程语言,可能会对上面的结果感到意外。在不少语言里,把列表或数组直接赋值给另一个变量时,两个变量通常共用同一份底层数据,修改其中一个就会影响另一个。
而 Go 语言的数组属于 “值类型”,赋值或传参时都会完整复制整个数组。如果一个数组包含成千上万个元素,频繁复制就会带来不小的内存开销。因此在实际开发中,只有明确知道数据个数固定不变时才会使用数组,大多数场景下我们更推荐使用后面章节学习的切片。
