Gibt es in Golang eine gute Möglichkeit, ein Stück Werte von einer Karte zu erhalten?

Wenn ich eine Karte m habe, gibt es eine bessere Möglichkeit, einen Schnitt der Werte v zu erhalten

package main
import (
  "fmt"
)

func main() {
    m := make(map[int]string)

    m[1] = "a"
    m[2] = "b"
    m[3] = "c"
    m[4] = "d"

    // Can this be done better?
    v := make([]string, len(m), len(m))
    idx := 0
    for  _, value := range m {
       v[idx] = value
       idx++
    }

    fmt.Println(v)
 }

Gibt es eine integrierte Funktion einer Karte? Gibt es eine Funktion in einem Go-Paket oder ist dies der beste Code, wenn ich muss?

Unglücklicherweise nicht. Es gibt keine eingebaute Möglichkeit, dies zu tun.

Als Randnotiz können Sie das Kapazitätsargument bei Ihrer Slice-Erstellung weglassen:

v := make([]string, len(m))

Die Kapazität entspricht hier der Länge.

Als Ergänzung zu Jimts Beitrag:

Sie können appenddie Werte auch verwenden, anstatt sie explizit ihren Indizes zuzuweisen:

m := make(map[int]string)

m[1] = "a"
m[2] = "b"
m[3] = "c"
m[4] = "d"

v := make([]string, 0, len(m))

for  _, value := range m {
   v = append(v, value)
}

Beachten Sie, dass die Länge Null ist (noch keine Elemente vorhanden), die Kapazität (zugewiesener Speicherplatz) jedoch mit der Anzahl der Elemente von initialisiert wird m. Dies geschieht, sodass appendnicht jedes Mal Speicher zugewiesen werden muss, wenn die Kapazität des Slice verschöpft ist.

Sie können makedas Slice auch ohne den Kapazitätswert verwenden und appendden Speicher für sich selbst zuweisen lassen .

Soweit mir derzeit bekannt ist, gibt es bei go keine Methode zum Verketten von Zeichenfolgen / Bytes zu einer resultierenden Zeichenfolge, ohne mindestens / zwei / Kopien zu erstellen.

Sie müssen derzeit ein [] Byte vergrößern, da alle Zeichenfolgenwerte const sind. DANN müssen Sie die integrierte Zeichenfolge verwenden, damit die Sprache ein 'gesegnetes' Zeichenfolgenobjekt erstellt, für das der Puffer kopiert wird, da irgendwo irgendwo eine Referenz vorhanden sein könnte an die Adresse, die das Byte [] unterstützt.

Wenn ein [] Byte geeignet ist, können Sie einen sehr geringen Vorsprung gegenüber den Bytes erzielen. Verbinden Sie die Funktion, indem Sie eine Zuordnung vornehmen und die Kopie selbst aufrufen.

package main
import (
  "fmt"
)

func main() {
m := make(map[int]string)

m[1] = "a" ;    m[2] = "b" ;     m[3] = "c" ;    m[4] = "d"

ip := 0

/* If the elements of m are not all of fixed length you must use a method like this;
 * in that case also consider:
 * bytes.Join() and/or
 * strings.Join()
 * They are likely preferable for maintainability over small performance change.

for _, v := range m {
    ip += len(v)
}
*/

ip = len(m) * 1 // length of elements in m
r := make([]byte, ip, ip)
ip = 0
for  _, v := range m {
   ip += copy(r[ip:], v)
}

// r (return value) is currently a []byte, it mostly differs from 'string'
// in that it can be grown and has a different default fmt method.

fmt.Printf("%s\n", r)
}

Sie können dieses mapsPaket verwenden:

go get https://github.com/drgrib/maps

Dann müssen Sie nur noch anrufen

values := maps.GetValuesIntString(m)

Es ist typsicher für diese übliche mapKombination. Sie können generateandere typsichere Funktionen für jede andere Art der mapVerwendung von verwendenmapper Tools im selben Paket verwenden.

Vollständige Offenlegung: Ich bin der Schöpfer dieses Pakets. Ich habe es erstellt, weil ich diese Funktionen mapwiederholt neu geschrieben habe.

Nicht unbedingt besser, aber der sauberere Weg , dies zu tun ist , indem sowohl die trotzt Scheibe LäNGE und Kapazität wietxs := make([]Tx, 0, len(txMap))

    // Defines the Slice capacity to match the Map elements count
    txs := make([]Tx, 0, len(txMap))

    for _, tx := range txMap {
        txs = append(txs, tx)
    }

Vollständiges Beispiel:

package main

import (
    "github.com/davecgh/go-spew/spew"
)

type Tx struct {
    from  string
    to    string
    value uint64
}

func main() {
    // Extra touch pre-defining the Map length to avoid reallocation
    txMap := make(map[string]Tx, 3)
    txMap["tx1"] = Tx{"andrej", "babayaga", 10}
    txMap["tx2"] = Tx{"andrej", "babayaga", 20}
    txMap["tx3"] = Tx{"andrej", "babayaga", 30}

    txSlice := getTXsAsSlice(txMap)
    spew.Dump(txSlice)
}

func getTXsAsSlice(txMap map[string]Tx) []Tx {
    // Defines the Slice capacity to match the Map elements count
    txs := make([]Tx, 0, len(txMap))
    for _, tx := range txMap {
        txs = append(txs, tx)
    }

    return txs
}

Einfache Lösung, aber viele Fallstricke. Lesen Sie diesen Blog-Beitrag für weitere Details: https://web3.coach/golang-how-to-convert-map-to-slice-three-gotchas