Question

了解这些数据结构，一般会从数组开始，因为数组是切片和映射的基础数据结构。理解了数组的工作原理，有助于理解切片和映射提供的优雅和强大的功能。

4.1.1　内部实现

在 Go 语言里，数组是一个长度固定的数据类型，用于存储一段具有相同的类型的元素的连续块。数组存储的类型可以是内置类型，如整型或者字符串，也可以是某种结构类型。

在图 4-1 中可以看到数组的表示。灰色格子代表数组里的元素，每个元素都紧邻另一个元素。每个元素包含相同的类型，这个例子里是整数，并且每个元素可以用一个唯一的索引（也称下标或标号）来访问。

图 4-1　数组的内部实现

数组是一种非常有用的数据结构，因为其占用的内存是连续分配的。由于内存连续，CPU 能把正在使用的数据缓存更久的时间。而且内存连续很容易计算索引，可以快速迭代数组里的所有元素。数组的类型信息可以提供每次访问一个元素时需要在内存中移动的距离。既然数组的每个元素类型相同，又是连续分配，就可以以固定速度索引数组中的任意数据，速度非常快。

4.1.2　声明和初始化

声明数组时需要指定内部存储的数据的类型，以及需要存储的元素的数量，这个数量也称为数组的长度，如代码清单 4-1 所示。

代码清单 4-1　声明一个数组，并设置为零值

// 声明一个包含 5 个元素的整型数组
var array [5]int

一旦声明，数组里存储的数据类型和数组长度就都不能改变了。如果需要存储更多的元素，就需要先创建一个更长的数组，再把原来数组里的值复制到新数组里。

在 Go 语言中声明变量时，总会使用对应类型的零值来对变量进行初始化。数组也不例外。当数组初始化时，数组内每个元素都初始化为对应类型的零值。在图 4-2 里，可以看到整型数组里的每个元素都初始化为 0，也就是整型的零值。

图 4-2　声明数组变量后数组的值

一种快速创建数组并初始化的方式是使用数组字面量。数组字面量允许声明数组里元素的数量同时指定每个元素的值，如代码清单 4-2 所示。

代码清单 4-2　使用数组字面量声明数组

// 声明一个包含 5 个元素的整型数组
// 用具体值初始化每个元素
array := [5]int{10, 20, 30, 40, 50}

如果使用 ... 替代数组的长度，Go 语言会根据初始化时数组元素的数量来确定该数组的长度，如代码清单 4-3 所示。

代码清单 4-3　让 Go 自动计算声明数组的长度

// 声明一个整型数组
// 用具体值初始化每个元素
// 容量由初始化值的数量决定
array := [...]int{10, 20, 30, 40, 50}

如果知道数组的长度而是准备给每个值都指定具体值，就可以使用代码清单 4-4 所示的这种语法。

代码清单 4-4　声明数组并指定特定元素的值

// 声明一个有 5 个元素的数组
// 用具体值初始化索引为 1 和 2 的元素
// 其余元素保持零值
array := [5]int{1: 10, 2: 20}

代码清单 4-4 中声明的数组在声明和初始化后，会和图 4-3 所展现的一样。

图 4-3　声明之后数组的值

4.1.3　使用数组

正像之前提到的，因为内存布局是连续的，所以数组是效率很高的数据结构。在访问数组里任意元素的时候，这种高效都是数组的优势。要访问数组里某个单独元素，使用 [] 运算符，如代码清单 4-5 所示。

代码清单 4-5　访问数组元素

// 声明一个包含 5 个元素的整型数组
// 用具体值初始为每个元素
array := [5]int{10, 20, 30, 40, 50}

// 修改索引为 2 的元素的值
array[2] = 35

代码清单 4-5 中声明的数组的值在操作完成后，会和图 4-4 所展现的一样。

图 4-4　修改索引为 2 的值之后数组的值

可以像第 2 章一样，声明一个所有元素都是指针的数组。使用 * 运算符就可以访问元素指针所指向的值，如代码清单 4-6 所示。

代码清单 4-6　访问指针数组的元素

// 声明包含 5 个元素的指向整数的数组
// 用整型指针初始化索引为 0 和 1 的数组元素
array := [5]*int{0: new(int), 1: new(int)}

// 为索引为 0 和 1 的元素赋值
*array[0] = 10
*array[1] = 20

代码清单 4-6 中声明的数组的值在操作完毕后，会和图 4-5 所展现的一样。

图 4-5　指向整数的指针数组

在 Go 语言里，数组是一个值。这意味着数组可以用在赋值操作中。变量名代表整个数组，因此，同样类型的数组可以赋值给另一个数组，如代码清单 4-7 所示。

代码清单 4-7　把同样类型的一个数组赋值给另外一个数组

// 声明第一个包含 5 个元素的字符串数组
var array1 [5]string

// 声明第二个包含 5 个元素的字符串数组
// 用颜色初始化数组
array2 := [5]string{"Red", "Blue", "Green", "Yellow", "Pink"}

// 把 array2 的值复制到 array1
array1 = array2

复制之后，两个数组的值完全一样，如图 4-6 所示。

图 4-6　复制之后的两个数组

数组变量的类型包括数组长度和每个元素的类型。只有这两部分都相同的数组，才是类型相同的数组，才能互相赋值，如代码清单 4-8 所示。

代码清单 4-8　编译器会阻止类型不同的数组互相赋值

// 声明第一个包含 4 个元素的字符串数组
var array1 [4]string

// 声明第二个包含 5 个元素的字符串数组
// 使用颜色初始化数组
array2 := [5]string{"Red", "Blue", "Green", "Yellow", "Pink"}

// 将 array2 复制给 array1
array1 = array2

Compiler Error:
cannot use array2 (type [5]string) as type [4]string in assignment

复制数组指针，只会复制指针的值，而不会复制指针所指向的值，如代码清单 4-9 所示。

代码清单 4-9　把一个指针数组赋值给另一个

// 声明第一个包含 3 个元素的指向字符串的指针数组
var array1 [3]*string

// 声明第二个包含 3 个元素的指向字符串的指针数组
// 使用字符串指针初始化这个数组
array2 := [3]*string{new(string), new(string), new(string)}

// 使用颜色为每个元素赋值
*array2[0] = "Red"
*array2[1] = "Blue"
*array2[2] = "Green"

// 将 array2 复制给 array1
array1 = array2

复制之后，两个数组指向同一组字符串，如图 4-7 所示。

图 4-7　两组指向同样字符串的数组

4.1.4　多维数组

数组本身只有一个维度，不过可以组合多个数组创建多维数组。多维数组很容易管理具有父子关系的数据或者与坐标系相关联的数据。声明二维数组的示例如代码清单 4-10 所示。

代码清单 4-10　声明二维数组

// 声明一个二维整型数组，两个维度分别存储 4 个元素和 2 个元素
var array [4][2]int

// 使用数组字面量来声明并初始化一个二维整型数组
array := [4][2]int{{10, 11}, {20, 21}, {30, 31}, {40, 41}}

// 声明并初始化外层数组中索引为 1 个和 3 的元素
array := [4][2]int{1: {20, 21}, 3: {40, 41}}

// 声明并初始化外层数组和内层数组的单个元素
array := [4][2]int{1: {0: 20}, 3: {1: 41}}

图 4-8 展示了代码清单 4-10 中声明的二维数组在每次声明并初始化后包含的值。

图 4-8　二维数组及其外层数组和内层数组的值

为了访问单个元素，需要反复组合使用 [] 运算符，如代码清单 4-11 所示。

代码清单 4-11　访问二维数组的元素

// 声明一个 2×2 的二维整型数组
var array [2][2]int

// 设置每个元素的整型值
array[0][0] = 10
array[0][1] = 20
array[1][0] = 30
array[1][1] = 40

只要类型一致，就可以将多维数组互相赋值，如代码清单 4-12 所示。多维数组的类型包括每一维度的长度以及最终存储在元素中的数据的类型。

代码清单 4-12　同样类型的多维数组赋值

// 声明两个不同的二维整型数组
var array1 [2][2]int
var array2 [2][2]int

// 为每个元素赋值
array2[0][0] = 10
array2[0][1] = 20
array2[1][0] = 30
array2[1][1] = 40

// 将 array2 的值复制给 array1
array1 = array2

因为每个数组都是一个值，所以可以独立复制某个维度，如代码清单 4-13 所示。

代码清单 4-13　使用索引为多维数组赋值

// 将 array1 的索引为 1 的维度复制到一个同类型的新数组里
var array3 [2]int = array1[1]

// 将外层数组的索引为 1、内层数组的索引为 0 的整型值复制到新的整型变量里
var value int = array1[1][0]

4.1.5　在函数间传递数组

根据内存和性能来看，在函数间传递数组是一个开销很大的操作。在函数之间传递变量时，总是以值的方式传递的。如果这个变量是一个数组，意味着整个数组，不管有多长，都会完整复制，并传递给函数。

为了考察这个操作，我们来创建一个包含 100 万个 int 类型元素的数组。在 64 位架构上，这将需要 800 万字节，即 8 MB 的内存。如果声明了这种大小的数组，并将其传递给函数，会发生什么呢？如代码清单 4-14 所示。

代码清单 4-14　使用值传递，在函数间传递大数组

// 声明一个需要 8 MB 的数组
var array [1e6]int

// 将数组传递给函数 foo
foo(array)

// 函数 foo 接受一个 100 万个整型值的数组
func foo(array [1e6]int) {
　　...
}

每次函数 foo 被调用时，必须在栈上分配 8 MB 的内存。之后，整个数组的值（8 MB 的内存）被复制到刚分配的内存里。虽然 Go 语言自己会处理这个复制操作，不过还有一种更好且更有效的方法来处理这个操作。可以只传入指向数组的指针，这样只需要复制 8 字节的数据而不是 8 MB 的内存数据到栈上，如代码清单 4-15 所示。

代码清单 4-15　使用指针在函数间传递大数组

// 分配一个需要 8 MB 的数组
var array [1e6]int

// 将数组的地址传递给函数 foo
foo(&array)

// 函数 foo 接受一个指向 100 万个整型值的数组的指针
func foo(array *[1e6]int) {
　　...
}

这次函数 foo 接受一个指向 100 万个整型值的数组的指针。现在将数组的地址传入函数，只需要在栈上分配 8 字节的内存给指针就可以。

这个操作会更有效地利用内存，性能也更好。不过要意识到，因为现在传递的是指针，所以如果改变指针指向的值，会改变共享的内存。如你所见，使用切片能更好地处理这类共享问题。