23. Maps

Search…
23. Maps
Let's navigate!
Map Type
Map is collection of key value pairs. It goes by various names in other programming languages like dictionaries in Python, objects in JavaScript etc.
Maps are represented as  map[K]V, where K and V are the types of its keys and values.
Declaring Maps
We can declare map using var declaration. We are defining string to be keys for the map and string to be values. Since map is declared but not initialized with any value, it will be a nil map. 
main.go
1
var capitals map[string]string
2
fmt.Println(capitals)
3
fmt.Println("is map nil ==>", capitals == nil)
Copied!
Creating map
Maps are created using make function call. make will perform the required memory allocation required to use map. We can add elements to map using map[key] = value semantics. 
main.go
1
caps := make(map[string]string)
2
// we can also use var keyword as below
3
// var caps map[string]string = make(map[string]string)
4
fmt.Println(caps)
5
fmt.Println("is map nil ==>", caps == nil) 
6
// returns false
7
caps["India"] = "Delhi"
8
caps["England"] = "London"
9
caps["U.S."] = "Washington"
10
fmt.Println(caps)
Copied!
Map Literals
We can also use map literal to declare and initialize maps. make function call is not required when using map literal.
main.go
1

capitalsOfCountries := map[string]string{
2
    "India":   "Delhi",
3
    "England": "London",
4
    "U.S.":    "Washington",
5
}
6
fmt.Println(capitalsOfCountries)
Copied!
Accessing map elements
map elements can be accessed using subscript notion similar to array and slices. In array and slices, index can only be integers. For maps, however, key can be anything which can be compared using == comparison.
main.go
1

//accessing map elements
2
fmt.Println(capitalsOfCountries["India"])
3
fmt.Println(capitalsOfCountries["England"])
Copied!
If we try to access map key which does not exists, it will not cause an error, but will return zero value.
main.go
1

fmt.Println(capitalsOfCountries["XYZ"]) 
2
// prints empty string
Copied!
Zero values for map
Zero value for map is nil. Zero value for map element is zero value for type being stored as value.
main.go
1

var s map[string]string
2
var i map[string]int
3
fmt.Println("is s nil =>", s == nil)
4
fmt.Println("is i nil =>", i == nil)
Copied!
If map is not nil, but empty, accessing its elements will returns its zero value.
main.go
1

// zero value for map elements
2
j := map[string]int{}
3
fmt.Println(j["India"]) // output : 0
4
​
Copied!
Notice that, event if key does to exist in empty map, it did return zero value.
Nil and empty map
Similar to slices, maps can be empty or nil. When we use make function call or use map literal for declaring map, it initializes empty map
main.go
1

var t = make(map[string]string)
2
k := map[string]int{}
3
fmt.Println("is t nil =>", t== nil)
4
fmt.Println("is k nil =>", k== nil)
Copied!
Both nil and empty maps have len() as zero.
main.go
1
var s map[string]string
2
var t = make(map[string]string)
3
fmt.Println(len(s))
4
fmt.Println(len(t))
Copied!
Iterating over map
Iterating over maps is similar to array and slices, we can use for...range loop for iteration. range works as follows for a map
for key,value :=range map { // }
main.go
1
for key, value := range caps {
2
	fmt.Printf("key =>%v, value => %v\n", key, value)
3
}
Copied!
Unlike arrays and slices, maps do not guarantee same order. Map is unordered collection of key-value pairs.
If either key or value is not required, we can omit it by using blank identifier.
main.go
1

for _, value := range caps {
2
	fmt.Printf("value => %v\n", value)
3
}
4
for key, _ := range caps {
5
	fmt.Printf("key =>%v\n", key)
6
}
Copied!
Finding element in map
To find element in map, we provide key to the map to get element/value returned from map. A map does not panic if we try to access key which is not present, instead it returns zero value. To identify if value is returned is actual value present on map or zero value returned due to absence of key, map returns a second value, ok which tells if key was found or not.  
If we see output for below code snippet, when we check for XYZ and ABC, both returns empty string. For XYZ, value is empty string, while for ABC, it is missing from map.
main.go
1
cocs := map[string]string{
2
		"India":   "Delhi",
3
		"England": "London",
4
		"U.S.":    "Washington",
5
		"XYZ":     "",
6
	}
7
​
8
fmt.Printf("Checking captial for India-> %v\n",
9
	cocs["India"])
10
fmt.Printf("Checking captial for XYZ-> %v\n",
11
	cocs["XYZ"])
12
fmt.Printf("Checking captial for ABC-> %v\n",
13
	cocs["ABC"])
Copied!
To distinguish between empty/zero value and missing value, we can use value,ok semantics.
main.go
1
value, ok := cocs["XYZ"]
2
if ok {
3
	fmt.Printf("Value is %v \n", value)
4
} else {
5
	fmt.Println("Key not found")
6
}
7
value, ok = cocs["ABC"]
8
if ok {
9
	fmt.Printf("Value is %v \n", value)
10
} else {
11
	fmt.Println("Key not found")
12
}
Copied!
Updating element in map
Updating value is similar to creating a value. We can use 
map[key]= value semantic to update value for given key.
main.go
1

capitals = map[string]string{
2
		"India":   "",
3
		"England": "London",
4
		"U.S.":    "Washington",
5
}
6
capitals["India"] = "Delhi"
7
fmt.Println(capitals)
Copied!
Deleting element from map
Deleting value from map is straightforward. Go provides inbuilt delete function to delete a value from map. Semantics for delete is 
delete(mapName,key)
main.go
1

capitals = map[string]string{
2
		"India":   "Pune",
3
		"England": "London",
4
		"U.S.":    "Washington",
5
}
6
​
7
delete(capitals, "England")
8
fmt.Println(capitals)
Copied!
Comparing maps
Similar to slices, maps can not be compared directly. We can only check if a map is nil or not directly. For other comparisons, we need to write our own for loop for comparison.
GitHub Code
codewithgo-samples/maps at master · gophersumit/codewithgo-samples
GitHub
Blog Posts
Go maps in action - The Go Programming Language
Macro View of Map Internals In Go
Videos
GopherCon 2016: Keith Randall - Inside the Map Implementation
​