The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Maps

Next ►
►

Maps in Go are powerful data structures that allow you to store and retrieve data using key-value pairs. They are similar to dictionaries in Python or hash tables in other programming languages. This section will cover the basics of maps, how to create and manipulate them, and common operations you can perform with maps.

Key Concepts

  1. Definition: A map is an unordered collection of key-value pairs.
  2. Key-Value Pairs: Each key is unique, and it maps to a value.
  3. Dynamic Size: Maps can grow and shrink as needed.
  4. Zero Value: The zero value of a map is nil.

Creating Maps

You can create a map using the make function or by using a map literal.

Using make Function

package main

import "fmt"

func main() {
    // Create a map with string keys and int values
    var myMap = make(map[string]int)
    fmt.Println(myMap) // Output: map[]
}

Using Map Literals

package main

import "fmt"

func main() {
    // Create a map using a map literal
    myMap := map[string]int{
        "Alice": 25,
        "Bob":   30,
    }
    fmt.Println(myMap) // Output: map[Alice:25 Bob:30]
}

Adding and Retrieving Elements

Adding Elements

package main

import "fmt"

func main() {
    myMap := make(map[string]int)
    myMap["Alice"] = 25
    myMap["Bob"] = 30
    fmt.Println(myMap) // Output: map[Alice:25 Bob:30]
}

Retrieving Elements

package main

import "fmt"

func main() {
    myMap := map[string]int{
        "Alice": 25,
        "Bob":   30,
    }
    age := myMap["Alice"]
    fmt.Println(age) // Output: 25
}

Checking for Existence

You can check if a key exists in a map using the comma ok idiom.

package main

import "fmt"

func main() {
    myMap := map[string]int{
        "Alice": 25,
        "Bob":   30,
    }
    age, exists := myMap["Alice"]
    if exists {
        fmt.Println("Alice's age is", age) // Output: Alice's age is 25
    } else {
        fmt.Println("Alice is not in the map")
    }
}

Deleting Elements

You can delete elements from a map using the delete function.

package main

import "fmt"

func main() {
    myMap := map[string]int{
        "Alice": 25,
        "Bob":   30,
    }
    delete(myMap, "Alice")
    fmt.Println(myMap) // Output: map[Bob:30]
}

Iterating Over Maps

You can iterate over a map using a for loop.

package main

import "fmt"

func main() {
    myMap := map[string]int{
        "Alice": 25,
        "Bob":   30,
    }
    for key, value := range myMap {
        fmt.Printf("%s is %d years old\n", key, value)
    }
    // Output:
    // Alice is 25 years old
    // Bob is 30 years old
}

Practical Exercises

Exercise 1: Create and Manipulate a Map

  1. Create a map to store the names and ages of three people.
  2. Add a new person to the map.
  3. Retrieve and print the age of one person.
  4. Delete one person from the map.
  5. Iterate over the map and print all names and ages.

Solution

package main

import "fmt"

func main() {
    // Step 1: Create a map
    people := map[string]int{
        "Alice": 25,
        "Bob":   30,
        "Eve":   35,
    }

    // Step 2: Add a new person
    people["Charlie"] = 40

    // Step 3: Retrieve and print the age of one person
    age := people["Alice"]
    fmt.Println("Alice's age is", age) // Output: Alice's age is 25

    // Step 4: Delete one person
    delete(people, "Bob")

    // Step 5: Iterate over the map
    for name, age := range people {
        fmt.Printf("%s is %d years old\n", name, age)
    }
    // Output:
    // Alice is 25 years old
    // Eve is 35 years old
    // Charlie is 40 years old
}

Common Mistakes and Tips

  • Nil Map: Trying to add elements to a nil map will cause a runtime panic. Always initialize your map using make or a map literal.
  • Key Existence: Always check if a key exists before using its value to avoid unexpected zero values.
  • Iteration Order: The iteration order over map keys is not specified and can vary from one iteration to the next.

Conclusion

In this section, you learned about maps in Go, including how to create, manipulate, and iterate over them. Maps are a versatile and essential data structure in Go, useful for various applications. In the next section, we will explore structs, another powerful feature in Go for organizing and managing data.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved