Wie kann man in Go effizient durch verschachteltes JSON der zweiten Ebene iterieren?

Schleifen/Iterieren über verschachteltes JSON der zweiten Ebene in Go

Bei dieser Frage geht es um die Iteration durch eine komplexe verschachtelte JSON-Struktur in Go, wobei der Fokus besonders darauf liegt auf der zweiten Verschachtelungsebene. Die JSON-Eingabe enthält mehrere Ebenen verschachtelter Objekte und Arrays, und die Aufgabe besteht darin, auf die Schlüssel-Wert-Paare innerhalb dieser verschachtelten Strukturen zuzugreifen und sie zu verarbeiten.

Analyse des JSON und der Anfangsschleife

Der bereitgestellte Code verwendet das Paket „encoding/json“, um die JSON-Eingabe in ein Map[string]interface{}-Objekt zu analysieren. Diese Karte stellt die oberste Ebene der JSON-Hierarchie dar. Mithilfe einer Range-Schleife werden die Schlüssel-Wert-Paare der ersten Ebene in der Karte durchlaufen.

for firstLvlkey, firstLvlValue := range m {
    // process first-level key and value...
}

Iterierung über die zweite Ebene: Anpassung

Innerhalb der In der Schleife der ersten Ebene versucht der Code, die verschachtelten JSON-Objekte der zweiten Ebene zu durchlaufen, z. B. innerJSON1 und InnerJSON2. Um dies zu erreichen, muss der Interface{}-Wert jedes Schlüssels der ersten Ebene überprüft und entsprechend verarbeitet werden.

Der effiziente Weg, dies zu handhaben, ist die Typzusicherung, bei der Typschalter verwendet werden, um den Typ der Schnittstelle zu bestimmen{ } Wert. Durch den rekursiven Aufruf der Funktionen parseMap oder parseArray für verschachtelte Karten oder Arrays kann der Code iterativ alle Ebenen der JSON-Struktur erkunden.

func parseMap(aMap map[string]interface{}) {
    for key, val := range aMap {
        switch concreteVal := val.(type) {
            case map[string]interface{}:
                // Nested map
                fmt.Println(key)
                parseMap(val.(map[string]interface{}))
            case []interface{}:
                // Nested array
                fmt.Println(key)
                parseArray(val.([]interface{}))
            default:
                // Primitive value
                fmt.Println(key, ":", concreteVal)
        }
    }
}

func parseArray(anArray []interface{}) {
    for i, val := range anArray {
        switch concreteVal := val.(type) {
            case map[string]interface{}:
                // Nested map
                fmt.Println("Index:", i)
                parseMap(val.(map[string]interface{}))
            case []interface{}:
                // Nested array
                fmt.Println("Index:", i)
                parseArray(val.([]interface{}))
            default:
                // Primitive value
                fmt.Println("Index", i, ":", concreteVal)
        }
    }
}

Beispielausgabe

Basierend Auf dem bereitgestellten Eingabe-JSON druckt der Code die Schlüssel-Wert-Paare aus der zweiten Ebene von Verschachtelung:

InnerInnerJSONArray
Index: 0
fld1 : val1
Index: 1
fld2 : val2
value1 : 10
value2 : 22
InnerInnerArray
Index 0 : test1
Index 1 : test2
InnerJSON2 : NoneValue

Zusätzliche Überlegungen

• Der bereitgestellte Code geht davon aus, dass die JSON-Struktur wohlgeformt ist und keine ungültigen JSON-Eingaben verarbeitet.
• Die Verwendung der Typreflexion (Interface{}) kann im Vergleich zur Verwendung typisierter Strukturen für bekanntes JSON den Mehraufwand für das Programm erhöhen Strukturen.
• Für komplexere JSON-Strukturen oder Leistungsoptimierung sollten Sie den json.Decoder von Go verwenden und manuell durch die JSON-Hierarchie navigieren.

Das obige ist der detaillierte Inhalt vonWie kann man in Go effizient durch verschachteltes JSON der zweiten Ebene iterieren?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!