Ein Stück Schlüssel von einer Karte bekommen

Gibt es eine einfachere / schönere Möglichkeit, in Go ein Stück Schlüssel von einer Karte zu erhalten?

Derzeit iteriere ich über die Karte und kopiere die Schlüssel in ein Slice:

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

Beispielsweise,

package main

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

Um in Go effizient zu sein, ist es wichtig, die Speicherzuweisungen zu minimieren.

Dies ist eine alte Frage, aber hier sind meine zwei Cent. Die Antwort von PeterSO ist etwas prägnanter, aber etwas weniger effizient. Sie wissen bereits, wie groß es sein wird, sodass Sie nicht einmal append verwenden müssen:

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

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

In den meisten Situationen wird es wahrscheinlich keinen großen Unterschied machen, aber es ist nicht viel mehr Arbeit, und in meinen Tests (unter Verwendung einer Karte mit 1.000.000 zufälligen int64Schlüsseln und anschließendes zehnmaliges Generieren des Schlüsselarrays mit jeder Methode) ging es darum 20% schneller, um Mitglieder des Arrays direkt zuzuweisen, als um Anhängen zu verwenden.

Durch das Festlegen der Kapazität werden zwar Neuzuweisungen vermieden, das Anhängen muss jedoch noch zusätzliche Arbeit leisten, um zu überprüfen, ob Sie bei jedem Anhängen die Kapazität erreicht haben.

Sie können auch ein Array von Schlüsseln mit Typ []Valuenach MapKeysStrukturmethode Valueaus dem Paket "Reflect" entnehmen :

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

Ein besserer Weg, dies zu tun, wäre append:

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

Abgesehen davon haben Sie kein Glück - Go ist keine sehr ausdrucksstarke Sprache.

Ich habe einen skizzenhaften Benchmark für die drei in anderen Antworten beschriebenen Methoden erstellt.

Offensichtlich ist die Vorbelegung des Slice vor dem Ziehen der Tasten schneller als die appendEingabe, aber überraschenderweise ist die reflect.ValueOf(m).MapKeys()Methode erheblich langsamer als die letztere:

❯ 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

Hier ist der Code: https://play.golang.org/p/Z8O6a2jyfTH (das Ausführen auf dem Spielplatz bricht ab und behauptet, dass es zu lange dauert, also führen Sie es lokal aus.)

Besuchen Sie 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)
}