HTML tutorial
CSS3 tutorial
Bootstrap tutorial
JavaScript tutorial
JQuery tutorial
AngularJS tutorial
React tutorial
NodeJS tutorial
PHP tutorial
Python tutorial
Python3 tutorial
Django tutorial
Linux tutorial
Docker tutorial
Ruby tutorial
Java tutorial
C tutorial
C ++ tutorial
Perl tutorial
JSP tutorial
Lua tutorial
Scala tutorial
Go tutorial
ASP.NET tutorial
C # tutorial
Maps are used to store data values in key:value pairs
Maps are used to store data values in key:value pairs.
Each element in a map is a key:value pair.
A map is an unordered and changeable collection that does not allow duplicates.
The length of a map is the number of its elements. You can find it using the len() function.
The default value of a map is nil.
Maps hold references to an underlying hash table.
Go has multiple ways for creating maps.
var a = map[KeyType]ValueType{key1:value1, key2:value2,...}
b := map[KeyType]ValueType{key1:value1, key2:value2,...}
This example shows how to create maps in Go. Notice the order in the code and in the output
package main
import ("fmt")
func main() {
var a = map[string]string{"brand": "Ford", "model": "Mustang", "year": "1964"}
b := map[string]int{"Oslo": 1, "Bergen": 2, "Trondheim": 3, "Stavanger": 4}
fmt.Printf("a\t%v\n", a)
fmt.Printf("b\t%v\n", b)
}
Result:
a map[brand:Ford model:Mustang year:1964]
b map[Bergen:2 Oslo:1 Stavanger:4 Trondheim:3]
Note: The order of the map elements defined in the code is different from the way that they are stored. The data are stored in a way to have efficient data retrieval from the map.
var a = make(map[KeyType]ValueType)
b := make(map[KeyType]ValueType)
This example shows how to create maps in Go using the make()function.
package main
import ("fmt")
func main() {
var a = make(map[string]string) // The map is empty now
a["brand"] = "Ford"
a["model"] = "Mustang"
a["year"] = "1964"
// a is no longer empty
b := make(map[string]int)
b["Oslo"] = 1
b["Bergen"] = 2
b["Trondheim"] = 3
b["Stavanger"] = 4
fmt.Printf("a\t%v\n", a)
fmt.Printf("b\t%v\n", b)
}
Result:
a map[brand:Ford model:Mustang year:1964]
b map[Bergen:2 Oslo:1 Stavanger:4 Trondheim:3]
There are two ways to create an empty map. One is by using the make()function and the other is by using the following syntax.
var a map[KeyType]ValueType
Note: The make()function is the right way to create an empty map. If you make an empty map in a different way and write to it, it will causes a runtime panic.
This example shows the difference between declaring an empty map using with the make()function and without it.
package main
import ("fmt")
func main() {
var a = make(map[string]string)
var b map[string]string
fmt.Println(a == nil)
fmt.Println(b == nil)
}
Result:
false
true
The map key can be of any data type for which the equality operator (==) is defined. These include:
Invalid key types are:
These types are invalid because the equality operator (==) is not defined for them.
The map values can be any type.
You can access map elements by:
value = map_name[key]
package main
import ("fmt")
func main() {
var a = make(map[string]string)
a["brand"] = "Ford"
a["model"] = "Mustang"
a["year"] = "1964"
fmt.Printf(a["brand"])
}
Result:
Ford
Updating or adding an elements are done by:
map_name[key] = value
This example shows how to update and add elements to a map.
package main
import ("fmt")
func main() {
var a = make(map[string]string)
a["brand"] = "Ford"
a["model"] = "Mustang"
a["year"] = "1964"
fmt.Println(a)
a["year"] = "1970" // Updating an element
a["color"] = "red" // Adding an element
fmt.Println(a)
}
Result:
map[brand:Ford model:Mustang year:1964]
map[brand:Ford color:red model:Mustang year:1970]
Removing elements is done using the delete() function.
delete(map_name, key)
package main
import ("fmt")
func main() {
var a = make(map[string]string)
a["brand"] = "Ford"
a["model"] = "Mustang"
a["year"] = "1964"
fmt.Println(a)
delete(a,"year")
fmt.Println(a)
}
Result:
map[brand:Ford model:Mustang year:1964]
map[brand:Ford model:Mustang]
You can check if a certain key exists in a map using:
val, ok :=map_name[key]
If you only want to check the existence of a certain key, you can use the blank identifier (_) in place of val.
package main
import ("fmt")
func main() {
var a = map[string]string{"brand": "Ford", "model": "Mustang", "year": "1964", "day":""}
val1, ok1 := a["brand"] // Checking for existing key and its value
val2, ok2 := a["color"] // Checking for non-existing key and its value
val3, ok3 := a["day"] // Checking for existing key and its value
_, ok4 := a["model"] // Only checking for existing key and not its value
fmt.Println(val1, ok1)
fmt.Println(val2, ok2)
fmt.Println(val3, ok3)
fmt.Println(ok4)
}
Result:
Ford true
false
true
true
Example Explained
In this example, we checked for existence of different keys in the map.
The key "color" does not exist in the map. So the value is an empty string ('').
The ok2 variable is used to find out if the key exist or not. Because we would have got the same value if the value of the "color" key was empty. This is the case for val3.
Maps are references to hash tables.
If two map variables refer to the same hash table, changing the content of one variable affect the content of the other.
package main
import ("fmt")
func main() {
var a = map[string]string{"brand": "Ford", "model": "Mustang", "year": "1964"}
b := a
fmt.Println(a)
fmt.Println(b)
b["year"] = "1970"
fmt.Println("After change to b:")
fmt.Println(a)
fmt.Println(b)
}
Result:
map[brand:Ford model:Mustang year:1964]
map[brand:Ford model:Mustang
year:1964]
After change to b:
map[brand:Ford model:Mustang year:1970]
map[brand:Ford model:Mustang year:1970]You can use range to iterate over maps.
This example shows how to iterate over the elements in a map. Note the order of the elements in the output.
package main
import ("fmt")
func main() {
a := map[string]int{"one": 1, "two": 2, "three": 3, "four": 4}
for k, v := range a {
fmt.Printf("%v : %v, ", k, v)
}
}
Result:
two : 2, three : 3, four : 4, one : 1,
Maps are unordered data structures. If you need to iterate over a map in a specific order, you must have a separate data structure that specifies that order.
package main
import ("fmt")
func main() {
a := map[string]int{"one": 1, "two": 2, "three": 3, "four": 4}
var b = []string // defining the order
b = append(b, "one", "two", "three", "four")
for k, v := range a { // loop with no order
fmt.Printf("%v : %v, ", k, v)
}
fmt.Println()
for _, element := range b { // loop with the defined order
fmt.Printf("%v : %v, ", element, a[element])
}
}
Result:
two : 2, three : 3, four : 4, one : 1,
one : 1, two : 2, three : 3, four : 4,