go——字典

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

1	`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