How to Iterate Over Map Keys in Go

By the end of this page, you will understand how to loop through the keys of a Go map using range, how to collect keys into a slice when needed, why map order is not guaranteed, and how this pattern is used in real Go programs.

In Go, a map stores key-value pairs. When you want to visit every entry in a map, the usual tool is a for loop with range.

A Go map does not provide a separate built-in "get all keys" function. Instead, you iterate through the map directly:

for key := range m {
    fmt.Println(key)
}

This works because range can loop over maps and return each key one at a time.

If you also need the value, you can write:

for key, value := range m {
    fmt.Println(key, value)
}

This concept matters because maps are used everywhere in Go:

• configuration lookups
• counting frequencies
• caching data
• grouping records
• tracking flags or states

Understanding how to iterate over a map is essential for reading, transforming, validating, and exporting data.

One important rule: map iteration order in Go is not guaranteed. If you print keys from a map, they may appear in a different order between runs. If you need a stable order, collect the keys into a slice and sort them.

Think of a Go map like a labeled storage cabinet.

• The key is the label on a drawer.
• The value is what is stored inside that drawer.
• len(m) tells you how many drawers exist.
• range lets you walk past every drawer and read its label.

If you only care about the labels, you read just the keys. If you care about both the labels and contents, you read both key and value.

The cabinet does not promise that the drawers will appear in alphabetical or insertion order. You are simply visiting all existing drawers in an unspecified order.

Basic syntax

To iterate over all keys in a Go map:

for key := range m {
    fmt.Println(key)
}

To iterate over keys and values:

for key, value := range m {
    fmt.Println(key, value)
}

Example: print all keys

package main

import "fmt"

func main() {
    m := map[string]string{
        "key1": "val1",
        "key2": "val2",
        "key3": "val3",
    }

    for key := range m {
        fmt.Println(key)
    }
}

This loops through the map and prints each key.

Example: collect keys into a slice

Sometimes you want a list of keys instead of printing them immediately.

package main

import "fmt"

 {
    m := []{
        : ,
        : ,
        : ,
    }

    keys := ([], , (m))

     key :=  m {
        keys = (keys, key)
    }

    fmt.Println(keys)
}

Consider this example:

package main

import "fmt"

func main() {
    m := map[string]string{
        "name": "Ada",
        "city": "London",
    }

    for key := range m {
        fmt.Println("key:", key)
    }
}

Step by step:

1. A map named m is created.

2. It contains two entries:

   • "name" -> "Ada"
   • "city" -> "London"

3. The loop starts:

   for key := range m {
   

4. range m asks Go to visit every entry in the map.

5. On each iteration, Go places the current key into the variable key.

Here are common situations where iterating over map keys is useful:

Configuration processing

config := map[string]string{
    "host": "localhost",
    "port": "8080",
}

for key := range config {
    fmt.Println("config key:", key)
}

You may want to validate required settings or print supported options.

Counting and reporting

wordCount := map[string]int{
    "go": 3,
    "map": 2,
}

for word := range wordCount {
    fmt.Println(word)
}

This is useful when generating summaries from counted data.

Building API responses

A service might store fields in a map and iterate over keys to produce output or check allowed fields.

Data validation

You can loop over submitted keys to reject unknown fields:

allowed := map[string]bool{
    "name": ,
    : ,
}

submitted := []{
    : ,
    : ,
}

 key :=  submitted {
     !allowed[key] {
        fmt.Println(, key)
    }
}

In real Go codebases, developers usually use map iteration in a few standard patterns.

1. Simple traversal

When order does not matter:

for key, value := range m {
    process(key, value)
}

This is the most common pattern.

2. Collect then sort

When output must be deterministic, such as in tests, logs, or generated files:

keys := make([]string, 0, len(m))
for key := range m {
    keys = append(keys, key)
}
sort.Strings(keys)

Then iterate over keys.

3. Validation against known keys

Maps are often used as sets:

allowed := map[string]struct{}{
    "name":  {},
    "email": {},
}

for key := range input {
    if _, ok := allowed[key]; !ok {
        return fmt.Errorf("unknown field: %s", key)
    }
}

This is common in request validation and config parsing.

Assuming the order is fixed

Broken expectation:

for key := range m {
    fmt.Println(key)
}

A beginner may expect insertion order or alphabetical order. Go does not guarantee either.

How to avoid it:

• collect keys into a slice
• sort the slice
• iterate over the sorted slice

Thinking len(m) gives access to keys

len(m) only tells you how many entries are in the map. It does not provide the keys themselves.

count := len(m)
fmt.Println(count)

This is useful for size, not traversal.

Ignoring the value when you actually need it

If you need both key and value, do not do an extra lookup unless necessary.

Less efficient style:

for key := range m {
    fmt.Println(key, m[key])
}

Better:

for key, value := range m {
    fmt.Println(key, value)
}

Trying to use a nonexistent keys() function

Go maps do not have a built-in method.

range over map vs range over slice

// Iterate over keys only
for key := range m {
    fmt.Println(key)
}

// Iterate over keys and values
for key, value := range m {
    fmt.Println(key, value)
}

// Get number of entries
n := len(m)

// Collect keys into a slice
keys := make([]string, 0, len(m))
for key := range m {
    keys = append(keys, key)
}

Rules to remember

• Go maps are iterated with for ... range.
• len(m) gives the count, not the keys.
• Map iteration order is not guaranteed.
• If order matters, collect keys and sort them.
• Use for key, value := range m when you need both pieces of data.

Common pattern for sorted output

keys := make([]string, 0, len(m))
for key := range m {
    keys = append(keys, key)
}
sort.Strings(keys)
for _, key := range keys {
    fmt.Println(key, m[key])
}

How do I loop through all keys in a Go map?

Use for key := range m {}.

Can I get all map keys as a slice in Go?

Yes. Create a slice, then append each key while ranging over the map.

Does Go preserve map insertion order?

No. Map iteration order is not guaranteed.

How do I print both keys and values from a Go map?

Use for key, value := range m {}.

Is there a built-in function to return map keys in Go?

No built-in map method returns all keys directly. You iterate with range.

Why is my map output order changing?

Because Go maps do not guarantee iteration order. Sort the keys if you need stable output.

• for loop — Map iteration in Go uses the for keyword.
• range — The core language feature used to iterate over maps, slices, arrays, and strings.
• slices — Useful when collecting map keys into an ordered list.
• sorting in Go — Needed when you want map keys in a predictable order.
• map lookup with comma ok — Important when checking whether a key exists.
• maps as sets — A common pattern where only the key matters.
• zero values in Go — Useful when understanding missing map keys and lookups.