乐趣区

关于go:需要提醒你关于-golang-中-map-使用的几点注意事项

jiezi

日常的开发工作中，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 map

goroutine 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 map

goroutine 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 的实现机制，简略来说，是他本身自带锁，因而能够管制并发平安

好了，明天就到这里，语言是好语言，工具也是好工具，咱们须要理论用起来能力施展他们的价值，不必的话一切都是白瞎

欢送点赞，关注，珍藏

敌人们，你的反对和激励，是我保持分享，提高质量的能源

好了，本次就到这里

技术是凋谢的，咱们的心态，更应是凋谢的。拥抱变动，背阴而生，致力向前行。

我是 阿兵云原生，欢送点赞关注珍藏，下次见~

退出移动版