Comment puis-je parcourir une carte Go dans un ordre spécifique ?

Itération ordonnée des cartes Go : un guide complet

Parcourir une carte Go dans l'ordre peut être un défi en raison du langage utilisé, qui met l'accent sur la concurrence plutôt que sur la préservation de l'ordre. Cet article explorera deux méthodes solides pour réaliser une itération ordonnée tout en conservant les avantages de l'utilisation de cartes.

1. Maintenir l'ordre avec une tranche de clés

Cette méthode consiste à garder une trace des clés de carte dans une tranche séparée pour garantir l'ordre d'itération. Tout en introduisant une surcharge, cette approche offre une simplicité et une mise en œuvre claire.

• Key Wrap : Pour chaque clé insérée dans la carte, vérifiez si elle existe dans la tranche de clé. Sinon, ajoutez la clé à la tranche.
• Utilisation de la tranche : Pendant l'itération, utilisez la tranche clé pour accéder aux valeurs correspondantes dans la carte.
• Maintien de la synchronisation : Supprimez les clés de la tranche lorsque les valeurs correspondantes sont supprimées de la map.

Exemple de mise en œuvre :

type Key int   // Key type
type Value int // Value type

type Map struct {
    m    map[Key]Value
    keys []Key
}

func New() *Map {
    return &Map{m: make(map[Key]Value)}
}

func (m *Map) Set(k Key, v Value) {
    if _, ok := m.m[k]; !ok {
        m.keys = append(m.keys, k)
    }
    m.m[k] = v
}

func (m *Map) Range() {
    for _, k := range m.keys {
        fmt.Println(m.m[k])
    }
}

2. Lier des valeurs dans une LinkedList

Cette approche consiste à envelopper les valeurs dans une structure contenant la valeur réelle et une référence à la clé suivante. Il permet une insertion et une suppression efficaces d'éléments.

• Value Wrapper : Définissez une structure de wrapper de valeur avec une valeur et une référence à la clé suivante.
• Insertion de carte : Définissez le wrapper de valeur comme valeur de la clé dans le map.
• Mécanisme de liaison : Liez le nouveau wrapper au précédent pour maintenir l'ordre d'insertion.
• Itération : Démarrer l'itération à partir de la première clé et suivez les références suivantes pour accéder aux valeurs dans l'ordre d'insertion.

Exemple Mise en œuvre :

type Key int   // Key type
type Value int // Value type

type valueWrapper struct {
    value Value
    next  *Key // Next key
}

type Map struct {
    m           map[Key]valueWrapper
    first, last *Key
}

func New() *Map {
    return &Map{m: make(map[Key]valueWrapper)}
}

func (m *Map) Set(k Key, v Value) {
    if _, ok := m.m[k]; !ok && m.last != nil {
        w2 := m.m[*m.last]
        m.m[*m.last] = valueWrapper{w2.value, &k}
    }
    w := valueWrapper{value: v}
    m.m[k] = w
    if m.first == nil {
        m.first = &k
    }
    m.last = &k
}

func (m *Map) Range() {
    for k := m.first; k != nil; {
        w := m.m[*k]
        fmt.Println(w.value)
        k = w.next
    }
}

Bonus :

Voici quelques conseils supplémentaires à prendre en compte :

• Mise en œuvre de la carte : Pensez à créer un type personnalisé qui enveloppe la carte et fournit les méthodes nécessaires pour la commande itération.
• Optimisation : Explorez toujours les optimisations pour réduire les frais généraux et améliorer les performances.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!