Go语言中的map

map在Go语言
其中一个最有用的数据结构在计算机科学是散列表。 有许多实现的散列表与不同的性质，但在一般情况下它们提供了迅速查找，外，并删除。 去提供了一个内置的 map 的类型，实现了一散列表。

初始化
该map的类型在去是这样的：

map[KeyType]ValueType
在KeyType可以是任何类型的可比性(在此以后)，并ValueType可以是任何类型的所有人，包括另外一个map！

这可变米是map串钥匙int值：

var m map[string]int
map的类型的基准类型，例如指针或片，并使米以上的价值为零；它不点的初始化map。 一个空map的行为就像一个空map阅读时，但是尝试写入空map将导致运行时恐慌。 初始化的map，利用内在的使功能：

m = make(map[string]int)
使功能的分配和初始化的散列的map的数据结构以及返回地的价值这一点。 该方案的详细信息的数据结构是实施细节的运行环境和不限定的语言本身。 在这个职位，我们将重点放在使用的map，不执行它们。

map
去提供了一个熟悉的语法使用的map。 这个声明阐述的"路线"的关键66:

m["route"] = 66
这一声明可检索的价值存在"路线"的关键，并将其分配给新的可变i:

i := m["route"]
如果所请求的关键并不存在，我们得到空值的价值的类型。 在这种情况下，价值类型是整数，因此空值为0:

j := m["root"]
// j == 0
内建len功能返回的数量元素的map：

n := len(m)
内删除功能删除一个项目在map上：

delete(m, "route")
删除功能返回没什么，没什么，如果指定的关键并不存在。

分配测试有两个价值观存在的关键：

i, ok := m["route"]
在该声明中，第一个值(i)分配的价值存在"路线"的关键。 如果此项不存在，我是一个空值的价值类型(0). 第二个值("ok")是一个布尔(bool)价值，其具有的价值如果真的关键存在于map，和价值的虚假的，如果没有。

检查的关键，而不提取的数值时，使用下划线而不是第一个值：

_, ok := m["route"]
迭代map的内容，使用范围的关键词：

for key, value := range m {
fmt.Println("Key:", key, "Value:", value)
}
初始化的map与一些数据，使用的map的文字:

commits := map[string]int{
"rsc": 3711,
"r": 2138,
"gri": 1908,
"adg": 912,
}
相同的语法可以用来初始化空map，这在功能上等同于使用的做功能。:

m = map[string]int{}
使用空值
它可以方便地搜索返回的一个空值键时失踪。

例如，一个mapbool值可以被用作数据结构类似于一个组(记得，空值bool类型是假)。 这个例子看起来在联系的节点列表，并指纹他们的价值观。 它使用一个地点的指针，以检测循环中的列表。

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

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)
}
表访问了[n]是真实的，如果n访问，或假如果是不存在的。 没有必要使用两种价值的形成，以检查n在map上；默认值为零，这对于我们。

另一个例子的有用的空值的切片图. 当添加到一个空片，一个新的片是简单地分配，所以加入一个值的切片图是一个行操作；没有必要检查如果关键的存在。 在下面的例子中，一群人是填充的价值的人。 每个人都有一个名字和一个跨部分的喜欢。 这个例子创建一个map的链接每个喜欢的一群人喜欢它。

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.")
}
打印的人员的数量喜欢熏肉:

fmt.Println(len(likes["bacon"]), "people like bacon.")
注意，由于范围和len享零片作为一个长度为零片，这些最后的两个例子将工作，甚至如果没有人喜欢熏肉奶酪或(尽管这是不可能的).

关键类型
如前所述，map钥匙可以是任何类型是相当的。 语言规范规定了这种确切的，但在短期，相当类型布尔、数字、指针、管和接口类型，以及结构或阵列，仅含有这些类型。 部分，map，和功能都缺少清单。 这些类型的无法相比，使用==不可用作map键。

显然，串，整数和其他基本类型，应可为map键，但结构键可能意想不到的。 结构可用于关键的数据在多个层面。 例如，可以使用这种map的map，以数计的网页访问的国家：

hits := make(map[string]map[string]int)
这是一张map的串(map的串int)。 每一个外部map的关键路径的网页与其自己内部的map。 每个内部关键的卡是一个双字母国家代码。 这种表达返回的次数，一个澳大利亚已加载的文件页：

n := hits["/doc/"]["au"]
不幸的是，这种办法变得麻烦的时候添加数据，作为用于任何特定外国的关键，你要检查，如果一个内部的map存在，并创建它，如果有必要的：

func add(m map[string]map[string]int, path, country string) {
mm, ok := m[path]
if !ok {
mm = make(map[string]int)
m[path] = mm
}
mm[country]++
}
add(hits, "/doc/", "au")
另一方面，一个设计，使用一个单一的map是一个结构的关键消除了所有这一复杂性：

type Key struct {
Path, Country string
}
hits := make(map[Key]int)
当一名越南人访问该主页，增加(并可能创建)相对应的柜台在一个线：

hits[Key{"/", "vn"}]++
它只是作为容易看到许多瑞士人民已经阅读规范：

n := hits[Key{"/ref/spec", "ch"}]
竞争力
map是不安全的竞争性使用：这是不是定义发生了什么，当你读和写到他们在同一时间。 如果你需要阅读和书写的map，从竞争性地执行去的程序(go程序)，访问必须提供的一些同步机制。 一个最常见的方式来保护卡是同步的。 RWMutex.

该声明宣布一个计数变量，这是一个匿名的结构中含有一张map和内同步。 RWMutex.

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()
迭代了
当迭代map的使用范围循环，顺序的迭代的是没有指定，它不能保证，它将同从一个迭代的下一步。 如果你需要一个稳定的迭代了，你必须保持一个独立的数据结构定义这个顺序。 这个例子使用一个单独的排序关键片打印map[int]串键的顺序:

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])
}