Obtendo uma fatia de chaves de um mapa

Existe alguma maneira mais simples / agradável de obter uma fatia de chaves de um mapa no Go?

Atualmente, eu estou iterando sobre o mapa e copiando as chaves para uma fatia:

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

Por exemplo,

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 no Go, é importante minimizar as alocações de memória.

Esta é uma pergunta antiga, mas aqui estão meus dois centavos. A resposta do PeterSO é um pouco mais concisa, mas um pouco menos eficiente. Você já sabe o quão grande será, então nem precisa usar o apêndice:

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

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

Na maioria das situações, provavelmente não fará muita diferença, mas não é muito mais trabalhoso. Nos meus testes (usando um mapa com 1.000.000 de int64chaves aleatórias e gerando a matriz de chaves dez vezes com cada método), tratava-se de 20% mais rápido para atribuir membros da matriz diretamente do que usar anexar.

Embora a configuração da capacidade elimine realocações, o anexo ainda precisa fazer um trabalho extra para verificar se você atingiu a capacidade em cada anexo.

Você também pode pegar uma matriz de chaves com o tipo []Valuepelo método MapKeysde struct Valuedo pacote "refletir":

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]
}

Uma maneira melhor de fazer isso seria usar append:

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

Fora isso, você está sem sorte - o Go não é uma linguagem muito expressiva.

Fiz uma referência superficial dos três métodos descritos em outras respostas.

Obviamente, pré-alocar a fatia antes de puxar as teclas é mais rápido que o appending, mas, surpreendentemente, o reflect.ValueOf(m).MapKeys()método é significativamente mais lento que o ú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

Aqui está o código: https://play.golang.org/p/Z8O6a2jyfTH (executá-lo no playground aborta, alegando que leva muito tempo, então, bem, execute-o localmente).

Visite 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)
}