Using Maps for Lookup Tables in Go

Introduction to Maps in Go

In the Go programming language, maps are a built-in data type that provides a way to store key-value pairs. They are similar to dictionaries in Python or hash tables in other languages. This makes them ideal for use as lookup tables where you can efficiently store and retrieve data based on a unique key.

Basic Usage of Maps

Let's start with a simple example of using maps in Go. We will create a map to associate names with ages.

package main

import "fmt"

func main() {
    // Create a map with string keys and int values
    ages := map[string]int{
        "Alice": 30,
        "Bob": 25,
        "Charlie": 35,
    }

    // Print the map
    fmt.Println(ages)

    // Access an element by key
    fmt.Println("Alice", ages["Alice"])

    // Check if a key exists
    if age, ok := ages["Bob"]; ok {
        fmt.Println("Bob", age)
    } else {
        fmt.Println("Bob not found")
    }
}

Intermediate Concepts

Maps in Go are dynamic, you can add, update, and delete elements. Let's explore these operations.

package main

import "fmt"

func main() {
    // Initialize a map
    countries := make(map[string]string)

    // Adding elements
    countries["USA"] = "Washington, D.C."
    countries["Canada"] = "Ottawa"

    // Updating an element
    countries["USA"] = "DC"

    // Deleting an element
    delete(countries, "Canada")

    // Iterating over a map
    for country, capital := range countries {
        fmt.Printf("The capital of %s is %s
", country, capital)
    }
}

Advanced Map Usage

In more advanced scenarios, you might need to work with maps of composite keys or need a map that provides access to default values. Let's look into an advanced topic: maps with slices as values, and creating a map with a user-defined key type.

Maps with Slice Values

package main

import "fmt"

func main() {
    // Maps with slice values
    group := map[string][]string{
        "Fruit":     {"Apple", "Banana"},
        "Vegetable": {"Carrot", "Cucumber"},
    }
    
    // Adding an item to a slice in the map
    group["Fruit"] = append(group["Fruit"], "Cherry")
    
    for category, items := range group {
        fmt.Printf("%s: %v
", category, items)
    }
}

User-defined Key Types in Map

package main

import "fmt"

// Define a composite key type
type Coordinate struct {
    Latitude, Longitude float64
}

func main() {
    // Map with a struct as a key
    locations := make(map[Coordinate]string)

    locations[Coordinate{40.7128, -74.0060}] = "New York"
    locations[Coordinate{34.0522, -118.2437}] = "Los Angeles"

    for coord, city := range locations {
        fmt.Printf("%s is located at %v
", city, coord)
    }
}

Conclusion

Maps in Go are a powerful tool for implementing lookup tables thanks to their flexibility in terms of key-value pairings and efficient operations. They've proven particularly useful in various applications from simple tasks like querying elements to more complex tasks like transforming maps.