Golang map

Posted 2023-05-16

参考技术A 然后就要看元素在bucket中的存储结构了。

以上就是go map的大体结构和实现方法了。

Golang实践录：map的几个使用示例

本文针对 Golang 的 Map 实现几个简单示例。这些都是在实际工程中使用到的。

基本使用

map 是一种无序的基于key-value的数据结构，Golang 的 map 是引用类型，因此必须初始化才能使用。

下面给出几种初始化形式示例：

var m map[string]int
m = make(map[string]int)
​
m := make(map[string]int)
​
var FuncMap = map[string]func(int, string)
...

​
var allMap map[string]PersonInfo_t
allMap = make(map[string]PersonInfo_t)

增加：

m["latelee"] = 250

删除：

delete(m, "latelee")

查询 key 是否存在：

if v, ok := allMap[id]; ok 
...

遍历：

for k, v := range allMap 
    ...

实践

对基本使用有一定了解后，需根据实际应用场合使用，本节列举几个示例：

函数调用

需求：一个命令模块，根据不同的命令名称，调用不同的函数。

可用数组实现，但要遍历查询；也可用if判断，如果用 map 实现，从代码整洁和维护角度看，都是个不错的选择。定义的FuncMap，key为命令，value为函数指针，具体代码如下：

// 全局变量，映射，可由其它包使用
// 简单定义map的函数指针
var FuncMap = map[string]func(int, string)
    "111": map1,
    "222": map2,

​
func map1(a int, b string) 
    fmt.Println("111", a, b)

​
func map2(a int, b string) 
    fmt.Println("222", a, b)

​
func test1(id string) 
    a := 250
    b := "25.250"
    if fn, ok := FuncMap[id]; ok 
        fn(a, b)
     else 
        fmt.Println(id, "not found func")
    

输出结果：

111 250 25.250
222 250 25.250
333 not found func

多线程的使用

需求：工程中有较多线程（Golang中实际上协程），对同一个 map 有读、写的操作，此时，普通的 map 则无法适应，需使用sync.Map，使用也简单，主要函数有：

添加：g_syncMap.Store。

删除：g_syncMap.Delete(key)。

测试代码如下：

// sync.Map使用
​
var g_syncMap sync.Map
​
func showSyncMap() 
    // 遍历打印，不做死循环
    g_syncMap.Range(func(k, v interface) bool 
        v1 := v.(string)
        fmt.Printf("key: %v -> %v\\n", k, v1)
        return true
    )

​
func test2() 
    // 存
    g_syncMap.Store(1, "111")
    g_syncMap.Store(2, "222")
    g_syncMap.Store(3, "333")
    showSyncMap()
​
    // 删除
    g_syncMap.Delete(1)
    showSyncMap()
​
    g_syncMap.Store(3, "333_111") // 重复写同一个key，会更新为新的
    showSyncMap()
​
    //Load 方法，获得value
    if v, ok := g_syncMap.Load(2); ok 
        fmt.Println("Load ->", v)
    
    //LoadOrStore方法，获取或者保存
    //参数是一对key：value，如果该key存在且没有被标记删除则返回原先的value（不更新）和true；
    // 不存在则store，返回该value 和false
    if vv, ok := g_syncMap.LoadOrStore(1, "c"); !ok  // 前面删除1了，这里重新保存
        fmt.Println("save new", vv)
    
    if vv, ok := g_syncMap.LoadOrStore(2, "c"); ok  // 2 一直存在
        fmt.Println("exist", vv, ok)
    
    showSyncMap()

输出结果如下：

key: 1 -> 111
key: 2 -> 222
key: 3 -> 333
key: 2 -> 222
key: 3 -> 333
key: 2 -> 222
key: 3 -> 333_111
Load -> 222
save new c
exist 222 true
key: 1 -> c
key: 2 -> 222
key: 3 -> 333_111

多 key 单独查询

需求：某种数据有很多个字段，可以根据其中的一些字段查询的对象。如某一人员信息，有ID、code代码、名称等，可以根据ID查人员信息，也可以根据code代码查，还可以根据名称查（假定名称不重复）。

由于 map 不能有多个 key，因此使用多个 map 映射。设主信息的 allMap 的 key 为 ID，value 为人员信息。另外有若干辅助 map，cMap 的 key 为 code，value为ID；hMap类似，key 为 hex 码，value 为 ID。查询时，先查辅助 map，得到 ID值，再查主 map。

示例代码：

type PersonInfo_t struct 
    id   string
    hex  string
    code string
    name string
    age  int

​
var allMap map[string]PersonInfo_t
var cMap map[string]string
var hMap map[string]string
​
func findFromItem(item string) (ret PersonInfo_t) 
    id := item // default id
​
    if len(item) == 4  // hex
        id = hMap[item]
     else if len(item) == 6  // code
        id = cMap[item]
    
​
    if v, ok := allMap[id]; ok 
        fmt.Printf("found %v\\n", id)
        return v
    
​
    return PersonInfo_t

​
func showMap(allMap map[string]PersonInfo_t) 
    var keys []string
    for k, _ := range allMap 
        keys = append(keys, k)
    
    // 进行数组的排序
    sort.Strings(keys)
    // 遍历数组就是有序的了
    for _, k := range keys 
        fmt.Printf("v: %v\\n", allMap[k])
    

​
func multiMap() 
    allMap = make(map[string]PersonInfo_t)
    cMap = make(map[string]string)
    hMap = make(map[string]string)
    for i := 0; i < 10; i++ 
        var tmp PersonInfo_t
        tmp.id = fmt.Sprintf("id_%02d", i)
        tmp.code = fmt.Sprintf("C00%03d", i)
        tmp.hex = fmt.Sprintf("H%03d", i)
        tmp.name = fmt.Sprintf("foo_%d_bar", i)
        tmp.age = 20
        // 总的
        allMap[tmp.id] = tmp
​
        // 存储id的
        cMap[tmp.code] = tmp.id
        hMap[tmp.hex] = tmp.id
    
​
    //showMap(allMap)
​
    id := "id_00"
    fmt.Printf("%v: %v\\n", id, allMap[id])
​
    id = "id_100"
    fmt.Printf("%v: %v\\n", id, allMap[id])
​
    id = "H007"
    fmt.Printf("%v: %v\\n", id, findFromItem(id))
​
    id = "H017"
    fmt.Printf("%v: %v\\n", id, findFromItem(id))
​
    id = "C00005"
    fmt.Printf("%v: %v\\n", id, findFromItem(id))
​

输出结果：

id_00: id_00 H000 C00000 foo_0_bar 20
id_100:     0
found id_07
H007: id_07 H007 C00007 foo_7_bar 20
H017:     0
found id_05
C00005: id_05 H005 C00005 foo_5_bar 20
​

多 key 查询

需求：某种数据有很多个字段，由其中的两个字段共同决定查询的对象。接上一例子，假定必须有code代码和hex代码才能确认人员信息。在设计上，将这两个字段合并作为key即可。

代码如下：

var mMap map[string]PersonInfo_t
​
func findFromM(code, hex string) (ret PersonInfo_t) 
    key := fmt.Sprintf("%v_%v", code, hex)
​
    if v, ok := mMap[key]; ok 
        return v
    
​
    return PersonInfo_t

​
func mkMap() 
    mMap = make(map[string]PersonInfo_t)
    for i := 0; i < 10; i++ 
        var tmp PersonInfo_t
        tmp.id = fmt.Sprintf("id_%02d", i)
        tmp.code = fmt.Sprintf("C00%03d", i)
        tmp.hex = fmt.Sprintf("H%03d", i)
        tmp.name = fmt.Sprintf("foo_%d_bar", i)
        tmp.age = 20
        // 多个key
        key := fmt.Sprintf("%v_%v", tmp.code, tmp.hex)
        mMap[key] = tmp
    
​
    showMap(allMap)
​
    code := "C00000"
    hex := "H000"
    fmt.Printf("%v & %v: %v\\n", code, hex, findFromM(code, hex))
    code = "C00000"
    hex = "H111" // 不存在的
    fmt.Printf("%v & %v: %v\\n", code, hex, findFromM(code, hex))

输出结果：

C00000 & H000: id_00 C00000 H000 foo_0_bar 20
C00000 & H111:     0

小结

对于多 key 单独查询的场合，是典型的用空间换时间的思路，如果使用时间换空间，则可建立数组，遍历查询，查询条件即为不同的字段，数量在万级别以下，可能没有明显差别，但到百万级别，耗时就比较大了，因此，是否真正需要应用 map，还得自行评估。实际上，笔者2种方式都有使用到。