How Can I Iterate Over a Go Map in Insertion Order?

Iterating Maps in Insertion Order

Go maps do not guarantee iteration order, making it challenging to retrieve map items in the order they were inserted. To address this, consider the following approaches:

Using a Keys Slice

Maintain a separate slice to track keys in insertion order. Whenever you add a key-value pair to the map, check if the key exists in the slice. If not, add it. When iterating over the map, use the keys slice to access items.

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

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

Using a Linked-List Value Wrapper

Wrap map values with a data structure that stores the value and a pointer to the next key in insertion order. Whenever you add a key-value pair, update the next pointer of the previous value wrapper. To iterate in insertion order, start with the first key and follow the next pointers.

type valueWrapper struct {
    value Value
    next *Key
}

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

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.v, &k}
    }
    w := valueWrapper{v: 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.v)
        k = w.next
    }
}

These solutions address the need for maintaining insertion order while preserving the map's benefits. By separating key tracking from map operations, or linking values in order, you can reliably iterate over maps in the desired sequence.

The above is the detailed content of How Can I Iterate Over a Go Map in Insertion Order?. For more information, please follow other related articles on the PHP Chinese website!