go map 比较深入的使用方案

参考blog： https://blog.golang.org/go-maps-in-action

现在基本上所有的编程语言都有自带的map，或者dict，主要提供一个快速的查找，插入，删除，具备与存储体量无关的O（1）的性能，并且支持key上面的唯一性，
比如java里的HashMap，python里的Dictionary，scala里的各种Map等等。

go也原生提供了一个类似的数据类型，就叫做map。首先它是个mutable的，也就是说，可以随时对其进行修改。其次，它不是线程安全的。所以等价于java里的HashMap。

申明和初始化

map[KeyType]ValueType

这里的KeyType代表map的key类型，一定要是 comparable 的，而ValueType可以是任意的类型，甚至包括其他的内嵌的map
比如

var m map[string]int

这里的keyType是string，valueType就是int

map在go里是属于reference type，也就是作为方法的型参或者返回类型的是时候，传递也是这个reference的地址。不是map的本体。其次，这个map在申明的时候是nil map，需要如果没有初始化，那么就是nil
对于这个nil的map，可以对其进行任意的取值，返回都是（nil，err），但是如果对其设置一个新的值，就会panic
A nil map behaves like an empty map when reading, but attempts to write to a nil map will cause a runtime panic; don’t do that

所以需要先初始化，方法1:

m = make(map[string]int)

方法二：

var m map[string]int = map[string]int{"hunter":12,"tony":10}

或者初始化一个空的map

m = map[string]int{}

读取

i := m["route"]

如果route存在，就返回那个值，如果不存在，返回0值，也就是说，根据这个value的类型，返回缺省值，比如string，就返回“”，int 就返回0

删除

delete(m,"route")

如果route存在，删除成功，否则什么都没有发生
因为读取在不存在key的时候返回0值，为了区分是否成功，可以采用如下手段

i, ok := m["route"]

遍历

for key, value := range m {
    fmt.Println("Key:", key, "Value:", value)
}

稍微高级点的用法

利用0值，因为当从map中读取一个不存在的key的时候，返回0值，有时候很麻烦，有时候也可以很巧妙的利用起来，参考原文英文中的例子

type Node struct {
    Next  *Node
    Value interface{}
}
var first *Node

func main(){
visited := make(map[*Node]bool)
    for n := first; n != nil; n = n.Next {
        if visited[n] {
            fmt.Println("cycle detected")
            break
        }
        visited[n] = true
        fmt.Println(n.Value)
    }
}

这是一个检测单向链表是否有环的比较笨的办法，原理就是利用map判断这个key为＊Node的值在map中是否出现过来确定是否有环。
这里的visited就是map，从这里我们可以看到，指针类型也是comparable的，所以可以作为keytype，其次，调用if语句中的visited［n］的时候，我们巧妙的利用了bool类型的0值就是false这个原理，来判断这个keytype是否已经出现。

还是原文中的例子：

    type Person struct {
        Name  string
        Likes []string
    }
    var people []*Person

    likes := make(map[string][]*Person)
    for _, p := range people {
        for _, l := range p.Likes {
            likes[l] = append(likes[l], p)
        }
    }

    for _, p := range likes["cheese"] {
        fmt.Println(p.Name, "likes cheese.")
    }

我们有一个自定义的struct，Person，里面存了人的名字和他／她的爱好，现在我们要写一个简单的小程序，把所有的people（人员）按照相同兴趣进行分类

我们这里的代码就是利用两个go里的特征，
1, range对于非nil的map，可以进行遍历，但是如果是nil的map（也就是没有初始化的map），默认按照空的map处理，也就是不运行for循环的逻辑代码
2, append支持非nil和nil 的map，都能进行成功的append。这样，就能简化代码

刚才提到map里的keytype必须是comparable的，go的文档里有明确的定义：
The language spec defines this precisely, but in short, comparable types are boolean, numeric, string, pointer, channel, and interface types, and structs or arrays that contain only those types.

Notably absent from the list are slices, maps, and functions;

these types cannot be compared using ==, and may not be used as map keys.

线程安全（goroutine）

前面提到go的map不是线程安全的，因此需要加锁，一般的方法是，定义一个embeded的struct，类似于子类

var counter = struct{
    sync.RWMutex
    m map[string]int
}{m: make(map[string]int)}

读的时候，调用读锁

counter.RLock()
n := counter.m["some_key"]
counter.RUnlock()
fmt.Println("some_key:", n)

写的时候，写锁

counter.Lock()
counter.m["some_key"]++
counter.Unlock()

＃ 读取顺序
go的map是hashmap，所以读取遍历的顺序是不保证的，如果业务需要保证key的遍历顺序，建议将key单独保存到一个slice里

import "sort"

var m map[int]string
var keys []int
for k := range m {
    keys = append(keys, k)
}
sort.Ints(keys)
for _, k := range keys {
    fmt.Println("Key:", k, "Value:", m[k])
}