Wie kann man verschachteltes JSON in Go effizient durchlaufen?

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

Stellen Sie sich das Szenario vor, in dem Sie auf eine verschachtelte JSON-Struktur wie die unten dargestellte stoßen:

{
    "outterJSON": {
        "innerJSON1": {
            "value1": 10,
            "value2": 22,
            "InnerInnerArray": [ "test1" , "test2"],
            "InnerInnerJSONArray": [ {"fld1" : "val1"} , {"fld2" : "val2"} ]
        },
        "InnerJSON2":"NoneValue"
    }
}

Die Aufgabe besteht darin, diese Struktur effektiv zu durchlaufen und alle Schlüssel-Wert-Paare als Zeichenfolgen für die weitere Verarbeitung abzurufen. Leider ist es nicht möglich, eine Struktur für eine solche dynamische JSON-Eingabe manuell zu definieren.

Effizienter Iterationsansatz

Um diese Herausforderung effizient zu meistern, wird ein rekursiver Ansatz verwendet:

func parseMap(m map[string]interface{}) {
  for key, val := range m {
    // Check the type of the value
    switch concreteVal := val.(type) {
      case map[string]interface{}:
        // If it's a nested map, recursively call the function
        parseMap(val.(map[string]interface{}))
      case []interface{}:
        // If it's a nested array, call the function to parse the array
        parseArray(val.([]interface{}))
      default:
        // For all other types, print the key and value as a string
        fmt.Println(key, ":", concreteVal)
    }
  }
}

Diese rekursive Funktion parseMap untersucht den Typ jedes Werts in der Karte. Wenn der Wert selbst eine Karte ist, ruft er rekursiv parseMap auf, um diese verschachtelte Karte zu durchlaufen. Wenn der Wert ein Array ist, wird parseArray aufgerufen, um darüber zu iterieren. Für alle anderen Typen (z. B. Zeichenfolgen, Zahlen usw.) werden der Schlüssel und der Wert einfach als Zeichenfolge ausgegeben.

Demo

Bedenken Sie die zuvor bereitgestellte Beispiel-JSON-Eingabe. Wenn Sie den folgenden Code ausführen, wird die folgende Ausgabe erzeugt:

func parseArray(a []interface{}) {
  for i, val := range a {
    // Check the type of the value
    switch concreteVal := val.(type) {
      case map[string]interface{}:
        // If it's a nested map, recursively call the function
        parseMap(val.(map[string]interface{}))
      case []interface{}:
        // If it's a nested array, call the function to parse the array
        parseArray(val.([]interface{}))
      default:
        // For all other types, print the index and value as a string
        fmt.Println("Index:", i, ":", concreteVal)
    }
  }
}

const input = `
{
    "outterJSON": {
        "innerJSON1": {
            "value1": 10,
            "value2": 22,
            "InnerInnerArray": [ "test1" , "test2"],
            "InnerInnerJSONArray": [{"fld1" : "val1"} , {"fld2" : "val2"}]
        },
        "InnerJSON2":"NoneValue"
    }
}
`

Ausgabe:

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

Dieser Ansatz erfasst effektiv alle Schlüssel-Wert-Paare innerhalb des verschachtelten JSON, sodass es für die Verarbeitung geeignet ist Extraktionsaufgaben in Go-Sprache.

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