关于golang中map使用的几点注意事项总结(强烈推荐!)
作者：阿兵云原生
前言
日常的开发工作中，map 这个数据结构相信大家并不陌生，在 golang 里面，当然也有 map 这种类型
关于 map 的使用，还是有蛮多注意事项的，如果不清楚，这些事项，关键时候可能会踩坑，我们一起来演练一下吧
1 使用 map 记得初始化
写一个 demo
- 定义一个 map[int]int 类型的变量 myMap ， 不做初始化
- 我们可以读取 myMap 的值，默认为 零值
- 但是我们往没有初始化的 myMap 中写入值，程序就会 panic ，这里切记不要踩坑
func main(){
var myMap map[int]int
fmt.Println("myMap[1] == ",myMap[1])
}
程序运行效果：
# go run main.go
myMap[1] == 0
代码中加入写操作：
func main(){
var myMap map[int]int
fmt.Println("myMap[1] == ",myMap[1])
myMap[1] = 10
fmt.Println("myMap[1] == ",myMap[1])
}
程序运行效果：
# go run main.go
myMap[1] == 0
panic: assignment to entry in nil mapgoroutine 1 [running]:
main.main()
/home/admin/golang_study/later_learning/map_test/main.go:20 +0xf3
exit status 2
程序果然报 panic 了，我们实际工作中需要万分小心，对代码要有敬畏之心
2 map 的遍历是无序的
定义一个 map[int]int 类型的 map，并初始化 5 个数
func main() {
myMap := map[int]int{
1: 1,
2: 2,
3: 3,
4: 4,
5: 5}
for k := range myMap {
fmt.Println(myMap[k])
}
}
程序运行效果：
# go run main.go
1
2
3
4
5
# go run main.go
5
1
2
3
4
# go run main.go
3
4
5
1
2
运行上述代码 3 次，3 次结果都不一样，当然，也有可能 3 次结果的顺序都是一样的
因为 GO 中的 map 是基于哈希表实现的，所以遍历的时候是无序的
若我们需要清空这个 map ，那么我们可以直接将对应的 map 变量置为 nil 即可，例如
myMap = nil
3 map 也可以是二维的
map 也是可以像数组一样是二维的，甚至是多维的都可以，主要是看我们的需求了
可是我们要注意，只是定义的时候类似二维数组，但是具体使用的时候还是有区别的
我们可以这样来操作二维数组
func main() {
myMap := map[int]map[string]string{}
myMap[0] = map[string]string{
"name":"xiaomotong",
"hobby":"program",
}
fmt.Println(myMap)
}
程序运行效果：
# go run main.go
map[0:map[name:xiaomotong hobby:program]]
我们不可以这样来操作二维数组
func main() {
myMap := map[int]map[string]string{}
myMap[0]["name"] = "xiaomotong"
myMap[0]["hobby"] = "program"
fmt.Println(myMap)
}
程序运行效果：
# go run main.go
panic: assignment to entry in nil mapgoroutine 1 [running]:
main.main()
/home/admin/golang_study/later_learning/map_test/main.go:17 +0x7f
exit status 2
原因很简单，程序报的 panic 日志已经说明了原因
是因为 myMap[0] 键 是 0 没问题，但是 值是 map[string]string 类型的，需要初始化才可以做写操作，这也是我们文章第一点所说到的
要是还是想按照上面这种写法来，那也很简单，加一句初始化就好了
func main() {
myMap := map[int]map[string]string{}
myMap[0] = map[string]string{}
myMap[0]["name"] = "xiaomotong"
myMap[0]["hobby"] = "program"
fmt.Println(myMap)
}
4 获取 map 的 key 最好使用这种方式
工作中，我们会存在需要获取一个 map 的所有 key 的方式，这个时候，我们一般是如何获取的呢，接触过反射的 xdm 肯定会说，这很简单呀，用反射一句话就搞定的事情，例如：
func main() {
myMap := map[int]int{
1: 1,
2: 2,
3: 3,
4: 4,
5: 5}
myKey := reflect.ValueOf(myMap).MapKeys()
for v :=range myKey{
fmt.Println(v)
}
}
运行程序go run main.go，结果如下：
可是我们都知道，golang 中的 反射 reflect 确实写起来很简洁，但是效率真的非常低，我们平时使用最好还是使用下面这种方式
func main() {
myMap := map[int]int{
1: 1,
2: 2,
3: 3,
4: 4,
5: 5}
myKey := make([]int,0,len(myMap))
for k :=range myMap{
myKey = append(myKey,myMap[k])
}
fmt.Println(myKey)
}
这种编码方式，提前已经设置好 myKey 切片的容量和 map 的长度一致，则后续向 myKey 追加 key 的时候，就不会出现需要切片扩容的情况
程序运行效果：
# go run main.go
[2 3 4 5 1]
我们可以看到，拿出来的 key ，也不是有序的
5 map 是并发不安全的 ，sync.Map 才是安全的
最后咱们再来模拟一下和验证一下 golang 的 map 不是安全
模拟 map 不安全的 demo， 需要多开一些协程才能模拟到效果，实验了一下，我这边模拟开 5 万 个协程
type T struct {
myMap map[int]int
}
func (t *T) getValue(key int) int {
return t.myMap[key]
}
func (t *T) setValue(key int, value int) {
t.myMap[key] = value
}
func main() {
ty := T{myMap: map[int]int{}}
wg := sync.WaitGroup{}
wg.Add(50000)
for i := 0; i < 50000; i++ {
go func(i int) {
ty.setValue(i, i)
fmt.Printf("get key == %d, value == %d \n", i, ty.getValue(i))
wg.Done()
}(i)
}
wg.Wait()
fmt.Println("program over !!")
}
运行程序变会报错如下信息：
# go run main.go
fatal error: concurrent map writes
...
如果硬是要使用 map 的话， 也可以加上一把互斥锁就可以解决了
咱们只用修改上述的代码，结构体定义的位置，和 设置值的函数
type T struct {
myMap map[int]int
lock sync.RWMutex
}
func (t *T) setValue(key int, value int) {
t.lock.Lock()
defer t.lock.Unlock()
t.myMap[key] = value
}
为了检查方便，我们把程序输出的值打印到一个文件里面 go run main.go >> map.log
程序运行后，可以看到，真实打印的 key 对应数据，确实是有 5000 行，没毛病
通过以上例子，就可以明白 golang 中的 map，确实不是并发安全的，需要加锁，才能做到并发安全
golang 也给我们提供了并发安全的 map ，sync.Map
sync.Map 的实现机制，简单来说，是他自身自带锁，因此可以控制并发安全
好了，今天就到这里，语言是好语言，工具也是好工具，我们需要实际用起来才能发挥他们的价值，不用的话一切都是白瞎
总结
到此这篇关于关于golang中map使用的几点注意事项的文章就介绍到这了,更多相关golang map使用注意事项内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！