web-dev-qa-db-fra.com

Comment parcourir une carte en golang dans l'ordre?

S'il vous plaît voir ci-dessous ma carte

var romanNumeralDict map[int]string = map[int]string{
  1000: "M",
  900 : "CM",
  500 : "D",
  400 : "CD",
  100 : "C",
  90  : "XC",
  50  : "L",
  40  : "XL",
  10  : "X",
  9   : "IX",
  5   : "V",
  4   : "IV",
  1   : "I",
}

Je cherche à faire une boucle sur cette carte dans l'ordre de la taille de la clé

  for k, v := range romanNumeralDict {
    fmt.Println("k:", k, "v:", v)
  }

Cependant, cela imprime 

k: 1000 v: M
k: 40 v: XL
k: 5 v: V
k: 4 v: IV
k: 900 v: CM
k: 500 v: D
k: 400 v: CD
k: 100 v: C
k: 90 v: XC
k: 50 v: L
k: 10 v: X
k: 9 v: IX
k: 1 v: I

Est-il possible de les imprimer dans l'ordre de la taille de la clé, j'aimerais donc parcourir cette carte en boucle

k:1
K:4
K:5
K:9
k:10

etc...

Merci beaucoup pour votre aide!

go
22
samol

Rassemblez toutes les clés, triez-les et parcourez votre carte par clé, comme suit:

keys := make([]int, 0)
for k, _ := range romanNumeralDict {
    keys = append(keys, k)
}
sort.Ints(keys)
for _, k := range keys {
    fmt.Println(k, romanNumeralDict[k])
}
41
Volker

Vous pouvez le rendre un peu plus rapide en préallouant keys car vous en connaissez la longueur:

func sortedKeys(m map[Key]Value) ([]Key) {
        keys := make([]Key, len(m))
        i := 0
        for k := range m {
            keys[i] = k
            i++
        }
        sort.Keys(keys)
        return keys
}

Remplacez Key et Value par vos types de clé et de valeur (y compris la ligne sort). toux génériques toux

8
Timmmm

Imprimez simplement la carte. Toutes les réponses ici contiennent maintenant l'ancien comportement des cartes. Dans Go 1.12+, vous pouvez simplement imprimer une valeur de carte qui sera triée par clé automatiquement. Ceci a été ajouté car il permet de tester facilement les valeurs de la carte.

func main() {
    m := map[int]int{3: 5, 2: 4, 1: 3}
    fmt.Println(m)

    // In Go 1.12+
    // Output: map[1:3 2:4 3:5]

    // Before Go 1.12 (the order was undefined)
    // map[3:5 2:4 1:3]
}

Les cartes sont maintenant imprimées dans un ordre de clé pour faciliter les tests. Les règles de commande sont les suivantes:

  • Le cas échéant, rien ne se compare
  • commande ints, floats, and strings by <
  • NaN compare moins que les flotteurs non-NaN
  • bool compare false avant true
  • Complexe compare réel, puis imaginaire
  • Pointeurs comparés par adresse machine
  • Les valeurs de canal comparent par adresse machine
  • Les structures comparent chaque champ
  • Les tableaux comparent chaque élément
  • Les valeurs d'interface comparent d'abord par reflect.Type décrivant le type concret, puis par valeur concrète, comme décrit dans les règles précédentes.

Lors de l’impression de cartes, les valeurs de clé non réflexives telles que NaN étaient précédemment affichées sous la forme. À partir de cette version, les valeurs correctes sont imprimées.

En savoir plus ici.

0
Inanc Gumus