[Golang (Go) Tutorial] Maps

Posted on Edited on In , , Views: Word count in article: 2.6k Reading time ≈ 2 mins.

Maps

Go provides another important data type named map which maps unique keys to values. A key is an object that you use to retrieve a value at a later date. Given a key and a value, you can store the value in a Map object. After the value is stored, you can retrieve it by using its key.

Create a map

1
2
3
4
5
6
7
8
9
10
var m map[string]int                // nil map of string-int pairs

m1 := make(map[string]float64)      // Empty map of string-float64 pairs
m2 := make(map[string]float64, 100) // Preallocate room for 100 entries

m3 := map[string]float64{           // Map literal
    "e":  2.71828,
    "pi": 3.1416,
}
fmt.Println(len(m3))                // Size of map: 2

  • A map (or dictionary) is an unordered collection of key-value pairs, where each key is unique.

  • You create a new map with a make statement or a map literal.

  • The default zero value of a map is nil. A nil map is equivalent to an empty map except that elements can’t be added.

  • The len function returns the size of a map, which is the number of key-value pairs.

Warning: If you try to add an element to an uninitialized map you get the mysterious run-time error Assignment to entry in nil map.

Set, Get, Delete, Length keys/values,

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
m := make(map[string]float64)

m["pi"] = 3.14             // Set a new key-value pair
m["pi"] = 3.1416           // Update value
fmt.Println(m)             // Print map: "map[pi:3.1416]"

v := m["pi"]               // Get value: v == 3.1416
v = m["pie"]               // Not found: v == 0 (zero value)

_, found := m["pi"]        // found == true
_, found = m["pie"]        // found == false

if x, found := m["pi"]; found {
    fmt.Println(x)
}                           // Prints "3.1416"

delete(m, "pi")             // Delete a key-value pair
fmt.Println(m)              // Print map: "map[]"

When you index a map you get two return values; the second one (which is optional) is a boolean that indicates if the key exists.

If the key doesn’t exist, the first value will be the default zero value.

For-each range loop

1
2
3
4
5
6
7
8
9
m := map[string]float64{
    "pi": 3.1416,
    "e":  2.71828,
}
fmt.Println(m) // "map[e:2.71828 pi:3.1416]"

for key, value := range m { // Order not specified 
    fmt.Println(key, value)
}

Iteration order is not specified and may vary from iteration to iteration.

  • If an entry that has not yet been reached is removed during iteration, the corresponding iteration value will not be produced.

  • If an entry is created during iteration, that entry may or may not be produced during the iteration.

Starting with Go 1.12, the fmt package prints maps in key-sorted order to ease testing.

Performance and implementation

Maps are backed by hash tables.

Set, get and delete operations run in constant expected time. The time complexity for the add operation is amortized.

The comparison operators == and != must be defined for the key type.

References

Maps explained: create, add, get, delete · YourBasic Go - https://yourbasic.org/golang/maps-explained/

Go - Maps - Tutorialspoint - https://www.tutorialspoint.com/go/go_maps.htm

Go map - working with maps in Golang - https://zetcode.com/golang/map/