Golangmap定义与常用操作实例

nil map是未初始化的map，不能写入但读取安全；空map用make初始化，可读写。需写入时应使用空map，仅判断存在性可用nil map。

Golang中的

map

Golang的

map

map

Golang Map的定义与基本操作实例

我们来具体看看

map

1. 定义与初始化

立即学习“go语言免费学习笔记（深入）”；

创建一个

map

make

// 定义一个键为string，值为int的map
var m1 map[string]int

// 使用make初始化，此时m1不再是nil，但容量为0
m1 = make(map[string]int)

// 也可以在声明时直接初始化
m2 := make(map[string]string)

// 或者，如果你知道初始元素，可以直接使用字面量方式
m3 := map[string]bool{
    "active": true,
    "admin":  false,
}

// 还可以指定初始容量，这有助于减少后续的内存重新分配，提高性能
// 但Go运行时会根据实际需要动态调整容量，所以这只是一个建议值
m4 := make(map[int]string, 10)

需要注意的是，一个未经

make

map

nil

nil

map

2. 赋值与更新

给

map

m1["apple"] = 1
m1["banana"] = 2
fmt.Println("m1:", m1) // 输出: m1: map[apple:1 banana:2]

m1["apple"] = 3 // 更新"apple"的值
fmt.Println("m1 (updated):", m1) // 输出: m1 (updated): map[apple:3 banana:2]

3. 获取值

从

map

value, ok := m1["apple"]
if ok {
    fmt.Printf("Key 'apple' exists, value is %d\n", value) // 输出: Key 'apple' exists, value is 3
} else {
    fmt.Println("Key 'apple' does not exist")
}

// 如果键不存在，直接访问会得到值的零值
valueOnly := m1["orange"]
fmt.Printf("Value for 'orange' (if not exists): %d\n", valueOnly) // 输出: Value for 'orange' (if not exists): 0

ok

4. 删除元素

使用内置的

delete

map

delete(m1, "banana")
fmt.Println("m1 (after delete):", m1) // 输出: m1 (after delete): map[apple:3]

// 删除不存在的键不会报错，也不会有任何操作
delete(m1, "grape")
fmt.Println("m1 (delete non-existent):", m1) // 输出: m1 (delete non-existent): map[apple:3]

5. 遍历

map

map

for...range

map

for key, value := range m1 {
    fmt.Printf("Key: %s, Value: %d\n", key, value)
}

// 如果你只关心键或只关心值，可以省略另一个
for key := range m1 {
    fmt.Printf("Only Key: %s\n", key)
}

6. 获取

map

使用

len

map

fmt.Printf("Length of m1: %d\n", len(m1)) // 输出: Length of m1: 1

这些就是

map

Golang Map的底层实现机制是怎样的？它与Slice有何区别？

深入理解

map

map

当你创建一个

map

hmap

bmap

map

它与Slice有何区别？

map

slice

1. 有序性：

   • slice

     登录后复制
     ：是有序的，元素通过索引（0到

     len-1

     登录后复制
     ）访问，顺序是固定的。

   • map

     登录后复制
     ：是无序的，元素通过键访问，遍历顺序不确定，每次可能都不同。这反映了其哈希表的本质。

2. 访问方式：

   • slice

     登录后复制
     ：通过整数索引访问元素，例如

     s[0]

     登录后复制
     。

   • map

     登录后复制
     ：通过键（可以是任意可比较类型，如

     string

     登录后复制
     ,

     int

     登录后复制
     ,

     struct

     登录后复制
     等）访问元素，例如

     m["key"]

     登录后复制
     。

3. 内存布局：

   • slice

     登录后复制
     ：在内存中是连续存储的，这使得基于索引的访问非常高效。

   • map

     登录后复制
     ：元素在内存中是分散存储的，通过哈希函数和指针链接，查找效率依赖于哈希函数的质量和冲突解决机制。

4. 零值：

   

   通义万相

   通义万相，一个不断进化的AI艺术创作大模型

   596

   查看详情

   • slice

     登录后复制
     ：零值是

     nil

     登录后复制
     ，

     len

     登录后复制
     和

     cap

     登录后复制
     都是0。

   • map

     登录后复制
     ：零值也是

     nil

     登录后复制
     ，

     len

     登录后复制
     是0。对

     nil

     登录后复制
     的

     map

     登录后复制
     进行读操作是安全的，但写操作会导致panic。

5. 扩容机制：

   • slice

     登录后复制
     ：当容量不足时，会创建一个新的更大底层数组，并将旧元素拷贝过去。

   • map

     登录后复制
     ：当负载因子过高时，会进行扩容，重新计算所有键的哈希值并分布到新的桶中。

6. 用途：

   • slice

     登录后复制
     ：适用于需要顺序访问、列表、栈、队列等场景。

   • map

     登录后复制
     ：适用于需要快速查找、存储配置、计数、关联数据等场景。

我个人在使用时，经常会根据数据是否需要“顺序”来决定使用

slice

map

slice

map

在并发场景下，如何安全地操作Golang Map？有哪些常见的陷阱和解决方案？

map

map

常见的陷阱：

1. 直接并发读写：最直接的错误就是不加任何保护地在多个goroutine中同时修改或读取

   map

   登录后复制
   。

   // 示例：会引发panic
   // var m = make(map[string]int)
   // go func() {
   //     for i := 0; i < 1000; i++ {
   //         m[fmt.Sprintf("key%d", i)] = i
   //     }
   // }()
   // go func() {
   //     for i := 0; i < 1000; i++ {
   //         _ = m[fmt.Sprintf("key%d", i)]
   //     }
   // }()
   // time.Sleep(time.Second) // 等待goroutine执行

   登录后复制

   Go运行时会检测到这种并发不安全的操作，并通常会报告一个

   fatal error: concurrent map writes

   登录后复制
   或

   concurrent map reads and writes

   登录后复制
   。

解决方案：

针对并发操作

map

1. 使用

   sync.Mutex

   登录后复制
   进行锁定

   这是最直接、最通用的方法。通过互斥锁（

   Mutex

   登录后复制
   ）来确保在任何给定时间只有一个goroutine可以访问

   map

   登录后复制
   。

   import (
       "fmt"
       "sync"
       "time"
   )
   
   type SafeMap struct {
       mu    sync.Mutex
       data map[string]int
   }
   
   func NewSafeMap() *SafeMap {
       return &SafeMap{
           data: make(map[string]int),
       }
   }
   
   func (sm *SafeMap) Set(key string, value int) {
       sm.mu.Lock()
       defer sm.mu.Unlock()
       sm.data[key] = value
   }
   
   func (sm *SafeMap) Get(key string) (int, bool) {
       sm.mu.Lock()
       defer sm.mu.Unlock()
       val, ok := sm.data[key]
       return val, ok
   }
   
   // func main() {
   //     safeM := NewSafeMap()
   //     var wg sync.WaitGroup
   //
   //     for i := 0; i < 100; i++ {
   //         wg.Add(1)
   //         go func(i int) {
   //             defer wg.Done()
   //             safeM.Set(fmt.Sprintf("key%d", i), i)
   //         }(i)
   //     }
   //
   //     for i := 0; i < 50; i++ {
   //         wg.Add(1)
   //         go func(i int) {
   //             defer wg.Done()
   //             val, ok := safeM.Get(fmt.Sprintf("key%d", i))
   //             if ok {
   //                 // fmt.Printf("Read key%d: %d\n", i, val)
   //             }
   //         }(i)
   //     }
   //
   //     wg.Wait()
   //     fmt.Println("SafeMap operations completed.")
   // }

   登录后复制

   优点：简单易懂，适用于所有并发场景。 缺点：读操作也会阻塞写操作，写操作也会阻塞读操作，如果读多写少，性能可能会受影响。

2. 使用

   sync.RWMutex

   登录后复制
   进行读写锁

   RWMutex

   登录后复制
   是

   Mutex

   登录后复制
   的升级版，它允许多个goroutine同时进行读操作，但写操作仍然是排他的。当有写操作时，所有读写操作都会被阻塞。这在读多写少的场景下能显著提升性能。

   type RWSafeMap struct {
       mu    sync.RWMutex
       data map[string]int
   }
   
   func NewRWSafeMap() *RWSafeMap {
       return &RWSafeMap{
           data: make(map[string]int),
       }
   }
   
   func (rsm *RWSafeMap) Set(key string, value int) {
       rsm.mu.Lock() // 写锁
       defer rsm.mu.Unlock()
       rsm.data[key] = value
   }
   
   func (rsm *RWSafeMap) Get(key string) (int, bool) {
       rsm.mu.RLock() // 读锁
       defer rsm.mu.RUnlock()
       val, ok := rsm.data[key]
       return val, ok
   }
   // 使用方式与SafeMap类似，只是内部锁类型不同

   登录后复制

   优点：在读多写少的场景下，性能优于

   sync.Mutex

   登录后复制
   。 缺点：相比

   sync.Mutex

   登录后复制
   略复杂，需要区分读锁和写锁。

3. 使用

   sync.Map

   登录后复制
   (Go 1.9+)

   sync.Map

   登录后复制
   是Go 1.9版本引入的并发安全

   map

   登录后复制
   ，它专门为并发场景设计，在某些特定场景下（例如，键是稳定增长的，且不经常删除），性能优于

   RWMutex

   登录后复制
   。它的内部实现非常巧妙，包含一个只读部分（

   read

   登录后复制
   ）和一个可写部分（

   dirty

   登录后复制
   ），通过“copy-on-write”策略来优化并发读写。

   import "sync"
   
   // func main() {
   //     var m sync.Map
   //     var wg sync.WaitGroup
   //
   //     for i := 0; i < 100; i++ {
   //         wg.Add(1)
   //         go func(i int) {
   //             defer wg.Done()
   //             m.Store(fmt.Sprintf("key%d", i), i) // 存储键值对
   //         }(i)
   //     }
   //
   //     for i := 0; i < 50; i++ {
   //         wg.Add(1)
   //         go func(i int) {
   //             defer wg.Done()
   //             if val, ok := m.Load(fmt.Sprintf("key%d", i)); ok { // 获取值
   //                 // fmt.Printf("Read sync.Map key%d: %d\n", i, val)
   //             }
   //         }(i)
   //     }
   //
   //     wg.Wait()
   //     fmt.Println("sync.Map operations completed.")
   //
   //     // 遍历sync.Map
   //     m.Range(func(key, value interface{}) bool {
   //         // fmt.Printf("Key: %v, Value: %v\n", key, value)
   //         return true // 返回true继续遍历，返回false停止遍历
   //     })
   // }

   登录后复制

   sync.Map

   登录后复制
   的API：

   • Store(key, value interface{})

     登录后复制
     ：存储键值对。

   • Load(key interface{}) (value interface{}, ok bool)

     登录后复制
     ：获取值。

   • LoadOrStore(key, value interface{}) (actual interface{}, loaded bool)

     登录后复制
     ：如果键存在则加载，否则存储。

   • Delete(key interface{})

     登录后复制
     ：删除键。

   • Range(f func(key, value interface{}) bool)

     登录后复制
     ：遍历

     map

     登录后复制
     。

   优点：在特定场景下（高并发读，少量写，键不经常删除）性能极佳，通常优于

   RWMutex

   登录后复制
   。API设计更简洁。 缺点：不适用于所有场景，例如，如果键的更新或删除非常频繁，

   sync.Map

   登录后复制
   的性能可能不如

   RWMutex

   登录后复制
   。并且，键和值必须是

   interface{}

   登录后复制
   类型，这意味着需要类型断言，可能带来一些运行时开销和不便。

选择哪种方案取决于你的具体需求和性能瓶颈。对于我来说，如果只是简单的并发保护，

sync.Mutex

sync.RWMutex

sync.Map

interface{}

Golang Map的零值（nil map）与空Map有什么不同？何时应该使用它们？

这又是一个Go语言里常常让人感到困惑，但一旦理解就豁然开朗的细节。

nil map

map

1.

nil map

当一个

map

make

nil

var nilMap map[string]int
fmt.Println("nilMap:", nilMap)         // 输出: nilMap: map[]
fmt.Println("Is nilMap nil?", nilMap == nil) // 输出: Is nilMap nil? true
fmt.Println("Length of nilMap:", len(nilMap)) // 输出: Length of nilMap: 0

nil map

• 不能写入：尝试向

  nil map

  登录后复制
  中添加元素会引发运行时panic。

  // nilMap["key"] = 1 // 这行代码会引发 panic: assignment to entry in nil map

  登录后复制
• 可以读取：从

  nil map

  登录后复制
  中读取元素是安全的，会返回该值类型的零值。

  val, ok := nilMap["nonexistent"]
  fmt.Printf("Read from nilMap: val=%d, ok=%t\n", val, ok) // 输出: Read from nilMap: val=0, ok=false

  登录后复制
• 长度为0：

  len(nilMap)

  登录后复制
  返回0。
• 可以迭代：

  for...range

  登录后复制
  循环

  nil map

  登录后复制
  不会有任何操作，也不会panic。

2. 空Map

一个空

map

make

map

emptyMap := make(map[string]int)
fmt.Println("emptyMap:", emptyMap)         // 输出: emptyMap: map[]
fmt.Println("Is emptyMap nil?", emptyMap == nil) // 输出: Is emptyMap nil? false
fmt.Println("Length of emptyMap:", len(emptyMap)) // 输出: Length of emptyMap: 0

空

map

• 可以写入：可以正常添加、修改元素。

  emptyMap["key"] = 1
  fmt.Println("emptyMap after write:", emptyMap) // 输出: emptyMap after write: map[key:1]

  登录后复制
• 可以读取：和普通

  map

  登录后复制
  一样，可以安全读取。
• 长度为0（初始）：

  len(emptyMap)

  登录后复制
  返回0，但随着元素添加会改变。
• 可以迭代：

  for...range

  登录后复制
  循环空

  map

  登录后复制
  不会有任何操作。

何时应该使用它们？

理解这两者的区别

以上就是Golangmap定义与常用操作实例的详细内容，更多请关注php中文网其它相关文章！