Comment parcourir efficacement le JSON imbriqué de deuxième niveau dans Go ?

Boucle/itération sur un JSON imbriqué de deuxième niveau dans Go

Cette question implique une itération à travers une structure JSON imbriquée complexe dans Go, en se concentrant spécifiquement au deuxième niveau de nidification. L'entrée JSON contient plusieurs niveaux d'objets et de tableaux imbriqués, et la tâche consiste à accéder et à traiter les paires clé-valeur au sein de ces structures imbriquées.

Analyse du JSON et de la boucle initiale

Le code fourni utilise le package encoding/json pour analyser l'entrée JSON dans un objet map[string]interface{}. Cette carte représente le niveau supérieur de la hiérarchie JSON. À l'aide d'une boucle range`, il parcourt les paires clé-valeur de premier niveau de la carte.

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

Itération sur le deuxième niveau : personnalisation

Dans le boucle de premier niveau, le code cherche à parcourir les objets JSON imbriqués de deuxième niveau, tels que innerJSON1 et InnerJSON2. Pour y parvenir, la valeur d'interface{} de chaque clé de premier niveau doit être vérifiée et traitée en conséquence.

Le moyen efficace de gérer cela consiste à utiliser l'assertion de type, en utilisant des commutateurs de type pour déterminer le type de l'interface{ } valeur. En appelant de manière récursive les fonctions parseMap ou parseArray pour des cartes ou des tableaux imbriqués, le code peut explorer de manière itérative tous les niveaux de la structure JSON.

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

Exemple de sortie

Basé sur le JSON d'entrée fourni, le code imprimera les paires clé-valeur du deuxième niveau de imbrication :

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

Considérations supplémentaires

• Le code fourni suppose que la structure JSON est bien formée et ne gère pas les entrées JSON non valides.
• L'utilisation de la réflexion de type (interface{}) peut ajouter une surcharge au programme par rapport à l'utilisation de structures typées pour du JSON connu structures.
• Pour des structures JSON plus complexes ou une optimisation des performances, pensez à utiliser json.Decoder de Go et à naviguer manuellement dans la hiérarchie JSON.

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!