9.7 Go语言入门(映射 Map)

目录

Go 语言（Golang）是一种静态类型、编译型语言，由 Google 开发，专注于简洁性、并发和高效性。

下面是 Go 语言的基础语法讲解和代码示例。

---

上一篇：五、Go语言入门（数组、切片和指针）

---

六、映射 Map

在 Go 语言中，映射（Map）是一种内置的数据结构，它是一种键值对的集合，提供了高效的键值对查找、插入和删除操作。下面详细讲解 Go 语言中的映射，包括它的声明、初始化、基本操作以及一些高级用法，并提供代码示例。

1. 声明和初始化映射

映射的声明和初始化有多种方式，主要通过 make 函数和映射字面量进行。

1.1 使用 make 函数

make 函数是创建映射的常用方法。它的语法如下：

go make(map[KeyType]ValueType, [capacity])

package main

import "fmt"

func main() {
    // 声明并初始化一个空的映射
    m1 := make(map[string]int)
    fmt.Println(m1) // 输出：map[]

    // 声明并初始化一个具有初始容量的映射
    m2 := make(map[string]int, 10)
    fmt.Println(m2) // 输出：map[]
}

1.2 使用映射字面量

映射字面量允许在声明映射时直接初始化其内容。

package main

import "fmt"

func main() {
    // 使用映射字面量初始化映射
    m := map[string]int{
        "Alice": 25,
        "Bob":   30,
        "Carol": 35,
    }
    fmt.Println(m) // 输出：map[Alice:25 Bob:30 Carol:35]
}

2. 映射的基本操作

2.1 插入和更新元素

通过指定键，可以在映射中插入或更新元素。

package main

import "fmt"

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

    // 插入元素
    m["Alice"] = 25
    m["Bob"] = 30

    // 更新元素
    m["Alice"] = 26

    fmt.Println(m) // 输出：map[Alice:26 Bob:30]
}

2.2 访问元素

通过键可以访问映射中的元素。如果键不存在，会返回值类型的零值。

package main

import "fmt"

func main() {
    m := map[string]int{
        "Alice": 25,
        "Bob":   30,
    }

    // 访问存在的键
    age := m["Alice"]
    fmt.Println("Alice's age:", age) // 输出：Alice's age: 25

    // 访问不存在的键
    age = m["Carol"]
    fmt.Println("Carol's age:", age) // 输出：Carol's age: 0
}

2.3 检查键是否存在

可以使用双重赋值语法来检查键是否存在。

package main

import "fmt"

func main() {
    m := map[string]int{
        "Alice": 25,
        "Bob":   30,
    }

    // 检查键是否存在
    age, exists := m["Alice"]
    if exists {
        fmt.Println("Alice's age:", age) // 输出：Alice's age: 25
    } else {
        fmt.Println("Alice does not exist")
    }

    age, exists = m["Carol"]
    if exists {
        fmt.Println("Carol's age:", age)
    } else {
        fmt.Println("Carol does not exist") // 输出：Carol does not exist
    }
}

2.4 删除元素

使用 delete 函数可以删除映射中的元素。

package main

import "fmt"

func main() {
    m := map[string]int{
        "Alice": 25,
        "Bob":   30,
    }

    // 删除元素
    delete(m, "Alice")
    fmt.Println(m) // 输出：map[Bob:30]

    // 尝试删除不存在的键，不会引发错误
    delete(m, "Carol")
    fmt.Println(m) // 输出：map[Bob:30]
}

2.5 获取映射的长度

使用 len 函数可以获取映射中的键值对数量。

package main

import "fmt"

func main() {
    m := map[string]int{
        "Alice": 25,
        "Bob":   30,
    }

    fmt.Println("Length of map:", len(m)) // 输出：Length of map: 2
}

3. 遍历映射

使用 for 循环和 range 关键字可以遍历映射中的所有键值对。

package main

import "fmt"

func main() {
    m := map[string]int{
        "Alice": 25,
        "Bob":   30,
        "Carol": 35,
    }

    // 遍历映射
    for key, value := range m {
        fmt.Println(key, "is", value, "years old")
    }
}

4. 映射的注意事项

4.1 映射的零值

映射的零值是 nil，不能直接对其进行读写操作。必须使用 make 或映射字面量进行初始化。

package main

import "fmt"

func main() {
    var m map[string]int
    // m["Alice"] = 25 // 会导致运行时错误

    if m == nil {
        fmt.Println("The map is nil")
    }
}

4.2 映射是引用类型

映射是引用类型，在函数传递时会传递引用，而不是副本。

package main

import "fmt"

func updateMap(m map[string]int) {
    m["Alice"] = 26
}

func main() {
    m := map[string]int{
        "Alice": 25,
    }

    fmt.Println("Before:", m) // 输出：Before: map[Alice:25]

    updateMap(m)

    fmt.Println("After:", m) // 输出：After: map[Alice:26]
}

4.3 并发安全

映射在并发读写时不是线程安全的。若需要并发读写映射，可以使用 sync.Map 或者加锁机制。

package main

import (
    "fmt"
    "sync"
)

func main() {
    var m sync.Map

    // 存储值
    m.Store("Alice", 25)
    m.Store("Bob", 30)

    // 加载值
    age, ok := m.Load("Alice")
    if ok {
        fmt.Println("Alice's age:", age)
    }

    // 删除值
    m.Delete("Alice")

    // 遍历映射
    m.Range(func(key, value interface{}) bool {
        fmt.Println(key, "is", value)
        return true
    })
}

通过理解映射的这些基本和高级操作，可以在 Go 语言编程中高效地使用映射来处理键值对数据。映射在许多实际应用中非常常用，例如存储配置、缓存数据、索引查找等。