Ottenere una fetta di chiavi da una mappa

Esiste un modo più semplice / migliore per ottenere una fetta di chiavi da una mappa in Go?

Attualmente sto ripetendo la mappa e copiando le chiavi in ​​una porzione:

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

Per esempio,

package main

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

Per essere efficiente in Go, è importante ridurre al minimo le allocazioni di memoria.

Questa è una vecchia domanda, ma ecco i miei due centesimi. La risposta di PeterSO è leggermente più concisa, ma leggermente meno efficiente. Sai già quanto sarà grande, quindi non hai nemmeno bisogno di usare append:

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

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

Nella maggior parte delle situazioni probabilmente non farà molta differenza, ma non è molto più lavoro e nei miei test (usando una mappa con 1.000.000 di casuali int64 chiavi e quindi generare l'array di chiavi dieci volte con ogni metodo), si trattava di 20% più veloce nell'assegnare i membri dell'array direttamente rispetto all'uso di append.

Sebbene l'impostazione della capacità elimini le riallocazioni, l'appendice deve ancora fare un lavoro extra per verificare se hai raggiunto la capacità su ciascuna appendice.

Puoi anche prendere un array di chiavi con type []Valueper metodo MapKeysdi struct Valuedal pacchetto "reflection":

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

Un modo migliore per farlo sarebbe usare append:

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

A parte questo, sei sfortunato: Go non è un linguaggio molto espressivo.

Ho fatto un benchmark impreciso sui tre metodi descritti in altre risposte.

Ovviamente pre-allocare la fetta prima di tirare i tasti è più veloce di appending, ma sorprendentemente, il reflect.ValueOf(m).MapKeys()metodo è significativamente più lento di quest'ultimo:

❯ 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

Ecco il codice: https://play.golang.org/p/Z8O6a2jyfTH (eseguendolo nel parco giochi si interrompe sostenendo che ci vuole troppo tempo, quindi, bene, eseguirlo 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)
}