Comment parcourir efficacement le JSON imbriqué dans Go ?

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

Considérez le scénario dans lequel vous rencontrez une structure JSON imbriquée comme celle illustrée ci-dessous :

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

La tâche consiste à parcourir efficacement cette structure et à récupérer toutes les paires clé-valeur sous forme de chaînes pour un traitement ultérieur. Malheureusement, définir manuellement une structure pour une entrée JSON aussi dynamique n'est pas réalisable.

Approche itérative efficace

Pour relever ce défi efficacement, une approche récursive est utilisée :

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

Cette fonction récursive parseMap examine le type de chaque valeur de la carte. Si la valeur est elle-même une carte, elle appelle récursivement parseMap pour parcourir cette carte imbriquée. Si la valeur est un tableau, il appelle parseArray pour la parcourir. Pour tous les autres types (tels que les chaînes, les nombres, etc.), il imprime simplement la clé et la valeur sous forme de chaîne.

Démo

Considérez l'exemple d'entrée JSON fourni précédemment. L'exécution du code ci-dessous produira le résultat suivant :

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"
    }
}
`

Sortie :

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

Cette approche capture efficacement toutes les paires clé-valeur dans le JSON imbriqué, ce qui le rend adapté au traitement et tâches d'extraction en langage Go.

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!