Go 编程实战：数组 Array——固定长度的数据集合

在前面的文章中，我们已经学习了 Go 语言中的 break、continue 和 goto，掌握了如何控制循环执行流程。从这一篇开始，我们进入 Go 中非常重要的数据结构部分。

在实际开发中，我们经常需要保存一组相同类型的数据。例如保存学生成绩、服务器端口、商品价格、用户 ID 等。如果为每一个数据单独定义变量，不仅代码繁琐，而且不方便统一处理。

这时候就可以使用数组 Array。

数组是 Go 语言最基础的集合类型之一，也是后面学习 Slice、Map 等数据结构的重要基础。

一、什么是数组

数组是一组长度固定、类型相同的数据集合。

基本语法：

var 数组名 [长度]数据类型

例如：

var nums [5]int

表示定义一个长度为 5 的 int 数组。

可以理解为：

nums
+----+----+----+----+----+
| 0  | 0  | 0  | 0  | 0  |
+----+----+----+----+----+
  0    1    2    3    4

数组中的每个位置都有一个下标，下标从 0 开始。

长度为 5 的数组，其有效下标为：

0
1
2
3
4

因此最后一个元素的下标永远是：

len(nums) - 1

二、数组的零值

Go 语言变量在声明后即使没有手动赋值，也会自动获得对应类型的零值。

例如：

package main

import "fmt"

func main() {
	var nums [5]int

	fmt.Println(nums)
}

输出：

[0 0 0 0 0]

如果是字符串数组：

var names [3]string
fmt.Println(names)

结果中的每个元素都是空字符串。

布尔数组：

var flags [3]bool
fmt.Println(flags)

输出：

[false false false]

因此 Go 中定义数组后可以直接使用，不需要手动初始化所有元素。

三、给数组元素赋值

通过下标可以访问和修改数组中的元素：

package main

import "fmt"

func main() {
	var scores [5]int

	scores[0] = 90
	scores[1] = 85
	scores[2] = 96
	scores[3] = 78
	scores[4] = 88

	fmt.Println(scores)
}

输出：

[90 85 96 78 88]

也可以单独访问某个元素：

fmt.Println(scores[0])
fmt.Println(scores[2])

输出：

90
96

数组下标不能超过有效范围，例如：

var nums [5]int

nums[5] = 100

这里会出现越界问题，因为 [5]int 的有效下标只有 0~4。

四、定义数组时直接初始化

除了先声明再赋值，还可以在创建数组的时候直接初始化。

nums := [5]int{10, 20, 30, 40, 50}

fmt.Println(nums)

输出：

[10 20 30 40 50]

字符串数组：

names := [3]string{"Tom", "Jack", "Lucy"}

如果没有提供所有元素：

nums := [5]int{10, 20}

实际上相当于：

[10 20 0 0 0]

剩余元素自动使用零值。

五、让 Go 自动计算数组长度

如果初始化数据比较多，可以使用：

nums := [...]int{10, 20, 30, 40, 50}

这里的：

...

表示让编译器自动计算数组长度。

因此：

nums := [...]int{10, 20, 30}

等价于：

nums := [3]int{10, 20, 30}

可以使用 len() 查看长度：

fmt.Println(len(nums))

输出：

3

这种写法在初始化数组时非常方便。

六、指定下标初始化

Go 还支持通过下标初始化数组。

例如：

nums := [5]int{
	0: 10,
	2: 30,
	4: 50,
}

fmt.Println(nums)

输出：

[10 0 30 0 50]

没有指定的位置仍然使用零值。

也可以写成：

nums := [...]int{
	2: 100,
	5: 200,
}

因为最大下标是 5，所以数组长度会自动推导为 6。

七、遍历数组

数组最常见的操作之一就是遍历。

可以使用普通 for 循环：

package main

import "fmt"

func main() {
	nums := [5]int{10, 20, 30, 40, 50}

	for i := 0; i < len(nums); i++ {
		fmt.Println(nums[i])
	}
}

这种方式适合需要使用下标的场景。

Go 更推荐使用 range：

for index, value := range nums {
	fmt.Println(index, value)
}

输出：

0 10
1 20
2 30
3 40
4 50

其中：

index

表示当前下标，

value

表示当前元素。

如果只需要值：

for _, value := range nums {
	fmt.Println(value)
}

如果只需要下标：

for index := range nums {
	fmt.Println(index)
}

八、修改数组中的元素

数组中的元素是可以修改的：

nums := [3]int{10, 20, 30}

nums[1] = 100

fmt.Println(nums)

输出：

[10 100 30]

也可以通过循环修改：

for i := 0; i < len(nums); i++ {
	nums[i] *= 2
}

例如：

nums := [5]int{1, 2, 3, 4, 5}

for i := 0; i < len(nums); i++ {
	nums[i] *= 2
}

fmt.Println(nums)

输出：

[2 4 6 8 10]

需要注意，如果这样写：

for _, value := range nums {
	value *= 2
}

原数组不会改变。

因为这里的 value 是数组元素值的副本，而不是原元素本身。

九、数组的长度属于类型的一部分

这是 Go 数组非常重要的特点。

下面两个变量：

var a [3]int
var b [5]int

虽然它们存储的都是 int，但是类型并不相同。

一个是：

[3]int

另一个是：

[5]int

因此不能直接：

a = b

这也是 Go 数组和很多其他语言数组之间比较明显的区别。

数组长度在编译阶段就已经确定，运行过程中不能改变。

十、数组之间可以比较

如果数组元素类型支持比较，那么相同类型的数组也可以直接使用：

==

和：

!=

例如：

a := [3]int{1, 2, 3}
b := [3]int{1, 2, 3}
c := [3]int{1, 2, 4}

fmt.Println(a == b)
fmt.Println(a == c)

输出：

true
false

只有数组长度、元素类型和每个位置的值都相同，两个数组才相等。

十一、数组是值类型

这是学习 Go 数组必须掌握的重点。

Go 中数组属于值类型。

例如：

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？

因为：

b := a

会复制整个数组。

此时可以理解为：

a -> [10 20 30]

b -> [10 20 30]

它们是两份独立的数据。

这与后面要学习的 Slice 有很大的区别。

十二、数组作为函数参数

因为数组是值类型，所以把数组传递给函数时，默认也是复制。

例如：

package main

import "fmt"

func change(nums [3]int) {
	nums[0] = 100
}

func main() {
	nums := [3]int{10, 20, 30}

	change(nums)

	fmt.Println(nums)
}

输出：

[10 20 30]

函数内部修改的是复制后的数组，因此不会影响原数组。

如果确实需要修改原数组，可以传递数组指针：

func change(nums *[3]int) {
	nums[0] = 100
}

调用：

change(&nums)

完整示例：

package main

import "fmt"

func change(nums *[3]int) {
	nums[0] = 100
}

func main() {
	nums := [3]int{10, 20, 30}

	change(&nums)

	fmt.Println(nums)
}

输出：

[100 20 30]

不过实际 Go 项目中，如果需要频繁向函数传递一组数据，通常不会直接传数组，而是使用下一篇要学习的 Slice。

十三、二维数组

数组中的元素本身也可以是数组。

例如：

var nums [3][4]int

表示：

3 行
4 列

可以理解为：

[
 [0 0 0 0]
 [0 0 0 0]
 [0 0 0 0]
]

初始化：

nums := [3][4]int{
	{1, 2, 3, 4},
	{5, 6, 7, 8},
	{9, 10, 11, 12},
}

访问第二行第三个元素：

fmt.Println(nums[1][2])

结果：

7

遍历二维数组：

for i := 0; i < len(nums); i++ {
	for j := 0; j < len(nums[i]); j++ {
		fmt.Printf("%d ", nums[i][j])
	}
	fmt.Println()
}

也可以使用 range：

for _, row := range nums {
	for _, value := range row {
		fmt.Printf("%d ", value)
	}
	fmt.Println()
}

二维数组可以用于矩阵、棋盘、表格数据等场景。

十四、数组实战：计算成绩

例如保存 5 名学生的成绩：

package main

import "fmt"

func main() {
	scores := [5]int{86, 92, 78, 95, 88}

	sum := 0
	max := scores[0]
	min := scores[0]

	for _, score := range scores {
		sum += score

		if score > max {
			max = score
		}

		if score < min {
			min = score
		}
	}

	avg := float64(sum) / float64(len(scores))

	fmt.Println("总分：", sum)
	fmt.Println("平均分：", avg)
	fmt.Println("最高分：", max)
	fmt.Println("最低分：", min)
}

输出类似：

总分： 439
平均分： 87.8
最高分： 95
最低分： 78

通过这个例子可以看到，数组特别适合保存数量已经确定的一组相同类型的数据。

十五、数组适合什么场景

数组最大的特点就是：

长度固定

因此比较适合数量明确且不会变化的数据。

例如：

var week [7]string

表示一周七天。

var months [12]int

表示一年十二个月的数据。

或者：

rgb := [3]int{255, 128, 0}

表示 RGB 三个颜色通道。

但是现实项目中的数据数量通常是不固定的。

例如用户列表可能今天 100 个用户，明天 1000 个用户；商品列表可能不断增加；接口返回的数据数量也无法提前确定。

这时候固定长度数组就显得不够灵活。

十六、数组常见错误

第一个常见问题是数组越界：

nums := [3]int{1, 2, 3}

fmt.Println(nums[3])

数组只有：

0
1
2

三个有效下标，因此访问 3 会越界。

第二个问题是认为不同长度数组属于相同类型：

var a [3]int
var b [5]int

a = b

这是不允许的，因为 [3]int 和 [5]int 是两个不同的类型。

第三个问题是误以为数组赋值共享数据：

a := [3]int{1, 2, 3}
b := a

b[0] = 100

这里不会修改 a，因为数组赋值会复制数据。

十七、数组与 Slice 的关系

学习数组之后，很快就会发现一个问题：

var nums [5]int

长度一旦确定就不能改变。

但是实际开发中的集合通常需要：

动态增加数据
动态删除数据
动态截取数据
向函数传递任意长度的数据

如果全部使用数组，实现起来会非常不方便。

因此 Go 提供了更加常用的数据结构：

Slice

也就是切片。

切片底层和数组有非常密切的关系，但是相比数组更加灵活。

例如：

nums := []int{10, 20, 30}

注意这里没有数组长度：

[]int

它表示的就不再是数组，而是一个 int 类型的切片。

切片还可以动态追加元素：

nums = append(nums, 40)
nums = append(nums, 50)

这是数组无法直接做到的。

因此在实际 Go 项目中：

数组是基础
Slice 才是更常用的数据集合

理解数组的值类型、固定长度、下标访问以及内存结构之后，再学习 Slice 会容易很多。

总结

数组 Array 是 Go 语言中用于保存固定数量相同类型数据的基础数据结构。

定义数组：

var nums [5]int

初始化：

nums := [5]int{1, 2, 3, 4, 5}

自动推导长度：

nums := [...]int{1, 2, 3}

访问元素：

nums[0]

获取长度：

len(nums)

遍历：

for index, value := range nums {
	fmt.Println(index, value)
}

需要重点记住三个特点：

1. 数组长度固定
2. 数组长度属于类型的一部分
3. 数组属于值类型，赋值和函数传参默认会复制

数组虽然在实际业务开发中的直接使用频率没有 Slice 高，但它是理解 Go 集合数据结构的重要基础。特别是 Slice 的底层实现与数组密切相关，因此数组这一部分一定要理解清楚。

下一篇：切片 Slice------Go 中最常用的动态数据集合