Go Maps

« Previous Next »

Go Maps

In Go, a map is a built-in data type used to store data in key–value pairs. Each key is unique and maps to a specific value, making maps ideal for fast lookups and dynamic data storage.

Unlike arrays or slices, maps are:

• Unordered (no guaranteed iteration order)
• Mutable (you can add, update, and delete elements)
• Reference types (they point to an underlying hash table)

Key Features of Maps

• Store data as key:value pairs
• Keys must be unique (no duplicates allowed)
• The len() function returns the number of elements
• The zero value of a map is nil
• Internally implemented using a hash table for efficient access

Creating Maps in Go

1. Using Map Literals

package main import "fmt" func main() { // Creating maps with initial values countryCodes := map[string]string{ "IN": "India", "US": "United States", "JP": "Japan", } scores := map[string]int{ "Alice": 90, "Bob": 85, "Eve": 88, } fmt.Println("Countries:", countryCodes) fmt.Println("Scores:", scores) }

Countries: map[IN:India JP:Japan US:United States] Scores: map[Alice:90 Bob:85 Eve:88]

Note: Map output order may vary because maps are unordered.

2. Using the make() Function

package main import "fmt" func main() { // Creating an empty map inventory := make(map[string]int) // Adding elements inventory["Apples"] = 50 inventory["Bananas"] = 30 inventory["Oranges"] = 20 fmt.Println("Inventory:", inventory) }

Inventory: map[Apples:50 Bananas:30 Oranges:20]

Creating an Empty Map Safely

var m1 = make(map[string]int) // initialized and ready to use var m2 map[string]int // nil map (not initialized) Writing to m1 works normally Writing to m2 will cause a runtime panic

Allowed Key and Value Types

Valid Key Types

Keys must support the == operator:

• Numbers (int, float, etc.)
• Strings
• Booleans
• Arrays
• Structs
• Pointers
• Interfaces (if comparable)

Invalid Key Types

These cannot be used as keys:

• Slices
• Maps
• Functions

Value Types

Map values can be any data type.

Accessing Map Elements

price := map[string]int{ "Pen": 10, "Book": 50, } fmt.Println(price["Pen"]) // Output: 10

Adding and Updating Elements

cart := make(map[string]int) cart["Milk"] = 2 // Add cart["Bread"] = 1 // Add cart["Milk"] = 3 // Update fmt.Println(cart)

Deleting Elements

delete(cart, "Bread")

Checking if a Key Exists

studentMarks := map[string]int{ "Rahul": 80, "Neha": 90, } marks, exists := studentMarks["Rahul"] fmt.Println(marks, exists) // 80 true _, found := studentMarks["Amit"] fmt.Println(found) // false

This pattern avoids confusion when a key might exist with a zero value.

Maps Are Reference Types

Maps do not store data directly—they reference an underlying structure. Assigning one map to another shares the same data.

package main import "fmt" func main() { original := map[string]int{"A": 1, "B": 2} copyMap := original copyMap["A"] = 100 fmt.Println("Original:", original) fmt.Println("Copy:", copyMap) }

Original: map[A:100 B:2] Copy: map[A:100 B:2]

Both variables reflect the same change.

Iterating Over a Map

package main import "fmt" func main() { items := map[string]int{ "Pen": 10, "Pencil": 5, "Eraser": 3, } for key, value := range items { fmt.Println(key, ":", value) } }

Pen : 10 Pencil : 5 Eraser : 3

The iteration order is not guaranteed.

Iterating in a Specific Order

To control the order, use a separate slice of keys:

package main import "fmt" func main() { data := map[string]int{ "one": 1, "two": 2, "three": 3, } keys := []string{"one", "two", "three"} for _, k := range keys { fmt.Println(k, ":", data[k]) } }

one : 1 two : 2 three : 3

« Previous Next »

AI Code Explanation Go Language

Powered by Gocourse AI