web-dev-qa-db-fra.com

Comment analyser / désérialiser un JSON dynamique

Scénario:
Considérez ce qui suit est le JSON:

{
   "Bangalore_City": "35_Temperature",
   "NewYork_City": "31_Temperature",
   "Copenhagen_City": "29_Temperature"
}

Si vous remarquez, les données sont structurées de telle manière qu'il n'y a pas de clés codées en dur mentionnant City/Temperature ses valeurs fondamentalement justes.

Problème: Je ne suis pas en mesure d'analyser un JSON qui est dynamique.

Question: Quelqu'un aurait-il pu trouver une solution pour ce type d'analyse JSON? J'ai essayé go-simplejson , gabs & default encoding/json mais pas de chance.

Remarque: Le JSON ci-dessus est juste pour l'échantillon. Et il y a beaucoup d'applications qui utilisent l'API actuelle, donc je ne veux pas changer la structure des données. Je veux dire que je ne peux pas changer pour quelque chose comme suit:

[{
   "City_Name":"Bangalore",
   "Temperature": "35"
},...]

Ensuite, je peux définir struct

type TempData struct {
  City_Name string
  Temperature  string
}
jsongo
28
Amol M Kulkarni

Vous pouvez démarshal dans un map[string]string par exemple:

m := map[string]string{}
err := json.Unmarshal([]byte(input), &m)
if err != nil {
    panic(err)
}
fmt.Println(m)

Sortie (enveloppé):

map[Bangalore_City:35_Temperature NewYork_City:31_Temperature
    Copenhagen_City:29_Temperature]

Essayez-le sur le Go Playground .

De cette façon, quelles que soient les clés ou les valeurs, vous aurez toutes les paires dans un map que vous pourrez imprimer ou boucler.

Notez également que bien que votre exemple ne contienne que des valeurs string, mais si le type de valeur varie (par exemple string, nombres, etc.), vous pouvez utiliser interface{} pour le type de valeur, auquel cas votre carte serait de type map[string]interface{}.

Notez également que j'ai créé une bibliothèque pour travailler facilement avec de tels objets dynamiques, ce qui peut être d'une grande aide dans les cas suivants: github.com/icza/dyno .

36
icza

La norme encoding/json est bon pour la majorité des cas d'utilisation, mais il peut être assez lent par rapport aux solutions alternatives. Si vous avez besoin de performances, essayez d'utiliser fastjson . Il analyse des JSON arbitraires sans avoir besoin de créer des structures ou des cartes correspondant au schéma JSON.

Voir l'exemple de code ci-dessous. Il itère sur tous les (key, value) paires de l'objet JSON:

var p fastjson.Parser
v, err := p.Parse(input)
if err != nil {
    log.Fatal(err)
}

// Visit all the items in the top object
v.GetObject().Visit(func(k []byte, v *fastjson.Value) {
    fmt.Printf("key=%s, value=%s\n", k, v)

    // for nested objects call Visit again
    if string(k) == "nested" {
        v.GetObject().Visit(func(k []byte, v *fastjson.Value) {
            fmt.Printf("nested key=%s, value=%s\n", k, v)
        })
    }
})
1
valyala