golang从0到1实战系统十三：Go 数据底层的存储

下面这张图来源于 Russ Cox Blog 中一篇介绍 Go 数据结构 的文章，大家可以看到这些基
础类型底层都是分配了一块内存，然后存储了相应的值。
图 2.1 Go 数据格式的存储
一些技巧
分组声明
在 Go 语言中，同时声明多个常量、变量，或者导入多个包时，可采用分组的方式进行声明。
例如下面的代码：
import “fmt”
import “os”
const i = 100
const pi = 3.1415
const prefix = “Go_”
var i int
var pi float32
var prefix string
可以分组写成如下形式：
import(
“fmt”
“os”
)
const(
i = 100
pi = 3.1415
prefix = “Go_”
)
var(
i int
pi float32
prefix string
)
除非被显式设置为其它值或 iota，每个 const 分组的第一个常量被默认设置为它的 0 值，第
二及后续的常量被默认设置为它前面那个常量的值，如果前面那个常量的值是 iota，则它
也被设置为 iota。
iota 枚举
Go 里面有一个关键字 iota，这个关键字用来声明 enum 的时候采用，它默认开始值是 0，
每调用一次加 1：
const(
x = iota // x == 0
y = iota // y == 1
z = iota // z == 2
w // 常量声明省略值时，默认和之前一个值的字面相同。这里隐式地说 w =
iota，因此 w == 3。其实上面 y 和 z 可同样不用"= iota"
)
const v = iota // 每遇到一个 const 关键字，iota 就会重置，此时 v == 0
Go 程序设计的一些规则
Go 之所以会那么简洁，是因为它有一些默认的行为：
• 大写字母开头的变量是可导出的，也就是其它包可以读取的，是公用变量；小写字
母开头的就是不可导出的，是私有变量。
• 大写字母开头的函数也是一样，相当于 class 中的带 public 关键词的公有函数；小
写字母开头的就是有 private 关键词的私有函数。
array、slice、map
array
array 就是数组，它的定义方式如下：
var arr [n]type
在[n]type 中，n 表示数组的长度，type 表示存储元素的类型。对数组的操作和其它语言类
似，都是通过[]来进行读取或赋值：
var arr [10]int // 声明了一个 int 类型的数组
arr[0] = 42 // 数组下标是从 0 开始的
arr[1] = 13 // 赋值操作
fmt.Printf(“The first element is %d\n”, arr[0]) // 获取数据，返回 42
fmt.Printf(“The last element is %d\n”, arr[9]) //返回未赋值的最后一个元素，默认返回 0
由于长度也是数组类型的一部分，因此[3]int 与[4]int 是不同的类型，数组也就不能改变长
度。数组之间的赋值是值的赋值，即当把一个数组作为参数传入函数的时候，传入的其实是
该数组的副本，而不是它的指针。如果要使用指针，那么就需要用到后面介绍的 slice 类型
了。
数组可以使用另一种:=来声明
a := [3]int{1, 2, 3} // 声明了一个长度为 3 的 int 数组
b := [10]int{1, 2, 3} // 声明了一个长度为 10 的 int 数组，其中前三个元素初始化为 1、2、3，其它默认
为 0
c := […]int{4, 5, 6} // 可以省略长度而采用...的方式，Go 会自动根据元素个数来计算长度
也许你会说，我想数组里面的值还是数组，能实现吗？当然咯，Go 支持嵌套数组，即多维
数组。比如下面的代码就声明了一个二维数组：
// 声明了一个二维数组，该数组以两个数组作为元素，其中每个数组中又有 4 个 int 类型的元素
doubleArray := [2][4]int{[4]int{1, 2, 3, 4}, [4]int{5, 6, 7, 8}}
// 如果内部的元素和外部的一样，那么上面的声明可以简化，直接忽略内部的
类型
easyArray := [2][4]int{{1, 2, 3, 4}, {5, 6, 7, 8}}
数组的分配如下所示：
图 2.2 多维数组的映射关系
slice
在很多应用场景中，数组并不能满足我们的需求。在初始定义数组时，我们并不知道需要多
大的数组，因此我们就需要“动态数组”。在 Go 里面这种数据结构叫 slice
slice 并不是真正意义上的动态数组，而是一个引用类型。slice 总是指向一个底层
array，slice 的声明也可以像 array 一样，只是不需要长度。
// 和声明 array 一样，只是少了长度
var fslice []int
接下来我们可以声明一个 slice，并初始化数据，如下所示：
slice := []byte {‘a’, ‘b’, ‘c’, ‘d’}
slice 可以从一个数组或一个已经存在的 slice 中再次声明。slice 通过 array[i:j]来获取，其中 i
是数组的开始位置，j 是结束位置，但不包含 array[j]，它的长度是 j-i。
// 声明一个含有 10 个元素元素类型为 byte 的数组
var ar = [10]byte {‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘g’, ‘h’, ‘i’, ‘j’}
// 声明两个含有 byte 的 slice
var a, b []byte
// a 指向数组的第 3 个元素开始，并到第五个元素结束，
a = ar[2:5]
//现在 a 含有的元素: ar[2]、ar[3]和 ar[4]
// b 是数组 ar 的另一个 slice
b = ar[3:5]
// b 的元素是：ar[3]和 ar[4]
注意 slice 和数组在声明时的区别：声明数组时，方括号内写明了数组的长度或使用…自动
计算长度，而声明 slice 时，方括号内没有任何字符。
它们的数据结构如下所示
图 2.3 slice 和 array 的对应关系图
slice 有一些简便的操作
• slice 的默认开始位置是 0，ar[:n]等价于 ar[0:n]
• slice 的第二个序列默认是数组的长度，ar[n:]等价于 ar[n:len(ar)]
• 如果从一个数组里面直接获取 slice，可以这样 ar[:]，因为默认第一个序列是 0，第
二个是数组的长度，即等价于 ar[0:len(ar)]
下面这个例子展示了更多关于 slice 的操作：
// 声明一个数组
var array = [10]byte{‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘g’, ‘h’, ‘i’, ‘j’}
// 声明两个 slice
var aSlice, bSlice []byte
// 演示一些简便操作
aSlice = array[:3] // 等价于 aSlice = array[0:3] aSlice 包含元素: a,b,c
aSlice = array[5:] // 等价于 aSlice = array[5:10] aSlice 包含元素: f,g,h,i,j
aSlice = array[:] // 等价于 aSlice = array[0:10] 这样 aSlice 包含了全部的元素
// 从 slice 中获取 slice
aSlice = array[3:7] // aSlice 包含元素: d,e,f,g，len=4，cap=7
bSlice = aSlice[1:3] // bSlice 包含 aSlice[1], aSlice[2] 也就是含有: e,f
bSlice = aSlice[:3] // bSlice 包含 aSlice[0], aSlice[1], aSlice[2] 也就是
含有: d,e,f
bSlice = aSlice[0:5] // 对 slice 的 slice 可以在 cap 范围内扩展，此时
bSlice 包含：d,e,f,g,h
bSlice = aSlice[:] // bSlice 包含所有 aSlice 的元素: d,e,f,g
slice 是引用类型，所以当引用改变其中元素的值时，其它的所有引用都会改变该值，例如
上面的 aSlice 和 bSlice，如果修改了 aSlice 中元素的值，那么 bSlice 相对应的值也会改变。
从概念上面来说 slice 像一个结构体，这个结构体包含了三个元素：
• 一个指针，指向数组中 slice 指定的开始位置
• 长度，即 slice 的长度
• 最大长度，也就是 slice 开始位置到数组的最后位置的长度
• Array_a := [10]byte{‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘g’, ‘h’, ‘i’, ‘j’}
• Slice_a := Array_a[2:5]
上面代码的真正存储结构如下图所示
图 2.4 slice 对应数组的信息
对于 slice 有几个有用的内置函数：
• len 获取 slice 的长度
• cap 获取 slice 的最大容量
• append 向 slice 里面追加一个或者多个元素，然后返回一个和 slice 一样类型的
slice
• copy 函数 copy 从源 slice 的 src 中复制元素到目标 dst，并且返回复制的元素的个
数
注：append 函数会改变 slice 所引用的数组的内容，从而影响到引用同一数组的其它 slice。
但当 slice 中没有剩余空间（即(cap-len) == 0）时，此时将动态分配新的数组空间。返回的
slice 数组指针将指向这个空间，而原数组的内容将保持不变；其它引用此数组的 slice 则不
受影响。