从浅入深带你掌握Golang数据结构map

什么是map

map是Golang中非常常用的一种数据结构，类似于其他语言中的哈希表。map是一种无序的键值对数据结构，通过key来快速定位和访问对应的value。map的key可以是任何可比较类型（如int，float等），value可以是任何类型。

map的基本操作

创建map

创建map的方式如下所示：

var m map[key_type]value_type

或

m := make(map[key_type]value_type)

例如：

m := make(map[string]int)

上面的代码创建了一个空的map，key类型为string，value类型为int。

添加元素

向map中添加元素的方式如下所示：

m[key] = value

例如：

m["foo"] = 1

上面的代码向map m中添加了一个key为"foo"，value为1的元素。

删除元素

从map中删除元素的方式如下所示：

delete(m, key)

例如：

delete(m, "foo")

上面的代码从map m中删除了key为"foo"的元素。

查找元素

从map中查找元素的方式如下所示：

value, ok := m[key]

例如：

value, ok := m["foo"]

上面的代码从map m中查找key为"foo"的元素，并将其value值赋值给变量value。如果查找成功，ok的值将为true，否则为false。

遍历map

遍历map的方式如下所示：

for key, value := range m {
    // do something with key and value
}

例如：

for k, v := range m {
    fmt.Printf("%s -> %d\n", k, v)
}

上面的代码遍历了map m，并将每个元素的key和value输出。

map的高级操作

map的长度

map的长度可以通过len函数获取，例如：

l := len(m)

嵌套map

map可以嵌套使用，例如：

m := map[string]map[string]int{
    "foo": map[string]int{"bar": 1},
    "baz": map[string]int{"qux": 2},
}

上面的代码创建了一个嵌套map，其中第一层的key为"foo"和"baz"，第二层的key分别为"bar"和"qux"，value为int类型的数字。

map作为参数传递

map可以作为函数的参数传递，例如：

func someFunc(m map[string]int) {
    // do something with m
}

map的零值

map的零值为nil，表示未初始化。对于未初始化的map，不能直接添加元素，需要通过make函数进行初始化，例如：

var m map[string]int
m = make(map[string]int)

示例说明

示例1：统计字符串中字符出现的次数

func CountChars(s string) map[rune]int {
    m := make(map[rune]int)
    for _, c := range s {
        _, ok := m[c]
        if !ok {
            m[c] = 1
        } else {
            m[c]++
        }
    }
    return m
}

func main() {
    s := "hello world"
    m := CountChars(s)
    for k, v := range m {
        fmt.Printf("%c -> %d\n", k, v)
    }
}

上面的代码统计了字符串s中字符出现的次数，并输出了每个字符和其出现次数。

示例2：开闭合检查器

func CheckOpenClose(s string) bool {
    stack := make([]rune, 0)
    m := map[rune]rune{
        '}': '{',
        ']': '[',
        ')': '(',
    }
    for _, c := range s {
        if _, ok := m[c]; ok {
            if len(stack) == 0 || stack[len(stack)-1] != m[c] {
                return false
            } else {
                stack = stack[:len(stack)-1]
            }
        } else if c == '{' || c == '[' || c == '(' {
            stack = append(stack, c)
        }
    }
    return len(stack) == 0
}

func main() {
    s := "{a[b(c)]d}e"
    fmt.Println(CheckOpenClose(s)) // true
    s1 := "{a[b(c]d}e"
    fmt.Println(CheckOpenClose(s1)) // false
}

上面的代码检查了一个字符串中的符号是否开闭合匹配，如果匹配，则返回true，否则返回false。