Golang中如何使用嵌套结构递归构建嵌套的JSON/对象

本篇文章主要是结合我之前面试的各种经历和实战开发中遇到的问题解决经验整理的，希望这篇《Golang中如何使用嵌套结构递归构建嵌套的JSON/对象》对你有很大帮助！欢迎收藏，分享给更多的需要的朋友学习~

如何使用以下结构递归构建嵌套 json？

嵌套结构可以达到尽可能多的级别。

下面提到了示例结构和 json。

我在动态构建嵌套 json/对象时遇到问题。

我使用反射包来访问该结构。

我能够读取数据，但无法构建相同的数据。

致：

{
  "name":"data",
  "fields":[{
    "name":"id",
    "type":"string"
  },
  {
    "name":"name",
    "type":"string"
  },
  {
    "name":"details",
    "type":"struct",
    "fields":[{
      "name":"customer",
      "type":"int32"
    },{
      "name":"countries",
      "type":"int32"
    }]
}

无论我到目前为止做了什么，我都附在下面：

package main

import (
    "encoding/json"
    "fmt"
    "reflect"
)

func check(e error) {
    if e != nil {
        panic(e)
    }
}

func getFields(t reflect.Type, prefix string) {
    switch t.Kind() {
    case reflect.Ptr:
        getFields(t.Elem(), "")
    case reflect.Struct:
        buildRecursiveFunction(t)
    }
}

func buildRecursiveFunction(t reflect.Type) map[string]interface{} {
    var jsonArr []interface{}
    temp := make(map[string]interface{})
    for i := 0; i < t.NumField(); i++ {
        sf := t.Field(i)
        if sf.Name != "state" && sf.Name != "unknownFields" && sf.Name != "sizeCache" {
            obj := make(map[string]interface{})
            varName := sf.Name
            varType := sf.Type.Kind()
            obj["Name"] = varName
            obj["Type"] = varType.String()

            if varType.String() == "ptr" {
                obj["Fields"] = buildRecursiveFunction(sf.Type.Elem())
            } else {
            }
            jsonArr = append(jsonArr, obj)
        }
    }
    jsonArrVal, _ := json.Marshal(jsonArr)
    fmt.Println(string(jsonArrVal))
    return temp

}

func main() {
    getFields(reflect.TypeOf(&DeviceEnv{}), "")
    // json.Marshal(AllAttributes)
}

感谢任何帮助。

正确答案

我已经破解了你的代码并让它（有点）工作here，但它似乎不是以最好的方式构建的。返回并构建一个递归对象比尝试打印它（带有前缀？）更好。

定义一个 typeinfo 结构并使用一个递归函数来填充该结构怎么样？我认为这会产生一个清晰的结构，并且允许调用者按照自己的意愿对结果进行 json 编组：

func main() {
    info := MakeTypeInfo("DeviceEnvironment", DeviceEnv{})
    b, err := json.MarshalIndent(info, "", "  ")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("%s\n", b)
}

type TypeInfo struct {
    Name   string     `json:"Name"`
    Type   string     `json:"Type"`
    Fields []TypeInfo `json:"Fields,omitempty"`
}

func MakeTypeInfo(name string, value interface{}) TypeInfo {
    return makeTypeInfo(name, reflect.TypeOf(value))
}

func makeTypeInfo(name string, t reflect.Type) TypeInfo {
    kind := t.Kind()
    switch kind {
    case reflect.Struct:
        var fields []TypeInfo
        for i := 0; i < t.NumField(); i++ {
            field := t.Field(i)
            fields = append(fields, makeTypeInfo(field.Name, field.Type))
        }
        return TypeInfo{Name: name, Type: kind.String(), Fields: fields}
    case reflect.Pointer:
        return makeTypeInfo(name, t.Elem())
    default:
        return TypeInfo{Name: name, Type: kind.String()}
    }
}

请注意，我还没有完成您在代码中显示的字段过滤（例如：“unknownfields”）——不过，在 reflect.struct 案例中添加应该不难。

Full example in Go Playground.

以上就是《Golang中如何使用嵌套结构递归构建嵌套的JSON/对象》的详细内容，更多关于的资料请关注golang学习网公众号！