Go Language

Learn Go: Understanding Maps in Go #19

In this tutorial, we are going to look at maps in Go and how you can use them

Lets go!!

Published · Jan 31 2020

Previous Tutorial: An Introduction to Slices in Golang #18


  
We are going to be covering just about everything you need to know about maps to get started using them within your own Go applications. We are going to be looking at all of the various ways you interact with maps in Go and by the end of this tutorial, you will be a master when it comes to using them.
. . .

The Map Data Structure
Maps are an incredibly useful data structure when you need incredibly quick key-value lookups. They are used in an incredibly diverse number of ways and they are an invaluable tool in any programmer’s belt regardless of the underlying language used.
Maps in Go can be considered the equivalent of dict in Python, or HashMap in Java.
. . .

Map Basic Syntax
In Go, the map data type is what most programmers would think of as the dictionary type. It maps keys to values, making key-value pairs that are a useful way to store data in Go. 

A map is constructed by using the keyword map followed by the key data type in square brackets [ ], followed by the value data type. The key-value pairs are then placed inside curly braces on either side { }:
map[key]value{}

In addition to the curly braces, there are also colons throughout the map that connect the key-value pairs. The words to the left of the colons are the keys. Keys can be any comparable type in Go, like strings, ints, and so on.
package main

import (
	"fmt"
)

func main() {
	sammy := map[string]string{"name": "Sammy", "animal": "shark", "color": "blue", "location": "ocean"}
	fmt.Println(sammy)
}


The keys in the example map are:
"name"
"animal"
"color"
"location"

The words to the right of the colons are the values. Values can be any data type. The values in the example map are:
"Sammy"
"shark"
"blue"
"ocean"
. . .
Accessing Map Items
You can call the values of a map by referencing the related keys. Since maps offer key-value pairs for storing data, they can be important and useful items in your Go program.

If you want to isolate Sammy’s username, you can do so by calling sammy["name"]; the variable holding your map and the related key. Let’s print that out:
package main

import (
	"fmt"
)

func main() {
	sammy := map[string]string{"name": "Sammy", "animal": "shark", "color": "blue", "location": "ocean"}
	fmt.Println(sammy["name"])
}

https://play.golang.org/p/1SoMu5s-h9V

And receive the value as output:
Output:
Sammy

Maps behave like a database; instead of calling an integer to get a particular index value as you would with a slice, you assign a value to a key and call that key to get its related value.

By invoking the key "name" you receive the value of that key, which is "Sammy".

Similarly you can call the remaining values in the sammy map using the same format:
fmt.Println(sammy["animal"])
// returns shark

fmt.Println(sammy["color"])
// returns blue

fmt.Println(sammy["location"])
// returns ocean

By making use of the key-value pairs in map data types, you can reference keys to retrieve values.
. . .
Adding items to a map
The syntax for adding new items to a map is the same as that of arrays. The program below adds some new items to the personSalary map.
package main

import (  
    "fmt"
)

func main() {  
    personSalary := make(map[string]int)
    personSalary["steve"] = 12000
    personSalary["jamie"] = 15000
    personSalary["mike"] = 9000
    fmt.Println("personSalary map contents:", personSalary)
}

Run in playground

The above program outputs, personSalary map contents: map[steve:12000 jamie:15000 mike:9000]

It is also possible to initialize a map during declaration itself.
package main

import (  
    "fmt"
)

func main() {  
    personSalary := map[string]int {
        "steve": 12000,
        "jamie": 15000,
    }
    personSalary["mike"] = 9000
    fmt.Println("personSalary map contents:", personSalary)
}

Run in playground

The above program declares personSalary and adds two elements to it during declaration itself. Later one more element with key mike is added. The program outputs
personSalary map contents: map[steve:12000 jamie:15000 mike:9000]  

It's not necessary that only string types should be keys. All comparable types such as boolean, integer, float, complex, string, ... can also be keys. If you would like to know more about comparable types, please visit http://golang.org/ref/spec#Comparison_operators

. . .
Deleting items
delete(map, key) is the syntax to delete key from a map. The delete function does no return any value.
package main

import (
	"fmt"
)

func main() {
	sammy := map[string]string{"name": "Sammy", "animal": "shark", "color": "blue"}
	fmt.Println("before deleting -> ", sammy)
	delete(sammy, "color")
	fmt.Println("after deleting -> ", sammy)
}

https://play.golang.org/p/A0ZBUwvY_0w

The above program deletes the key "color" and it outputs
map before deleting  -> map[animal:shark color:blue name:Sammy]
map after deleting  -> map[animal:shark name:Sammy]
. . .
Checking Existence
Maps in Go will return the zero value for the value type of the map when the requested key is missing. Because of this, you need an alternative way to differentiate a stored zero, versus a missing key.

Let’s look up a value in a map that you know doesn’t exist and look at the value returned:
package main

import (
	"fmt"
)

func main() {
	counts := map[string]int{}
	fmt.Println(counts["sammy"])
}

https://play.golang.org/p/3UB9Nx5e1-6

You’ll see the following output:
Output
0

Even though the key sammy was not in the map, Go still returned the value of 0. This is because the value data type is an int, and because Go has a zero value for all variables, it returns the zero value of 0.

In many cases, this is undesirable and would lead to a bug in your program. When looking up the value in a map, Go can return a second, optional value. This second value is a bool and will be true if the key was found, or false if the key was not found. 

In Go, this is referred to as the ok idiom. Even though you could name the variable that captures the second argument anything you want, in Go, you always name it ok:
count, ok := counts["sammy"]

If the key sammy exists in the counts map, then ok will be true. Otherwise ok will be false.

You can use the ok variable to decide what to do in your program:
package main

import (
	"fmt"
)

func main() {
	counts := map[string]int{}

	count, ok := counts["sammy"]
	if ok {
		fmt.Printf("Sammy has a count of %d\n", count)
	} else {
		fmt.Println("Sammy was not found")
	}
}

https://play.golang.org/p/tyzpNAHFLLG

This would result in the following output:
Output
Sammy was not found

In Go, you can combine variable declaration and conditional checking with an if/else block. This allows you to use a single statement for this check:
if count, ok := counts["sammy"]; ok {
    fmt.Printf("Sammy has a count of %d\n", count)
} else {
    fmt.Println("Sammy was not found")
}

When retrieving a value from a map in Go, it’s always good practice to check for its existence as well to avoid bugs in your program.
. . .
Iterating over Keys and Values
When it comes to retrieving values out of a map, we can use the range keyword and loop over keys and values like we would a normal array or slice:
for key, value := range mymap {
    fmt.Println(key)
    fmt.Println(value)
}

Running this will subsequently print out all of the keys and their subsequent values contained within this mymap map.
package main

import (
	"fmt"
)

func main() {

	sammy := map[string]string{"name": "Sammy", "animal": "shark", "color": "blue", "location": "ocean"}

	for key, value := range sammy {
		fmt.Printf("key : %s -> value : %s \n", key, value)
	}
}

https://play.golang.org/p/IDVpNp2vRWq

If you need to extract all of the keys from a given map then you can use this loop in order to retrieve all keys and subsequently append them to an array of keys.
. . .
Maps equality
Maps can't be compared using the == operator. The == can be only used to check if a map is nil.
package main

func main() {  
    map1 := map[string]int{
        "one": 1,
        "two": 2,
    }

    map2 := map1

    if map1 == map2 {
    }
}

https://play.golang.org/p/nawNT_Z_FDl

The above program will throw compilation error invalid operation: map1 == map2 (map can only be compared to nil).

One way to check whether two maps are equal is to compare each one's individual elements one by one. 
. . .

Conclusion
This tutorial explored the map data structure in Go. Maps are made up of key-value pairs and provide a way to store data without relying on indexing. This allows us to retrieve values based on their meaning and relation to other data types.
. . .
Next Tutorial: An Introduction to the Strings in Golang #20 

Golang Tutorial Series:  Learn Go: Beginners Guide to Learn Golang from Scratch!
. . .
References: 
[ 1 ] Understanding Maps in Go
[ 2 ] Maps