Golang解组JSON响应，然后将字段名称转换为snake_case

一分耕耘，一分收获！既然打开了这篇文章《Golang解组JSON响应，然后将字段名称转换为snake_case》，就坚持看下去吧！文中内容包含等等知识点...希望你能在阅读本文后，能真真实实学到知识或者帮你解决心中的疑惑，也欢迎大佬或者新人朋友们多留言评论，多给建议！谢谢！

我想获取带有 json 标签的数据，其源为 pascalcase 格式，并将其保存到我的数据库中。但在进入数据库之前，我想将pascalcase格式更改为snake_case格式。

我的问题似乎与这个问题相反（golang unmarshal an json response, then marshal with struct 字段名称）。但我不想在名称字段中使用 pascalcase，而是使用 snake_case

这是我编写的示例代码：

package main

import (
    "encoding/json"
    "log"
)

// models data to save in db
type (
    person struct {
        firstname string      `json:"firstname"`
        lastname  string      `json:"lastname"`
        children  []childdata `json:"children,omitempty"`
    }
    childdata struct {
        childname string `json:"childname"`
        age       int    `json:"age"`
        favcolor  string `json:"favcolor"`
    }
    personout struct {
        firstname string      `json:"first_name"`
        lastname  string      `json:"last_name"`
        children  []childdata `json:"children,omitempty"`
    }
    childdataout struct {
        childname string `json:"child_name"`
        age       int    `json:"age"`
        favcolor  string `json:"fav_color"`
    }
)

// grisha is data from fetch api
var grisha = map[string]interface{}{
    "firstname": "grisha",
    "lastname":  "jeager",
    "children": []map[string]interface{}{
        {
            "childname": "zeke",
            "age":       2,
            "favcolor":  "blue",
        }, {
            "childname": "eren",
            "age":       3,
            "favcolor":  "red",
        },
    },
}

func getjsonfromapi(data map[string]interface{}) []byte {
    grishajson, _ := json.marshalindent(grisha, "", "    ")
    return grishajson
}

func parsingjson(jsoninput []byte) {
    var person person
    json.unmarshal(jsoninput, &person)

    out := personout(person)
    payload2, err := json.marshalindent(out, "", "    ")
    if err != nil {
        panic(err)
    }
    log.println(string(payload2))
}

func main() {
    data := getjsonfromapi(grisha)
    parsingjson(data)
}

我想要的结果是这样的

{
    "first_name": "grisha",
    "last_name": "jeager",
    "children": [
        {
            "child_name": "zeke",
            "age": 2,
            "fav_color": "blue"
        },
        {
            "child_name": "eren",
            "age": 3,
            "fav_color": "red"
        }
    ]
}

但结果在嵌套字段中仍然包含 pascalcase：

{
    "first_name": "Grisha",
    "last_name": "Jeager",
    "children": [
        {
            "ChildName": "Zeke",
            "Age": 2,
            "FavColor": "blue"
        },
        {
            "ChildName": "Eren",
            "Age": 3,
            "FavColor": "red"
        }
    ]
}

我想知道如何从 unmarshal json 转换嵌套结构的字段名称。

正确答案

只有当它们的基础类型（忽略标签）相同时，将一个结构转换为另一个结构才有效。如果基础类型不相同，则无法进行转换。

以结构体 s1 和 s2 为例，在下面的代码片段中，它们的底层类型是相同的，您可以将其中一种转换为另一种：

type s1 struct {
    field t1
}
type s2 struct {
    field t1
}
type t1 string

_ = s2(s1{}) // ok

但是，在下一个代码片段中，它们的底层类型并不相同，因此您无法将其中一个转换为另一个：

type s1 struct {
    field t1
}
type s2 struct {
    field t2
}
type t1 string
type t2 string

_ = s2(s1{}) // cannot convert s1{} (value of type s1) to type s2

有关更多详细信息，请阅读此处的转换规范：https://go.dev/ref/spec#Conversions

因此，要在底层类型不相同的两个结构之间进行转换，您必须手动逐个字段进行转换。但是，在 json 封送处理的情况下，您可以通过实现 json.marshaler 接口并使各个实例“自行转换”来使其变得更好。

type person struct {
    firstname string      `json:"firstname"`
    lastname  string      `json:"lastname"`
    children  []childdata `json:"children"`
}

func (p person) marshaljson() ([]byte, error) {
    type t struct {
        firstname string      `json:"first_name"`
        lastname  string      `json:"last_name"`
        children  []childdata `json:"children"`
    }

    return json.marshal(t(p))
}

type childdata struct {
    childname string `json:"childname"`
    age       int    `json:"age"`
    favcolor  string `json:"favcolor"`
}

func (d childdata) marshaljson() ([]byte, error) {
    type t struct {
        childname string `json:"child_name"`
        age       int    `json:"age"`
        favcolor  string `json:"fav_color"`
    }

    return json.marshal(t(d))
}

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

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

我们需要：

1. 将 person 映射到 personout
2. 将 childdata 映射到 childdataout

func childDataToChildDataOut(childData ChildData) ChildDataOut {
    return ChildDataOut{
        ChildName: childData.ChildName,
        Age:       childData.Age,
        FavColor:  childData.FavColor,
    }
}

func personToPersonOut(person Person) PersonOut {
    var children []ChildDataOut

    for _, childData := range person.Children {
        childDataOut := childDataToChildDataOut(childData)
        children = append(children, childDataOut)
    }

    return PersonOut{
        FirstName: person.FirstName,
        LastName:  person.LastName,
        Children:  children,
    }
}

本篇关于《Golang解组JSON响应，然后将字段名称转换为snake_case》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于Golang的相关知识，请关注golang学习网公众号！