How to parse/deserialize dynamic JSON

Scenario:
<br/>Consider the following is the JSON :

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

If you notice, the data is structured in such a way that there is no hard-coded keys mentioning City/Temperature its basically just values.

Issue: I am not able to parse any JSON which is dynamic.

Question: Could anyone have found solution for this kind of JSON parsing? I tried go-simplejson, gabs & default encoding/json but no luck.

Note:
The above JSON is just for sample. And there are lot of applications which are using the current API, So I do not want to change how the data is structured. I mean I can't change to something as follows:

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

Then I can define struct

type TempData struct {
  City_Name string
  Temperature  string
}

You can unmarshal into a map[string]string for example:

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

Output (wrapped):

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

Try it on the Go Playground.

This way no matter what the keys or values are, you will have all pairs in a map which you can print or loop over.

Also note that although your example contained only string values, but if the value type is varying (e.g. string, numbers etc.), you may use interface{} for the value type, in which case your map would be of type map[string]interface{}.

Also note that I created a library to easily work with such dynamic objects which may be a great help in these cases: github.com/icza/dyno.

Standard encoding/json is good for the majority of use cases, but it may be quite slow comparing to alternative solutions. If you need performance, try using fastjson. It parses arbitrary JSONs without the need for creating structs or maps matching the JSON schema.

See the example code below. It iterates over all the (key, value) pairs of the JSON object:

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

Just to add a general answer to how any valid JSON can be parsed; var m interface{} works for all types. That includes map (which OP asked for) arrays, strings, numbers and nested structures.

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

Also consider using gabs package https://github.com/Jeffail/gabs

"Gabs is a small utility for dealing with dynamic or unknown JSON structures in Go"