处理json数据的格式化和生成动态结构

本篇文章主要是结合我之前面试的各种经历和实战开发中遇到的问题解决经验整理的，希望这篇《处理json数据的格式化和生成动态结构》对你有很大帮助！欢迎收藏，分享给更多的需要的朋友学习~

{
  "type": "object",
  "properties": {
    "firstname": {
      "type": "string",
      "title": "first name",
      "default": "chuck"
    },
    "lastname": {
      "type": "string",
      "title": "last name"
    },
    "telephone": {
      "type": "string",
      "title": "telephone",
      "minlength": 10
    }
  }
}

我想构造上图所示的数据并发送给前端渲染。它必须包含类型和属性字段。属性中的字段是核心数据。

//testmap is a map. key is variable name , value is value
    testmap := drawvaluenamefrompareselffile(testpath)

    marshal, _ := json.marshalindent(testmap, "", " ")

    res := string(marshal)
    helper.ok(c, res)

type resp struct {
    code    errcode.code `json:"code" binding:"required"`
    message string       `json:"message" binding:"required"`
    data    interface{}  `json:"data" binding:"required"`
}

// ok
func ok(c *gin.context, data interface{}) {
    c.json(http.statusok, resp{
        code: errcode.errnone,
        data: data,
    })
}

但这就是我的结果

{
    "code": 0,
    "message": "",
    "data": "{\n  \"title\": \"product set\",\n  \"type\": \"object\",\n  \"properties\": {\n      \"id\": {\n        \"type\": \"number\"\n      },\n      \"name\": {\n        \"type\": \"string\"\n      },\n      \"price\": {\n        \"type\": \"number\"\n      },\n      \"dimensions\": {\n        \"type\": \"object\",\n        \"properties\": {\n          \"length\": {\n            \"type\": \"number\"\n          },\n          \"width\": {\n            \"type\": \"number\"\n          },\n          \"height\": {\n            \"type\": \"number\"\n          }\n        }\n      },\n      \"warehouselocation\": {\n        \"type\": \"object\",\n        \"properties\": {\n          \"latitude\": {\n            \"type\": \"number\"\n          },\n          \"longitude\": {\n            \"type\": \"number\"\n          }\n        }\n      }\n    }\n}\n"
}

有换行符和转义字符。 我尝试使用映射构建结构，但我对大小写转换和嵌套结构感到恼火

这是我目前使用的方法。但解析json时，无法将其改为小写字母。前端需要小写字母

package main


import (
    "errors"
    "reflect"
    "fmt"
)
// 构造器
type Builder struct {
    // 用于存储属性字段
    fileId []reflect.StructField
}

func NewBuilder() *Builder {
    return &Builder{}
}
// 添加字段
func (b *Builder)AddField(field string,typ reflect.Type) *Builder {
    b.fileId = append(b.fileId,reflect.StructField{Name: field,Type: typ})
    return b
}
// 根据预先添加的字段构建出结构体
func (b *Builder)Build() *Struct {
    stu := reflect.StructOf(b.fileId)
    index := make(map[string]int)
    for i := 0; i < stu.NumField(); i++ {
        index[stu.Field(i).Name] = i
    }
    return &Struct{stu,index}
}
func (b *Builder) AddString(name string) *Builder {
    return b.AddField(name, reflect.TypeOf(""))
}

func (b *Builder) AddBool(name string) *Builder {
    return b.AddField(name, reflect.TypeOf(true))
}

func (b *Builder) AddInt64(name string) *Builder {
    return b.AddField(name, reflect.TypeOf(int64(0)))
}

func (b *Builder) AddFloat64(name string) *Builder {
    return b.AddField(name, reflect.TypeOf(float64(1.2)))
}

func (b *Builder) AddStruct(name string) *Builder {
    // type T struct { a, b int }
    tmp := make(map[string]string)
    tmp["test"] = "test"
    return b.AddField(name, reflect.TypeOf(tmp))
}

// 实际生成的结构体，基类
// 结构体的类型
type Struct struct {
    typ reflect.Type
    // <fieldName : 索引> // 用于通过字段名称，从Builder的[]reflect.StructField中获取reflect.StructField
    index map[string]int
}

func (s Struct)New() *Instance {
    return &Instance{reflect.New(s.typ).Elem(),s.index}
}
// 结构体的值
type Instance struct {
    instance reflect.Value
    // <fieldName : 索引>
    index map[string]int
}
var (
    FieldNoExist error = errors.New("field no exist")
)
func (in Instance)Field(name string) (reflect.Value,error) {
    if i,ok := in.index[name];ok{
        return in.instance.Field(i),nil
    }else {
        return reflect.Value{},FieldNoExist
    }
}



func (in *Instance) SetStruct(name string, resp map[string]string) {
    if i,ok := in.index[name];ok{
        for k ,v := range resp {
            // value, _ :=v.(string)
            fmt.Println(reflect.ValueOf(k))
            fmt.Println(reflect.ValueOf(v))
            // in.instance.Field(i).SetString("test")
            in.instance.Field(i).Set(reflect.ValueOf(resp))
        }

        
    }
}


func (in *Instance) SetString(name, value string) {
    if i,ok := in.index[name];ok{
        in.instance.Field(i).SetString(value)
    }
}

func (in *Instance) SetBool(name string, value bool) {
    if i,ok := in.index[name];ok{
        in.instance.Field(i).SetBool(value)
    }
}

func (in *Instance) SetInt64(name string, value int64) {
    if i,ok := in.index[name];ok{
        in.instance.Field(i).SetInt(value)
    }
}

func (in *Instance) SetFloat64(name string, value float64) {
    if i,ok := in.index[name];ok{
        in.instance.Field(i).SetFloat(value)
    }
}
func (i *Instance) Interface() interface{} {
    return i.instance.Interface()
}

func (i *Instance) Addr() interface{} {
    return i.instance.Addr().Interface()
}



func main() {
    pe := NewBuilder().
        AddString("Name").
        AddInt64("Age").
        AddStruct("Typet").
        Build()
    p := pe.New()
    p.SetString("Name","你好")
    p.SetInt64("Age",32)
    fmt.Printf("%T\n",p)
    fmt.Printf("%T\n",p.Interface())
    fmt.Printf("%+v\n",p.Interface())
    fmt.Printf("%T\n",p.Addr())
    fmt.Printf("%+v\n",p.Addr())




    tmp := make(map[string]string)

    tmp["type1"] = "object1"
    tmp["type2"] = "object2"
    tmp["type3"] = "object3"


    p.SetStruct("Typet",tmp)


    fmt.Printf("%T\n",p)
    fmt.Printf("%T\n",p.Interface())
    fmt.Printf("%+v\n",p.Interface())
    fmt.Printf("%T\n",p.Addr())
    fmt.Printf("%+v\n",p.Addr())
}

正确答案

您需要对动态字段使用 map。

真正的动态数据可以存储在 map[string]interface{}

对于有限数量的字段，您可以使用强类型：

type Response struct {
    Type       string              `json:"type"`
    Properties map[string]RespProp `json:"properties"`
}

type RespProp struct {
    Type      string `json:"type"`
    Title     string `json:"title"`
    Default   string `json:"default,omitempty"`
    MinLength int    `json:"minLength,omitempty"`
}

https://go.dev/play/p/W8mpg7HvCwM

今天带大家了解了的相关知识，希望对你有所帮助；关于Golang的技术知识我们会一点点深入介绍，欢迎大家关注golang学习网公众号，一起学习编程~