How to check if a map contains a key in Go?

In Go, checking if a map contains a key is straightforward using the two-value assignment syntax. This method returns both the value associated with the key (or the zero value if the key is absent) and a boolean indicating whether the key exists. Below is a detailed explanation with multiple examples.

Key Syntax

value, exists := myMap[key]

• value: The value associated with key (or the zero value if the key doesn’t exist).
• exists: A boolean (true/false) indicating if the key is present.

Examples

1. Basic Key Check

Check if a key exists in a map[string]int:

package main

import "fmt"

func main() {
    fruitStock := map[string]int{
        "apple":  5,
        "banana": 3,
    }

    // Check if "apple" exists
    if _, exists := fruitStock["apple"]; exists {
        fmt.Println("Apple exists!")
    } else {
        fmt.Println("Apple does NOT exist.")
    }

    // Check if "grape" exists
    if _, exists := fruitStock["grape"]; exists {
        fmt.Println("Grape exists!")
    } else {
        fmt.Println("Grape does NOT exist.")
    }
}

Output:

Apple exists!
Grape does NOT exist.

2. Handling Zero Values

A key might exist with a zero value (e.g., 0 for int). Use the boolean to confirm presence:

func main() {
    scores := map[string]int{
        "Alice": 90,
        "Bob":   0, // Explicit zero value
    }

    // Check "Bob" (key exists but value is 0)
    value, exists := scores["Bob"]
    fmt.Printf("Key 'Bob': exists=%v, value=%d\n", exists, value)

    // Check "Charlie" (key does not exist)
    value, exists = scores["Charlie"]
    fmt.Printf("Key 'Charlie': exists=%v, value=%d\n", exists, value)
}

Output:

Key 'Bob': exists=true, value=0
Key 'Charlie': exists=false, value=0

3. Using the Value If It Exists

Retrieve and use the value if the key exists:

func main() {
    userRoles := map[string]string{
        "alice": "admin",
        "bob":   "user",
    }

    // Get role if the user exists
    if role, exists := userRoles["alice"]; exists {
        fmt.Println("Alice's role:", role)
    } else {
        fmt.Println("Alice is not registered.")
    }
}

Output:

Alice's role: admin

4. Checking Keys in a Nil Map

Accessing a key in a nil map is safe and returns false for existence:

func main() {
    var nilMap map[string]int // nil map

    // Check a key in a nil map
    _, exists := nilMap["apple"]
    fmt.Println("Key exists in nil map:", exists) // false
}

Output:

Key exists in nil map: false

5. Checking Keys in a Struct Value Map

Works for maps with complex values (e.g., struct):

type User struct {
    Age  int
    City string
}

func main() {
    users := map[string]User{
        "alice": {Age: 25, City: "New York"},
        "bob":   {Age: 30, City: "London"},
    }

    // Check if "alice" exists and print her city
    if user, exists := users["alice"]; exists {
        fmt.Println("Alice lives in:", user.City)
    }
}

Output:

Alice lives in: New York

Common Mistakes

Mistake 1: Relying Only on the Value

// ❌ Incorrect: Fails if the key exists with a zero value
value := fruitStock["orange"]
if value != 0 {
    fmt.Println("Orange exists!") // May miss keys with value=0
}

Mistake 2: Single-Value Assignment

// ❌ Incorrect: Can't distinguish missing keys from zero values
value := fruitStock["grape"]
fmt.Println(value) // 0 (but key doesn't exist)

Key Takeaways

• Use the two-value assignment (value, exists := myMap[key]) to check existence.
• The boolean (exists) is the only reliable way to confirm if a key exists.
• Works for all key types (e.g., string, int, custom types).
• Safe for nil maps (returns false for exists).

By using this pattern, you can safely and efficiently check for keys in Go maps!