golang map由浅入深的搬运工

1. map的声明与初始化
golang中的map声明非常简单，我们用map关键字表示声明一个map，中括号内是key的类型，后面跟上value的类型

Copy
//定义一个key为int，value为string的map
var m map[int] string

注意，map的声明的时候默认值是nil。此时进行取值，返回的是对应类型的零值（不存在也是返回零值）。

Copy
// bool 的零值是false
var m map[int]bool 
a, ok := m[1]
fmt.Println(a, ok) // false  false

// int 的零值是0
var m map[int]int 
a, ok := m[1]
fmt.Println(a, ok) // 0  false

map的初始化

Copy
// 声明之后必须初始化，才能使用
m = make(map[string]int)
m = map[string]int{}

// 声明并初始化  注意这里是 := 不是 =
m := make(map[string]int)
m := map[string]int{1:1}

如果向未初始化的map赋值会返回panic

key与value的限制
key一定要是可比较的类型（可以理解为支持==的操作），但是value可以为任意类型

可比较类型：
boolean
numeric
string
pointer
channel
interface
包含前文类型的array和struct

如果是非法的key类型，会报错：invalid map key type xxx。
golang为uint32、uint64、string提供了fast access，使用这些类型作为key可以提高map访问速度。[runtime/hashmap_fast.go]

curd

Copy
// 新增
m["name"] = "AKisumu"

// 删除，key不存在则啥也不干
delete(m, "name")

// 更新
m["name"] = "KiyoAki"

// 查询，key不存在返回value类型的零值
i := m["name"] // 三种查询方式，
i, ok := m["name"]
_, ok := m["name"]

遍历

需要强调的是map本身是无序的，在遍历的时候并不会按照你传入的顺序，进行传出。

Copy
正常遍历：

fo k, v := range m { 
    fmt.Println(k, v)
}
1
2
3
有序遍历：

import "sort"
var keys []string
// 把key单独抽取出来，放在数组中
for k, _ := range m {
    keys = append(keys, k)
}
// 进行数组的排序
sort.Strings(keys)
// 遍历数组就是有序的了
for _, k := range keys {
    fmt.Println(k, m[k])
}

函数传参
Golang中是没有引用传递的，均为值传递。这意味着传递的是数据的拷贝。
那么map本身是引用类型，作为形参或返回参数的时候，传递的是值的拷贝，而值是地址，扩容时也不会改变这个地址。

Copy
var m map[int64]int64
m = make(map[int64]int64, 1)
fmt.Printf("m 原始的地址是：%p\n", m)
changeM(m)
fmt.Printf("m 改变后地址是：%p\n", m)
fmt.Println("m 长度是", len(m))
fmt.Println("m 参数是", m)

// 改变map的函数
func changeM(m map[int64]int64) {
	fmt.Printf("m 函数开始时地址是：%p\n", m)
	var max = 5
	for i := 0; i < max; i++ {
		m[int64(i)] = 2
	}
	fmt.Printf("m 在函数返回前地址是：%p\n", m)
}

输出：

Copy
m 原始地址是：0xc42007a180
m 函数开始时地址是：0xc42007a180
m 在函数返回前地址是：0xc42007a180
m 改变后地址是：0xc42007a180
m 长度是 5
m 参数是  map[3:2 4:2 0:2 1:2 2:2]