Go 语言类型 映射
基本概念
映射（Map）是用于储存一系列无序键值对的数据结构。映射类型适合用于存储和检索关联数据，类似其他编程语言中的哈希表或字典。
在 Go 语言映射中，键（key）和值（value）是组成映射的基本元素，每个键都关联到一个特定值：
- 键：键用来在映射中唯一标识值。键类型必须是可比较类型，包括所有基本类型以及数组和结构体，不包括引用类型。
- 值：值是映射中与键相关联的数据。在同一个映射中，所有值类型都必须相同，值类型可以是任意类型，包括映射或结构体。
映射提供一种直观方式来表达数据之间的联系，底层实现是一个散列表，属于引用类型。
创建映射
映射在使用前必须初始化，为其分配内存空间，才能存储键值对。
声明和初始化
以下是声明和初始化映射方法：
package main
import "fmt"
func main() {
// 声明一个 nil 映射，不能直接使用
// 切片不能作为键，但数组可以
var a map[[3]int]int
// 声明并使用字面量初始化映射
var b = map[string]int{"a": 1, "b": 2}
// 短变量声明，采用多行赋值形式
// 如果 } 另起一行，最后一个元素后必须加逗号
c := map[string]int{
"c": 3,
"d": 4,
}
// 使用 make 函数创建并初始化空映射
// 容量参数可选，预设有助于提高性能
d := make(map[string]int, 100)
// 输出：map[] map[a:1 b:2] map[c:3 d:4] map[]
fmt.Println(a, b, c, d)
}nil 映射
和 nil 切片不同，nil 映射由于没分配内存，不能直接用于储存键值对。尝试添加键值对会引发运行时错误，必须先通过 make 函数初始化：
package main
import "fmt"
func main() {
// 声明一个 nil 映射
var m map[string]int
// 可以读取 nil 映射
value := m["k"]
fmt.Println("读取不存在的键值:", value) // 输出：0
// 尝试添加键值对会导致运行时错误
m["k"] = 1 // 报错：assignment to entry in nil map
// 使用 make 函数初始化
m = make(map[string]int)
m["k"] = 1
fmt.Println("添加键值后:", m) // 输出：map[k:1]
}nil 映射不占用内存，可以用于延迟初始化或作为函数返回值。
映射操作
只要映射已初始化，映射操作基本是安全的。
读取键值
映射中可以通过键来获取元素值，此外还会获取到键存在标志。如果键值对不存在，存在标志为 false 并返回值类型零值：
package main
import "fmt"
func main() {
m := map[string]int{"Alice": 68000, "Bob": 72000}
// 对返回分别赋值
salary, exists := m["Charlie"]
if exists {
fmt.Println(salary)
} else {
fmt.Println(salary, exists) // exists 值为 false，salary 为 0
}
}键存在标志是通过比较运算得到，所以键才必须是可比较类型。但和切片一样，映射之间不可比较，只能同 nil 做比较。
修改键值
修改映射键值对通过赋值来实现。如果键不存在，会新增键值对记录；如果键存在，赋值操作会更新该键值：
package main
import "fmt"
func main() {
m := map[string]int{"Alice": 68000, "Bob": 72000}
fmt.Println("初始工资：", m)
// 添加新记录
m["Charlie"] = 90000
fmt.Println("添加操作后：", m)
// 更新记录
m["Alice"] = 71000
fmt.Println("更新操作后：", m)
}遍历映射
可以使用 for 和 range 来遍历映射中所有键值对：
package main
import "fmt"
func main() {
m := map[string]int{"Alice": 101, "Bob": 102, "Charlie": 104, "David": 103}
// 使用 len 获取映射中键值对数量
fmt.Println("员工数量：", len(m))
// 使用 for 和 range 遍历映射，每次迭代输出顺序可能不同
for k, v := range m {
fmt.Printf("%s 在部门编号：%d\n", k, v)
}
}由于映射内元素排序不固定，因此不能对映射元素取址。
删除键值
Go 语言提供内置 delete 函数，用于删除映射中的键值对。 delete 函数没有返回值，如果键值对存在则删除；如果不存在则忽略，不会报错：
package main
import "fmt"
func main() {
m := map[string]int{"Alice": 7000, "Bob": 8000, "Charlie": 9000}
fmt.Println("初始映射：", m)
// 删除存在的键
delete(m, "Bob")
fmt.Println("第一次删除：", m)
// 尝试删除不存在的键
delete(m, "David")
fmt.Println("第二次删除：", m) // 输出没有变化
}复制映射
映射是引用类型，所以在函数中对映射修改，会影响所有被传递映射的引用。可以在函数内部创建映射副本，修改并返回副本。复制映射需要创建一个空映射，遍历原始映射键值对来填充新映射：
package main
import "fmt"
func modify(m map[string]int) map[string]int {
// 创建映射副本
n := make(map[string]int)
for k, v := range m {
n[k] = v
}
n["c"] = 3
return n
}
func main() {
m := map[string]int{"a": 1, "b": 2}
n := modify(m)
fmt.Println("原始映射：", m)
fmt.Println("新映射：", n)
}注意，当映射值是复杂数据结构（如切片、其他映射或包含指针的结构体）时，仅复制键值对复制的可能是指针，不是真正的深度复制。除了手动实现更深层次复制逻辑，也可以借助第三方库 copier 和 deepcopy，或者通过 encoding/gob 包序列化和反序列化对象到内存中来实现深度复制。
模拟集合
Go 语言没有集合类型，可利用映射键特性来模拟集合去重功能：
package main
import "fmt"
func main() {
// 原始数组
a := [...]int{1, 2, 3, 2, 1}
// 建立一个映射模拟集合
m := map[int]bool{}
// 创建一个切片来保存结果
s := []int{}
// 利用键的唯一性填充映射
for _, v := range a {
m[v] = true
}
// 通过查询键值来判断状态
fmt.Println(m[1]) // 值已存入，输出：true
fmt.Println(m[10]) // 没在映射，输出：false
// 将键存入切片
for k := range m {
s = append(s, k)
}
fmt.Println(s) // 输出: [1 2 3]
}并发映射
映射类型在并发情况下允许同时读，但同时写会导致运行时错误：
package main
func main() {
m := make(map[int]int)
// 不停写入
go func() {
for {
m[0] = 0
}
}()
// 不停读取
go func() {
for {
_ = m[1]
}
}()
// 无限循环，让并发程序在后台执行
for {
}
}上面代码会报错：concurrent map read and map write，指出两个并发函数读写映射时发生竟态问题。
除了加锁外，可以使用 sync.Map 替代映射。sync.Map 是一个支持并发安全的映射类型，使用上与原生映射不太相同，需要调用专属方法：
package main
import (
"fmt"
"sync"
)
func main() {
// 不需要初始化，直接声明后使用
var m sync.Map
// 储存键值对，以 interface{} 类型保存值
m.Store("a", 1)
m.Store("b", 2)
// 也用于更新键值对
m.Store("b", 20)
// 获取键值对
v, ok := m.Load("b")
if ok {
fmt.Println(v) // 输出：20
}
fmt.Println(m.Load("c")) // 输出：<nil> false
// 如果键存在则读取值，否则储存键值对
v, ok = m.LoadOrStore("c", 3)
fmt.Println(v, ok)
// 删除键值对
m.Delete("a")
// 遍历键值对需要提供一个函数，函数可以操作键值。这里只打印
m.Range(func(key, value interface{}) bool {
fmt.Println(key, ":", value)
return true
})
}使用 sync.Map 能保证并发安全，且对读操作进行过优化，适合读多写少的场景。