Wie kann man verschachteltes JSON in GoLang mithilfe der Typzusicherung effizient analysieren?

Schleife über verschachteltes JSON in GoLang

Es besteht die Anforderung, Schlüssel-Wert-Paare aus einer verschachtelten JSON-Struktur für die dynamische Verarbeitung zu extrahieren. Um diese Struktur effizient zu durchlaufen, wird der folgende Ansatz empfohlen:

Typzusicherung mit Bereichsschleife verwenden

Wie in der Antwort angegeben, kann eine Typzusicherung iterativ verwendet werden Auf den Inhalt verschachtelter JSON-Objekte zugreifen und ihn verarbeiten. Der folgende Beispielcode demonstriert diesen Ansatz:

package main

import (
    "encoding/json"
    "fmt"    
)

func main() {
    // Create a map for the JSON data
    m := map[string]interface{}{}
    
    // Unmarshal the JSON input into the map
    err := json.Unmarshal([]byte(input), &m)
    if err != nil {
        panic(err)
    }

    // Recursively parse the map
    parseMap(m)
}

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

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

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

In diesem Code durchlaufen die Funktionen parseMap und parseArray rekursiv die verschachtelte JSON-Struktur und drucken die Schlüssel-Wert-Paare hierarchisch. Dieser Ansatz bietet einen vielseitigen Mechanismus für den Zugriff auf und die Verarbeitung von Daten aus JSON, unabhängig von ihrer Komplexität.

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