Golang 数组：固定长度、值语义以及与切片的区别

声明数组

数组类型写作 [N]T：先写长度，再写元素类型。长度在编译期就已确定，并且是类型的一部分。

package main

import "fmt"

func main() {
	var scores [5]int // five zeros
	scores[0] = 90
	scores[4] = 75
	fmt.Println(scores, len(scores))

	days := [3]string{"Mon", "Tue", "Wed"}
	fmt.Println(days[1])

	primes := [...]int{2, 3, 5, 7, 11} // compiler counts: [5]int
	fmt.Printf("%T %v\n", primes, primes)

	// Index keys: unset positions get the zero value.
	sparse := [5]string{1: "b", 3: "d"}
	fmt.Printf("%q\n", sparse)
}

输出：

[90 0 0 0 75] 5
Tue
[5]int [2 3 5 7 11]
["" "b" "" "d" ""]

数组总是完整初始化的。没有赋值的元素保存的是元素类型的零值：0、""、false、nil。

索引与越界

索引的范围是 0 到 len(a)-1。常量索引越界是编译错误，变量索引越界则会在运行时触发 panic。

var a [3]int
a[5] = 1 // compile error: invalid argument: index 5 out of bounds [0:3]

i := 5
a[i] = 1 // panic: runtime error: index out of range [5] with length 3

遍历

for i, v := range a 按顺序访问每个元素。v 是元素的副本，所以给 v 赋值不会改变数组。要修改元素，请通过索引写入。

package main

import "fmt"

func main() {
	temps := [4]float64{21.5, 23.0, 19.8, 25.1}

	sum := 0.0
	for _, t := range temps {
		sum += t
	}
	fmt.Printf("average: %.2f\n", sum/float64(len(temps)))

	for i := range temps {
		temps[i] += 1 // modifies the array
	}
	fmt.Println(temps)
}

数组还有一个特有的细节：对数组值使用 range 时，会预先求值出数组的一份副本。如果循环体修改了后面的元素，v 显示的仍然是旧值。对 &a 或 a[:] 使用 range 可以避免复制。

数组是值

这是 Go 数组与 C、Java 或 JavaScript 中数组的主要区别。给数组赋值会复制每个元素，把数组传给函数也会复制它。

package main

import "fmt"

func reset(a [3]int) {
	a[0] = 0 // changes the function's copy
}

func resetPtr(a *[3]int) {
	a[0] = 0 // changes the caller's array
}

func main() {
	a := [3]int{1, 2, 3}
	b := a // full copy
	b[0] = 99
	fmt.Println(a, b)

	reset(a)
	fmt.Println(a)

	resetPtr(&a)
	fmt.Println(a)
}

输出：

[1 2 3] [99 2 3]
[1 2 3]
[0 2 3]

小数组复制起来很便宜，大数组就很昂贵了：按值传递一个 [1_000_000]int 会复制 8 MB 数据。当数组很大或函数需要修改它时，请传递指针（*[N]T）或切片（a[:]）。通过数组指针取索引不需要显式写 *：a[0] 可以直接用于 *[3]int。

比较数组以及用作 map 的键

元素可比较的数组支持 == 和 !=。每个元素都相等时，两个数组才相等。这也让数组可以作为 map 的键，而切片不行。

package main

import "fmt"

func main() {
	x := [3]int{1, 2, 3}
	y := [3]int{1, 2, 3}
	fmt.Println(x == y)

	// A grid position as a map key.
	type pos [2]int
	visited := map[pos]bool{}
	visited[pos{0, 0}] = true
	visited[pos{2, 1}] = true
	fmt.Println(visited[pos{2, 1}], visited[pos{1, 1}])
}

长度不同的数组是不同的类型，根本无法比较：[3]int{} == [4]int{} 无法编译（mismatched types [3]int and [4]int）。

多维数组

数组的数组可以构成一个固定大小的网格。整个网格是一块连续的内存。

package main

import "fmt"

func main() {
	var board [3][3]rune
	for r := range board {
		for c := range board[r] {
			board[r][c] = '.'
		}
	}
	board[1][1] = 'X'
	board[0][2] = 'O'

	for _, row := range board {
		fmt.Println(string(row[:]))
	}
}

row[:] 把 [3]rune 类型的行转换成 []rune 切片，而 string() 接受这种切片。

数组与切片

实际开发中，你主要会在几个地方碰到数组：sha256.Sum256 返回 [32]byte，大小永远不变的查找表，以及作为切片的底层存储。用 a[:] 或 a[1:3] 对数组切片，会得到一个与它共享内存的切片；这种共享意味着什么，见 切片 页面。

数组与切片之间的转换

package main

import "fmt"

func main() {
	arr := [4]int{1, 2, 3, 4}
	s := arr[:] // slice view: shares memory with arr
	s[0] = 100
	fmt.Println(arr)

	nums := []int{7, 8, 9}
	a := [3]int(nums) // Go 1.20: slice to array, copies
	nums[0] = 0
	fmt.Println(a, nums)

	p := (*[3]int)(nums) // Go 1.17: array pointer, shares memory
	p[1] = 0
	fmt.Println(nums)
}

把切片转换成数组（Go 1.20）或数组指针（Go 1.17）时，如果切片比数组长度短，就会 panic：panic: runtime error: cannot convert slice with length 2 to array or pointer to array with length 3。

常见错误

• 以为函数会修改传入的数组参数。 函数拿到的是一份副本。请传递 *[N]T 或切片。
• 在需要切片的地方使用数组。 []int{1, 2} 是切片，[2]int{1, 2} 是数组。接受 []int 的函数不接受 [2]int；请传入 a[:]。
• 在 range 循环中遍历大数组。 for _, v := range bigArray 会先复制整个数组。请对 &bigArray 或切片使用 range。