《Go语言实战》读书笔记——数组的内部实现和基础功能

目录

1.1 内部实现

1.2 声明和初始化

1.3 使用数组

1.4 多维数组

1.5 在函数间传递数组

---

1.1 内部实现

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

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

1.2 声明和初始化

声明数组时需要指定内部存储的数据的类型，以及需要存储的元素的数量，这个数量也称为数组的长度。

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

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

在 Go 语言中声明变量时，总会使用对应类型的零值来对变量进行初始化。数组也不例外。 当数组初始化时，数组内每个元素都初始化为对应类型的零值（如下图）。

类型	类型名	零值
字符类型	byte, rune	0
数值类型	float32, float64, int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, complex64, complex128	0
布尔类型	bool	false
字符串	string	“”（空字符串）
slice	[]TYPE	nil
map	map[TYPE]TYPE	nil
指针	uintptr	nil
函数	func	nil
接口	interface	nil
信道	chan	nil

1.3 使用数组

因为内存布局是连续的，所以数组是效率很高的数据结构。在访问数组里 任意元素的时候，这种高效都是数组的优势。要访问数组里某个单独元素，使用[]运算符。

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

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

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

数组变量的类型包括数组长度和每个元素的类型。只有这两部分都相同的数组，才是类型相 同的数组，才能互相赋值。

// 声明第一个包含 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

1.4 多维数组

数组本身只有一个维度，不过可以组合多个数组创建多维数组。多维数组很容易管理具有父 子关系的数据或者与坐标系相关联的数据。（这里二维数组初始化可以初始化指定的第几行）

// 声明一个二维整型数组，两个维度分别存储 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}}

1.5 在函数间传递数组

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

// 声明一个需要 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 的内存数据到栈上。

// 分配一个需要 8 MB 的数组
var array [1e6]int
// 将数组的地址传递给函数 foo
foo(&array)
// 函数 foo 接受一个指向 100 万个整型值的数组的指针
func foo(array *[1e6]int) {
...
} 

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