Go 学习笔记（八）map 类型
本文原创地址：博客园骏马金龙Go 基础系列：map 类型
Go 里的 map 用于存放 key/value 对，在其它地方常称为 hash、dictionary、关联数组，这几种称呼都是对同一种数据结构的不同称呼，它们都用于将 key 经过 hash 函数处理，然后映射到 value，实现一一对应的关系。
map 的内部结构
一个简单的 map 结构示意图：
在向 map 中存储元素的时候，会将每个 key 经过 hash 运算，根据运算得到的 hash 值选择合适的 hash bucket(hash 桶)，让后将各个 key/value 存放到选定的 hash bucket 中。如果一来，整个 map 将根据 bucket 被细分成很多类别，每个 key 可能会交叉地存放到不同的 bucket 中。
所以，map 中的元素是无序的，遍历时的顺序是随机的，即使两次以完全相同的顺序存放完全相同的元素，也无法保证遍历时的顺序。
由于要对 key 进行 hash 计算选择 hash bucket，所以 map 的 key 必须具有唯一性，否则计算出的 hash 值相同，将人为出现 hash 冲撞。
在访问、删除元素时，也类似，都要计算 key 的 hash 值，然后找到对应的 hash bucket，进而找到 hash bucket 中的 key 和 value。
Go 中的 map 是一个指针，它的底层是数组，而且用到了两个数组，其中一个更底层的数组用于打包保存 key 和 value。
创建、访问 map
可以通过 make() 创建 map，它会先创建好底层数据结构，然后再创建 map，并让 map 指向底层数据结构。
my_map := make(map[string]int)
其中[string]表示 map 的 key 的数据类型，int表示 key 对应的值。
也可以直接通过大括号创建并初始化赋值：
// 空map
my_map := map[string]string{}
// 初始化赋值
my_map := map[string]string{"Red": "#da1337","Orange": '#e95a22"}
// 格式化赋值
my_map := map[string]int{
"Java":11,
"Perl":8,
"Python":13, // 注意结尾的逗号不能少
}
其中 map 的 key 可以是任意内置的数据类型 (如 int)，或者其它可以通过 "==" 进行等值比较的数据类型，如 interface 和指针可以。slice、数组、map、struct 类型都不能作为 key。
但 value 基本可以是任意类型，例如嵌套一个 slice 到 map 中：
my_map := map[string][]int{}
访问 map 中的元素时，指定它的 key 即可，注意 string 类型的 key 必须加上引号：
my_map := map[string]int{
"Java":11,
"Perl":8,
"Python":13,
}
// 访问
println(my_map["Perl"])
// 赋值已有的key & value
my_map["Perl"] = 12
println(my_map["Perl"])
// 赋值新的key & value
my_map["Shell"] = 14
println(my_map["Shell"])
nil map 和空 map
空 map 是不做任何赋值的 map：
// 空map
my_map := map[string]string{}
nil map，它将不会做任何初始化，不会指向任何数据结构：
// nil map
var my_map map[string]string
nil map 和 empty map 的关系，就像 nil slice 和 empty slice 一样，两者都是空对象，未存储任何数据，但前者不指向底层数据结构，后者指向底层数据结构，只不过指向的底层对象是空对象。使用 println 输出看下即可知道：
package main
func main() {
var nil_map map[string]string
println(nil_map)
emp_map := map[string]string{}
println(emp_map)
}
输出结果：
0x0
0xc04204de38
所以， map 类型实际上就是一个指针 。
map 中元素的返回值
当访问 map 中某个元素的时候，有两种返回值的格式：
value := my_map["key"]
value,exists := my_map["key"]
第一种很好理解，就是检索 map 中 key 对应的 value 值。如果 key 不存在，则 value 返回值对应数据类型的 0。例如 int 为数值 0，布尔为 false，字符串为空 ""。
第二种不仅返回 key 对应的值，还根据 key 是否存在返回一个布尔值赋值给 exists 变量。所以，当 key 存在时，value 为对应的值，exists 为 true；当 key 不存在，value 为 0(同样是各数据类型所代表的 0)，exists 为 false。
看下例子：
my_map := map[string]int{
"Java":11,
"Perl":8,
"Python":13,
}
value1 := my_map["Python"]
value2,exists2 := my_map["Perl"]
value3,exists3 := my_map["Shell"]
println(value1)
println(value2,exists2)
println(value3,exists3)
上面将输出如下结果：
13
8 true
0 false
在 Go 中设置类似于这种多个返回值的情况很多，即便是自己编写函数也会经常设置它的 exists 属性。
len()和 delete()
len()函数用于获取 map 中元素的个数，即有多个少 key。delete() 用于删除 map 中的某个 key。
func main() {
my_map := map[string]int{
"Java": 11,
"Perl": 8,
"Python": 13,
"Shell": 23,
}
println(len(my_map)) // 4
delete(my_map,"Perl")
println(len(my_map)) // 3
}
测试 map 中元素是否存在
两种方式可以测试 map 中是否存在某个 key：
- 根据 map 元素的第二个返回值来判断
- 根据返回的 value 是否为 0(不同数据类型的 0 不同) 来判断
方式一：直接访问 map 中的该元素，将其赋值给两个变量，第二个变量就是元素是否存在的修饰变量。
my_map := map[string]int{
"Java":11,
"Perl":8,
"Python":13,
}
value,exists := my_map["Perl"]
if exists {
println("The key exists in map")
}
可以将上面两个步骤合并起来，看着更高大上一些：
if value,exists := my_map["Perl"];exists {
println("key exists in map")
}
方式二：根据 map 元素返回的 value 判断。因为该 map 中的 value 部分是 int 类型，所以它的 0 是数值的 0。
my_map := map[string]int{
"Java":11,
"Perl":8,
"Python":13,
}
value := my_map["Shell"]
if value == 0 {
println{"not exists in map"}
}
如果 map 的 value 数据类型是 string，则判断是否为空：
if value == "" {
println("not exists in map")
}
由于 map 中的 value 有可能本身是存在的，但它的值为 0，这时就会出现误判断。例如下面的 "Shell"，它已经存在，但它对应的值为 0。
my_map := map[string]int{
"Java":11,
"Perl":8,
"Python":13,
"Shell":0,
}
所以，应当使用第一种方式进行判断元素是否存在。
迭代遍历 map
因为 map 是 key/value 类型的数据结构，key 就是 map 的 index，所以 range 关键字对 map 操作时，将返回 key 和 value。
my_map := map[string]int{
"Java":11,
"Perl":8,
"Python":13,
"Shell":23,
}
for key,value := range my_map {
println("key:",key," value:",value)
}
如果 range 迭代 map 时，只给一个返回值，则表示迭代 map 的 key：
my_map := map[string]int{
"Java":11,
"Perl":8,
"Python":13,
"Shell":23,
}
for key := range my_map {
println("key:",key)
}
获取 map 中所有的 key
Go 中没有提供直接获取 map 所有 key 的函数。所以，只能自己写，方式很简单，range 遍历 map，将遍历到的 key 放进一个 slice 中保存起来。
package main
import "fmt"
func main() {
my_map := map[string]int{
"Java": 11,
"Perl": 8,
"Python": 13,
"Shell": 23,
}
// 保存map中key的slice
// slice类型要和map的key类型一致
keys := make([]string,0,len(my_map))
// 将map中的key遍历到keys中
for map_key,_ := range my_map {
keys = append(keys,map_key)
}
fmt.Println(keys)
}
注意上面声明的 slice 中要限制长度为 0，否则声明为长度 4、容量 4 的 slice，而这 4 个元素都是空值，而且后面 append()会直接对 slice 进行一次扩容，导致 append() 后的 slice 长度为 map 长度的 2 倍，前一半为空，后一般才是 map 中的 key。
传递 map 给函数
map 是一种指针，所以将 map 传递给函数，仅仅只是复制这个指针，所以函数内部对 map 的操作会直接修改外部的 map。
例如，addone() 用于给 map 的 key 对应的值加 1。
package main
func main() {
my_map := map[string]int{
"Java": 11,
"Perl": 8,
"Python": 13,
"Shell": 23,
}
println(my_map["Perl"]) // 8
addone(my_map,"Perl")
println(my_map["Perl"]) // 9
}
func addone(m map[string]int,key string) {
m[key] += 1
}
使用函数作为 map 的值
map 的值可以是任意对象，包括函数、指针、stuct 等等。如果将函数作为 key 映射的值，则可以用于实现一种分支结构。
map_func := map[KEY_TYPE]func() RETURN_TYPE {......}
map_func := make(map[KEY_TYPE]func() RETURN_TYPE)
例如：
func main() {
mf := map[int]func() int{
1: func() int { return 10 },
2: func() int { return 20 },
5: func() int { return 50 },
}
fmt.Println(mf) // 输出函数的指针
a := mf[1]() // 调用某个分支的函数
println(a)
}
func main() {
mf := make(map[int]func() string)
mf[1] = func() string{ return "10" }
mf[2] = func() string{ return "20" }
mf[3] = func() string{ return "30" }
mf[4] = func() string{ return "40" }
fmt.Println(mf[2]())
}