字典在数学上的词汇是映射，将一个集合中的所有元素关联到另一个集合中的部分或全部元素，并且只能是一一映射或者多对一映射。
数组切片让我们具备了可以操作一块连续内存的能力，它是对同质元素的统一管理。而字典则赋予了不连续不同类的内存变量的关联性，它表达的是一种因果关系，字典的 key 是因，字典的 value 是果。如果说数组和切片赋予了我们步行的能力，那么字典则让我们具备了跳跃的能力。
指针、数组切片和字典都是容器型变量，字典比数组切片在使用上要简单很多，但是内部结构却无比复杂。本节我们只专注字典的基础使用，在后续的高级章节再来分析它的内部结构。
字典的创建
关于 Go 语言有很多批评的声音，比如说它不支持范型。其实严格来说 Go 是支持范型的，只不过很弱，范型在 Go 语言里是一种很弱的存在。比如数组切片和字典类型都是支持范型的。在创建字典时，必须要给 key 和 value 指定类型。创建字典也可以使用 make 函数
<code>package main
import "fmt"
func main() {
\tvar m map[int]string = make(map[int]string)
\tfmt.Println(m, len(m))
}
----------
map[] 0
复制代码/<code>
使用 make 函数创建的字典是空的，长度为零，内部没有任何元素。如果需要给字典提供初始化的元素，就需要使用另一种创建字典的方式。
<code>package main
import "fmt"
func main() {
\tvar m map[int]string = map[int]string{
\t\t90: "优秀",
\t\t80: "良好",
\t\t60: "及格", // 注意这里逗号不可缺少，否则会报语法错误
\t}
\tfmt.Println(m, len(m))
}
---------------
map[90:优秀 80:良好 60:及格] 3
复制代码/<code>
字典变量同样支持类型推导，上面的变量定义可以简写成
<code>var m = map[int]string{
90: "优秀",
80: "良好",
60: "及格",
}
复制代码/<code>如果你可以预知字典内部键值对的数量，那么还可以给 make 函数传递一个整数值，通知运行时提前分配好相应的内存。这样可以避免字典在长大的过程中要经历的多次扩容操作。
<code>var m = make(map[int]string, 16)
复制代码/<code>
字典的读写
同 Python 语言一样，字典可以使用中括号来读写内部元素，使用 delete 函数来删除元素。
<code>package main
import "fmt"
func main() {
\tvar fruits = map[string]int {
\t\t"apple": 2,
\t\t"banana": 5,
\t\t"orange": 8,
\t}
\t// 读取元素
\tvar score = fruits["banana"]
\tfmt.Println(score)
\t
\t// 增加或修改元素
\tfruits["pear"] = 3
\tfmt.Println(fruits)
\t
\t// 删除元素
\tdelete(fruits, "pear")
\tfmt.Println(fruits)
}
-----------------------
5
map[apple:2 banana:5 orange:8 pear:3]
map[orange:8 apple:2 banana:5]
复制代码/<code>
字典 key 不存在会怎样？
删除操作时，如果对应的 key 不存在，delete 函数会静默处理。遗憾的是 delete 函数没有返回值，你无法直接得到 delete 操作是否真的删除了某个元素。你需要通过长度信息或者提前尝试读取 key 对应的 value 来得知。
读操作时，如果 key 不存在，也不会抛出异常。它会返回 value 类型对应的零值。如果是字符串，对应的零值是空串，如果是整数，对应的零值是 0，如果是布尔型，对应的零值是 false。
你不能通过返回的结果是否是零值来判断对应的 key 是否存在，因为 key 对应的 value 值可能恰好就是零值，比如下面的字典你就不能判断 "durin" 是否存在
<code>var m = map[string]int {
"durin": 0 // 举个栗子而已，其实我还是喜欢吃榴莲的
}
复制代码/<code>这时候必须使用字典的特殊语法，如下
<code>package main
import "fmt"
func main() {
\tvar fruits = map[string]int {
\t\t"apple": 2,
\t\t"banana": 5,
\t\t"orange": 8,
\t}
\tvar score, ok = fruits["durin"]
\tif ok {
\t\tfmt.Println(score)
\t} else {
\t\tfmt.Println("durin not exists")
\t}
\tfruits["durin"] = 0
\tscore, ok = fruits["durin"]
\tif ok {
\t\tfmt.Println(score)
\t} else {
\t\tfmt.Println("durin still not exists")
\t}
}
-------------
durin not exists
0
复制代码/<code>
字典的下标读取可以返回两个值，使用第二个返回值都表示对应的 key 是否存在。初学者看到这种奇怪的用法是需要花时间来消化的，读者不需要想太多，它只是 Go 语言提供的语法糖，内部并没有太多的玄妙。正常的函数调用可以返回多个值，但是并不具备这种“随机应变”的特殊能力 —— 「多态返回值」。
字典的遍历
字典的遍历提供了下面两种方式，一种是需要携带 value，另一种是只需要 key，需要使用到 Go 语言的 range 关键字。
<code>package main
import "fmt"
func main() {
\tvar fruits = map[string]int {
\t\t"apple": 2,
\t\t"banana": 5,
\t\t"orange": 8,
\t}
\tfor name, score := range fruits {
\t\tfmt.Println(name, score)
\t}
\tfor name := range fruits {
\t\tfmt.Println(name)
\t}
}
------------
orange 8
apple 2
banana 5
apple
banana
orange
复制代码/<code>
奇怪的是，Go 语言的字典没有提供诸于 keys() 和 values() 这样的方法，意味着如果你要获取 key 列表，就得自己循环一下，如下
<code>package main
import "fmt"
func main() {
\tvar fruits = map[string]int {
\t\t"apple": 2,
\t\t"banana": 5,
\t\t"orange": 8,
\t}
\tvar names = make([]string, 0, len(fruits))
\tvar scores = make([]int, 0, len(fruits))
\tfor name, score := range fruits {
\t\tnames = append(names, name)
\t\tscores = append(scores, score)
\t}
\tfmt.Println(names, scores)
}
----------
[apple banana orange] [2 5 8]
复制代码/<code>
这会让代码写起来比较繁琐，不过 Go 语言官方就是没有提供，读者还是努力习惯一下吧
线程(协程)安全
Go 语言的内置字典不是线程安全的，如果需要线程安全，必须使用锁来控制。在后续锁的章节里，我们将会自己实现一个线程安全的字典。
字典变量里存的是什么？
字典变量里存的只是一个地址指针，这个指针指向字典的头部对象。所以字典变量占用的空间是一个字，也就是一个指针的大小，64 位机器是 8 字节，32 位机器是 4 字节。
可以使用 unsafe 包提供的 Sizeof 函数来计算一个变量的大小
<code>package main
import (
\t"fmt"
\t"unsafe"
)
func main() {
\tvar m = map[string]int{
\t\t"apple": 2,
\t\t"pear": 3,
\t\t"banana": 5,
\t}
\tfmt.Println(unsafe.Sizeof(m))
}
------
8
复制代码/<code>
思考题
在遍历字典得到 keys 和 values 的例子里，我们分配了 names 和 scores 两个切片，如果把代码片断调整成下面这样，会有什么问题？
<code>var names = make([]string, len(fruits))
var scores = make([]int, len(fruits))/<code>
閱讀更多 Echa攻城獅 的文章
