Obtener una porción de llaves de un mapa

¿Hay alguna forma más simple / mejor de obtener una porción de claves de un mapa en Go?

Actualmente estoy iterando sobre el mapa y copiando las claves en un segmento:

i := 0
keys := make([]int, len(mymap))
for k := range mymap {
    keys[i] = k
    i++
}

Por ejemplo,

package main

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

Para ser eficiente en Go, es importante minimizar las asignaciones de memoria.

Esta es una vieja pregunta, pero aquí están mis dos centavos. La respuesta de PeterSO es un poco más concisa, pero un poco menos eficiente. Ya sabes lo grande que será, así que ni siquiera necesitas usar append:

keys := make([]int, len(mymap))

i := 0
for k := range mymap {
    keys[i] = k
    i++
}

En la mayoría de las situaciones, probablemente no hará mucha diferencia, pero no es mucho más trabajo, y en mis pruebas (usando un mapa con 1,000,000 int64claves aleatorias y luego generando la matriz de claves diez veces con cada método), se trataba de 20% más rápido para asignar miembros de la matriz directamente que para usar append.

Si bien establecer la capacidad elimina las reasignaciones, append todavía tiene que hacer un trabajo adicional para verificar si ha alcanzado la capacidad en cada anexo.

También puede tomar una matriz de claves con tipo []Valuepor método MapKeysde estructura Valuedel paquete "reflect":

package main

import (
    "fmt"
    "reflect"
)

func main() {
    abc := map[string]int{
        "a": 1,
        "b": 2,
        "c": 3,
    }

    keys := reflect.ValueOf(abc).MapKeys()

    fmt.Println(keys) // [a b c]
}

Una mejor manera de hacer esto sería usar append:

keys = []int{}
for k := range mymap {
    keys = append(keys, k)
}

Aparte de eso, no tienes suerte: Go no es un lenguaje muy expresivo.

Hice un punto de referencia incompleto sobre los tres métodos descritos en otras respuestas.

Obviamente, preasignar el segmento antes de tirar de las teclas es más rápido que appending, pero sorprendentemente, el reflect.ValueOf(m).MapKeys()método es significativamente más lento que el último:

❯ go run scratch.go
populating
filling 100000000 slots
done in 56.630774791s
running prealloc
took: 9.989049786s
running append
took: 18.948676741s
running reflect
took: 25.50070649s

Aquí está el código: https://play.golang.org/p/Z8O6a2jyfTH (ejecutarlo en el patio de juegos aborta alegando que lleva demasiado tiempo, así que, bueno, ejecútelo localmente).

Visita https://play.golang.org/p/dx6PTtuBXQW

package main

import (
    "fmt"
    "sort"
)

func main() {
    mapEg := map[string]string{"c":"a","a":"c","b":"b"}
    keys := make([]string, 0, len(mapEg))
    for k := range mapEg {
        keys = append(keys, k)
    }
    sort.Strings(keys)
    fmt.Println(keys)
}