Apps Artificial Intelligence CSS DevOps Go JavaScript Laravel Linux MongoDB MySQL PHP Python Rust Svelte Vue

How to Get a Slice of Map Keys in Go

1 min read .
Updated on
How to Get a Slice of Map Keys in Go

Go maps store key-value pairs, but many tasks only need the keys—for example, to sort them, display them, compare sets, or feed them into another operation.

Map iteration is intentionally unordered, so extracting keys into a slice is also the first step when you need a deterministic order.

1. Collect All Keys with range

func getMapKeys(m map[string]int) []string {
	keys := make([]string, 0, len(m))
	for k := range m {
		keys = append(keys, k)
	}
	return keys
}

func main() {
	myMap := map[string]int{
		"apple":  1,
		"banana": 2,
		"cherry": 3,
	}

	keys := getMapKeys(myMap)
	fmt.Println("Keys:", keys)
}

Preallocating the slice with capacity len(m) avoids unnecessary growth while keys are appended.

Do not rely on the order returned by map iteration. Go deliberately does not guarantee it.

2. Sort String Keys

If you need stable lexical ordering:

import "sort"

func getSortedMapKeys(m map[string]int) []string {
	keys := make([]string, 0, len(m))
	for k := range m {
		keys = append(keys, k)
	}

	sort.Strings(keys)
	return keys
}

Example:

myMap := map[string]int{
	"banana": 2,
	"apple":  1,
	"cherry": 3,
}

keys := getSortedMapKeys(myMap)
fmt.Println("Sorted Keys:", keys) // [apple banana cherry]

In modern Go, the slices package also provides generic sorting helpers.

3. Generic Key Extraction

With Go generics, one helper can work for any comparable key type:

func mapKeys[K comparable, V any](m map[K]V) []K {
	keys := make([]K, 0, len(m))
	for k := range m {
		keys = append(keys, k)
	}
	return keys
}

Example:

numbers := map[int]string{
	10: "ten",
	20: "twenty",
}

keys := mapKeys(numbers)
fmt.Println(keys)

The result order is still unspecified unless you sort it afterward.

4. Custom Struct Keys

A struct can be a map key when all of its fields are comparable:

type Person struct {
	Name string
	Age  int
}

func getPersonKeys(m map[Person]int) []Person {
	keys := make([]Person, 0, len(m))
	for k := range m {
		keys = append(keys, k)
	}

	sort.Slice(keys, func(i, j int) bool {
		return keys[i].Name < keys[j].Name
	})

	return keys
}

You can sort by Name, Age, or another rule depending on the application’s needs.

Conclusion

To get map keys in Go, range over the map and append each key to a slice. Preallocate when you know the final size, sort the resulting slice whenever deterministic order matters, and use a generic helper if the same operation appears across multiple key and value types.

Golang Map

Related Posts

How to Check Whether a Map Contains a Key in Go
Updated on
How to Check Whether a Map Contains a Key in Go
Go has a built-in idiom for checking whether a map contains a key. A map lookup can return both the stored value and a boolean indicating whether the key is present. Check a Key Copy myMap := map[string]int{ "apple": 1, "banana": 2, "cherry": 3, } key := "banana" value, exists := myMap[key] if exists { fmt.Printf("Key '%s' exists with value %d\n", key, value) } else { fmt.Printf("Key '%s' does not exist\n", key) } The boolean is important because a missing key returns the value type’s zero value. Without the boolean, you cannot distinguish a missing key from a present key whose stored value happens to be zero.
Golang Map
Maps in Go: A Practical Guide with Examples
Updated on
Maps in Go: A Practical Guide with Examples
A Go map stores key-value pairs and gives you fast lookup by key. It is similar to a dictionary or hash map in other languages and is one of Go’s most useful built-in data structures. Creating a Map Using make: Copy personAge := make(map[string]int) personAge["Alice"] = 30 personAge["Bob"] = 25 fmt.Println(personAge) Using a map literal:
Golang Map
Arrays and Slices in Go: Add, Delete, Search, Update, Sort, and Filter
Updated on
Arrays and Slices in Go: Add, Delete, Search, Update, Sort, and Filter
Go arrays and slices are straightforward once you understand their different roles. Arrays have a fixed length that is part of their type, while slices are flexible views over an underlying array and are the collection type used most often in application code. The following examples use a slice of structs: Copy type Person struct { Name string Age int } people := []Person{ {Name: "Alice", Age: 30}, {Name: "Bob", Age: 25}, {Name: "John", Age: 20}, {Name: "Zara", Age: 35}, } 1. Add an Element Use append:
Golang Array Slice
Build a CRUD API with Go, Gin, MySQL, and GORM
Updated on
Build a CRUD API with Go, Gin, MySQL, and GORM
This tutorial builds a small CRUD API with Go, the Gin web framework, MySQL, and GORM. It also uses godotenv for local development configuration. 1. Create the Project Copy mkdir myapp cd myapp go mod init myapp 2. Install Dependencies Copy go get github.com/gin-gonic/gin go get gorm.io/gorm go get gorm.io/driver/mysql go get github.com/joho/godotenv Run go mod tidy after adding your imports so the module file reflects the dependencies actually used by the application.
Golang Gin MySQL GORM
Deploy a Go Web Server with systemd on Linux
Updated on
Deploy a Go Web Server with systemd on Linux
When developing a small Go web server, it is common to run it manually with go run main.go. The problem is that the process stops when the terminal closes, and it will not automatically return after a server reboot. A better production setup is to run the application as a systemd service. That gives you automatic startup, monitoring, service management, and optional restart behavior after failures. 1. Create a Simple Go Web Server Start with a minimal HTTP server:
Golang systemd
Easy Ways to Convert an Integer to a String in Go
Updated on
Easy Ways to Convert an Integer to a String in Go
Converting an integer to a string is common when building output, logs, identifiers, URLs, or serialized data. Go provides several standard-library options depending on whether you need a simple decimal conversion or more control over formatting. 1. strconv.Itoa() For an int in base 10, strconv.Itoa is usually the clearest choice: Copy package main import ( "fmt" "strconv" ) func main() { num := 42 str := strconv.Itoa(num) fmt.Println("String value:", str) } Itoa is equivalent to formatting the int as a base-10 integer.
Golang
chevron-up