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

·  阅读 60

持续创作,加速成长!这是我参与「掘金日新计划 · 6 月更文挑战」的第17天,点击查看活动详情

本文针对 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]stringfunc 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种方式都有使用到。

分类:
后端
标签:
收藏成功!
已添加到「」, 点击更改