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 of any data type.

---

Accessing, Adding, and Deleting Elements

Accessing Map Elements

package main import "fmt" func main() { price := map[string]int{ "Pen": 10, "Book": 50, } fmt.Println(price["Pen"]) }

10

Adding, Updating, and Deleting Elements

package main import "fmt" func main() { cart := make(map[string]int) cart["Milk"] = 2 // Add cart["Bread"] = 1 // Add cart["Milk"] = 3 // Update (overwrites previous value) fmt.Println("Before Delete:", cart) delete(cart, "Bread") // Delete fmt.Println("After Delete:", cart) }

Before Delete: map[Bread:1 Milk:3] After Delete: map[Milk:3]

Checking if a Key Exists

Checking if a key exists avoids confusion when a key might legitimately be stored with a zero value.

package main import "fmt" func main() { studentMarks := map[string]int{ "Rahul": 80, "Neha": 90, } marks, exists := studentMarks["Rahul"] fmt.Println("Rahul:", marks, "| Exists:", exists) _, found := studentMarks["Amit"] fmt.Println("Amit exists:", found) }

Rahul: 80 | Exists: true Amit exists: false

---

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 // Modifying the copy changes the original too 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"} // Desired order for _, k := range keys { fmt.Println(k, ":", data[k]) } }

one : 1 two : 2 three : 3

« Previous Next »