go——字典

Go中字典类型是散列表（hash table）的一个实现，其官方称谓是map。
散列表是一个实现了关联数组的数据结构，关联数组是用于表示键值对的无序集合的一种抽象数据类型。
Go中称键值对为键-元素对，它把字典中的每个键都看作与其对应的元素的索引，这样的索引再同一个字典值中是唯一的。
下面的代码声明了一个字典类型的变量：

var ipSwitches = map[string]bool{}

变量ipSwitches的键类型为string，元素类型为bool。
map[string]bool{}表示了一个不包含任何元素的字典值。
与切片类型一样，字典类型是一个引用类型。也正因此，字典类型的零值是nil。
字典值的长度表示了其中的键-元素对的数量，其零值的长度总是0.
将其作为语言内置类型，从运行时层面进行优化，可获得更高效的性能。
作为无序键值对集合，字典要求key必须是支持相等运算符（==、！=）的数据类型。

字典是引用类型,使用make函数或初始化表达式来创建。

package main

import "fmt"

func main() {
	m := make(map[string]int) //make函数创建
	m["a"] = 1
	m["b"] = 2

	m2 := map[int]struct { //key的类型int，value的类型struct
		x int
	}{
		1: {x: 100},
		2: {x: 200},
	}
	fmt.Println(m, m2) //map[a:1 b:2] map[1:{100} 2:{200}]
}

字典的基本操作:增删改查

package main

import "fmt"

func main() {
	m := map[string]int{
		"a": 1,
		"b": 2,
	}

	m["a"] = 10    //修改
	m["c"] = 30    //添加
	fmt.Println(m) //map[a:10 b:2 c:30]

	if v, ok := m["d"]; ok { //使用ok-idiom判断键是否存在
		fmt.Println(v)
	}

	delete(m, "b")      //删除一个键值对
	fmt.Println(m)      //map[a:10 b:2 c:30]
	fmt.Println(m["f"]) //0  访问不存在的键值对时返回0值
}

对字典进行迭代每次返回的键值次序都不相同

package main

import "fmt"

func main() {
	m := make(map[string]int)

	for i := 0; i < 7; i++ {
		m[string('a'+i)] = i
	}

	for i := 0; i < 4; i++ {
		for k, v := range m {
			fmt.Printf("%s:%d  ", k, v)
		}
		fmt.Println()
	}
}

/*
g:6  a:0  b:1  c:2  d:3  e:4  f:5
e:4  f:5  g:6  a:0  b:1  c:2  d:3
g:6  a:0  b:1  c:2  d:3  e:4  f:5
a:0  b:1  c:2  d:3  e:4  f:5  g:6
*/

函数len返回当前键值对的数量,cap不接受字典类型.
因内存访问安全和哈希算法等缘故,字典被设计成"not addressable",
因此不能直接修改value成员(结构或数组)。

package main

import "fmt"

func main() {
	type user struct {
		name string
		age  int
	}

	m := map[int]user{
		1: {"kebi", 19},
	}
	fmt.Println(len(m)) //1
	fmt.Println(cap(m)) //invalid argument m (type map[int]user) for cap
	m[1].age += 1       // cannot assign to struct field m[1].age in map
}

正确的做法是返回整个value,待修改后再设置字典键值,或直接用指针类型。

package main

import "fmt"

func main() {
	type user struct {
		name string
		age  int
	}

	m := map[int]user{
		1: {"kebi", 19},
	}

	u := m[1]  //取出整个value值
	u.age += 1 //现在操作的对象是结构体
	m[1] = u   //重新赋值
	fmt.Println(m)

	m2 := map[int]*user{ //value是指针类型
		1: &user{"Jack", 20},
	}
	m2[1].age++ //m2[1]返回的是指针,透过指针修改目标对象
	fmt.Println(m2[1])
}

　

不能对nil字典进行赋值操作,但却能读。

package main

import "fmt"

func main() {
	var m map[string]int //只进行声明的字典是nil字典
	fmt.Println(m["a"])  //0
	// m["a"] = 1          //panic: assignment to entry in nil map

	m2 := map[string]int{}
	fmt.Println(m == nil, m2 == nil) //true  false
}

在迭代期间删除或新增键值是安全的。

package main

import "fmt"

func main() {
	m := make(map[int]int)

	for i := 0; i < 10; i++ {
		m[i] = i + 10
	}

	for k := range m {
		if k == 5 {
			m[100] = 1000
		}
		delete(m, k)
		fmt.Println(k, m)
	}
}

/*
0 map[9:19 2:12 6:16 8:18 7:17 1:11 3:13 4:14 5:15]
2 map[5:15 7:17 1:11 3:13 4:14 8:18 9:19 6:16]
6 map[4:14 5:15 7:17 1:11 3:13 8:18 9:19]
8 map[7:17 1:11 3:13 4:14 5:15 9:19]
9 map[4:14 5:15 7:17 1:11 3:13]
1 map[3:13 4:14 5:15 7:17]
3 map[4:14 5:15 7:17]
4 map[5:15 7:17]
5 map[7:17 100:1000]
7 map[100:1000]
*/

运行时会对字典并发操作做出检测.如果某个任务正在对字典进行写操作,
那么其它任务就不能对该字典执行并发操作(读写删除),否则会导致进程崩溃.

package main

import "time"

func main() {
	m := make(map[string]int)

	go func() {
		for {
			m["a"] += 1
			time.Sleep(time.Microsecond)
		}
	}()

	go func() {
		for {
			_ = m["b"]
			time.Sleep(time.Microsecond)
		}
	}()
	select {}
}

//fatal error: concurrent map read and map write