Map is a reference type which points to a hash table, and you can use it to construct a “key-value” database which is very handy in practice programming. E.g., the following code will calculate the count of every element in a slice:
package main
import (
"fmt"
)
func main() {
s := []int{1, 1, 2, 2, 3, 3, 3}
m := make(map[int]int)
for _, v := range s {
m[v]++
}
for key, value := range m {
fmt.Printf("%d occurs %d times\n", key, value)
}
}
The output is like this:
3 occurs 3 times
1 occurs 2 times
2 occurs 2 times
Moreover, according to Go spec: “A map is an unordered group of elements of one type, called the element type, indexed by a set of unique keys of another type, called the key type.”. So if you run the above program another time, the output may be different:
2 occurs 2 times
3 occurs 3 times
1 occurs 2 times
You must not presume the element order of a map.
The key type of the map must can be compared with “==” operator: the built-in types, such as int, string, etc, satisfy this requirement; while slice not. For struct type, if its members all can be compared by “==” operator, then this struct can also be used as key.
When you access a non-exist key of the map, the map will return the nil value of the element. I.e.:
package main
import (
"fmt"
)
func main() {
m := make(map[int]bool)
m[0] = false
m[1] = true
fmt.Println(m[0], m[1], m[2])
}
The output is:
false true false
the value of m[0] and m[2] are both false, so you can’t discriminate whether the key is really in map or not. The solution is to use “comma ok” method:
value, ok := map[key]
if the key does exit, ok will be true; else ok will be false.
Sometimes, you may not care the values of the map, and use map just as a set. In this case, you can declare the value type as an empty struct: struct{}. An example is like this:
package main
import (
"fmt"
)
func check(m map[int]struct{}, k int) {
if _, ok := m[k]; ok {
fmt.Printf("%d is a valid key\n", k)
}
}
func main() {
m := make(map[int]struct{})
m[0] = struct{}{}
m[1] = struct{}{}
for i := 0; i <=2; i++ {
check(m, i)
}
}
The output is:
0 is a valid key
1 is a valid key
Using built-in delete function, you can remove an entry in the map, even the key doesn’t exist:
delete(map, key)
References:
Effective Go;
The Go Programming Language Specification;
The Go Programming Language.
https://github.com/NanXiao/golang-101-hacks