dp13668681869
2017-09-25 12:43 阅读 215

将扁平化的json转换为嵌套的json

Currently I'm using the following code to convert nested json into flattened json:

import (
    "fmt"

    "github.com/nytlabs/gojsonexplode"
)
func main() {
    input := `{"person":{"name":"Joe", "address":{"street":"123 Main St."}}}`
    out, err := gojsonexplode.Explodejsonstr(input, ".")
    if err != nil {
        // handle error
    }
    fmt.Println(out)
}

This is the output: {"person.address.street":"123 Main St.","person.name":"Joe"}

After some processing, now I want to restore this data into normal nested json, but I'm unable to do so.

My closest guess is usage of nested maps, but I don't know how to create nested map with N levels.

EDIT: Reason why I need this: I'm storing data in Redis, and if I store json into Redis then I can't search for keys, that's why I convert keys into key1:key2:key3: some_value

  • 点赞
  • 写回答
  • 关注问题
  • 收藏
  • 复制链接分享

2条回答 默认 最新

  • 已采纳
    dongxun2089 dongxun2089 2017-09-25 14:17

    In order to "unflatten" the data you need to split each of the keys at the dot and create nested objects. Here is an example with your data on the Go Playground.

    func unflatten(flat map[string]interface{}) (map[string]interface{}, error) {
        unflat := map[string]interface{}{}
    
        for key, value := range flat {
            keyParts := strings.Split(key, ".")
    
            // Walk the keys until we get to a leaf node.
            m := unflat
            for i, k := range keyParts[:len(keyParts)-1] {
                v, exists := m[k]
                if !exists {
                    newMap := map[string]interface{}{}
                    m[k] = newMap
                    m = newMap
                    continue
                }   
    
                innerMap, ok := v.(map[string]interface{})
                if !ok {
                    return nil, fmt.Errorf("key=%v is not an object", strings.Join(keyParts[0:i+1], "."))
                }   
                m = innerMap
            }   
    
            leafKey := keyParts[len(keyParts)-1]
            if _, exists := m[leafKey]; exists {
                return nil, fmt.Errorf("key=%v already exists", key)
            }   
            m[keyParts[len(keyParts)-1]] = value
        }   
    
        return unflat, nil 
    } 
    
    点赞 评论 复制链接分享
  • duaedf6509 duaedf6509 2017-09-25 13:38

    json.MarshalIndent is your friend.

    j, err := json.MarshalIndent(x, "", "\t")
    if err != nil {
        log.Println(err)
    }
    log.Println(string(j))
    

    It will print your data (x) in indented manner.

    点赞 评论 复制链接分享

相关推荐