将json中的所有snake_case键转换为camel

Question

In Golang, how can we convert snake_case keys in a JSON to camelCase ones recursively?

I am writing one http api in golang. This api fetches data from datastore, does some computation and return the response as JSON.

Situation is that the JSON document in the datastore (elasticsearch) is present with snake_case keys while the API response should be camelCase based (this is just to align with other api standard within project). The source which inserts into ES can't be modified. So its only at the api level keys conversion has to take place.

I have written a struct which is reading JSON from datastore nicely. But how can I convert the keys to camlelCase in golang?

The JSON is can be nested and all keys has to be converted. The JSON is arbitrarily large. i.e. some keys are just mapped to type interface{}

I am also using go's echo framework for writing the api.

Ex.

{
"is_modified" : true,
   { attribute": 
     {
      "legacy_id" : 12345 
     }
   }
}

TO

{
"isModified" : true,
   { attribute": 
     {
      "legacyId" : 12345 
     }
   }
}

Any pointers on how to do this in golang?

Thanks.

Struct:

type data_in_es struct {
IsModified bool `json:"is_modified,omitempty"`
Attribute *attribute `json:"attribute,omitempty"`
}

type attribute struct {
    LegacyId int `json:"legacy_id,omitempty"`
}

Answer 1

Since Go 1.8 you can define two structs that only differ in their tags and trivially convert between the two:

package main

import (
    "encoding/json"
    "fmt"
)

type ESModel struct {
    AB string `json:"a_b"`
}

type APIModel struct {
    AB string `json:"aB"`
}

func main() {
    b := []byte(`{
            "a_b": "c"
    }`)

    var x ESModel
    json.Unmarshal(b, &x)

    b, _ = json.MarshalIndent(APIModel(x), "", "  ")
    fmt.Println(string(b))
}

https://play.golang.org/p/dcBkkX9zQR

To do this generically, attempt to unmarshal the JSON document into a map. If it succeeds, fix all the keys and recursively call your function for each value in the map. The example below shows how to convert all keys to upper case. Replace fixKey with the snake_case conversion function.

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "strings"
)

func main() {
    // Document source as returned by Elasticsearch
    b := json.RawMessage(`{
            "a_b": "c",
            "d_e": ["d"],
            "e_f": {
                    "g_h": {
                            "i_j": "k",
                            "l_m": {}
                    }
            }
    }`)

    x := convertKeys(b)

    buf := &bytes.Buffer{}
    json.Indent(buf, []byte(x), "", "  ")
    fmt.Println(buf.String())
}

func convertKeys(j json.RawMessage) json.RawMessage {
    m := make(map[string]json.RawMessage)
    if err := json.Unmarshal([]byte(j), &m); err != nil {
            // Not a JSON object
            return j
    }

    for k, v := range m {
            fixed := fixKey(k)
            delete(m, k)
            m[fixed] = convertKeys(v)
    }

    b, err := json.Marshal(m)
    if err != nil {
            return j
    }

    return json.RawMessage(b)
}

func fixKey(key string) string {
    return strings.ToUpper(key)
}

https://play.golang.org/p/QQZPMGKrlg