Go语言json编码驼峰转下划线、下划线转驼峰的实现

要实现Go语言中JSON编码的驼峰转下划线和下划线转驼峰，可以使用Go中的反射(reflect)和标签(tag)进行处理。

驼峰转下划线

驼峰转下划线的实现可以通过如下步骤：

1. 定义一个结构体类型，并在结构体类型的字段上使用 json 标签，设置 json 序列化的键名。

    type Person struct {
        Name      string `json:"name"`
        Age       int    `json:"age"`
        IsMarried bool   `json:"is_married"`
    }

1. 定义一个函数，将结构体的字段名转换成下划线分隔的形式

    func toSnakeCase(s string) string {
        res := strings.Builder{}
        for i, v := range s {
            if unicode.IsUpper(v) {
                if i != 0 {
                    res.WriteRune('_')
                }
                res.WriteRune(unicode.ToLower(v))
            } else {
                res.WriteRune(v)
            }
        }
        return res.String()
    }

1. 使用“反射”来获取结构体的字段指针，并将每个字段的值按照下划线分隔的方式添加到 map[string]interface{} 中。

    func (p Person) ToSnakeCaseMap() map[string]interface{} {
        val := reflect.ValueOf(p)
        typ := reflect.TypeOf(p)

        res := make(map[string]interface{})
        for i := 0; i < typ.NumField(); i++ {
            field := typ.Field(i)

            // Get field name and convert to snake case
            name := field.Tag.Get("json")
            if name == "" {
                name = toSnakeCase(field.Name)
            }

            // Get field value
            value := val.Field(i).Interface()

            res[name] = value
        }

        return res
    }

这样我们就可以将一个结构体转换为下划线分隔的 JSON 字符串了。

下面是转换后的 JSON 示例：

p := Person{Name: "John Doe", Age: 30, IsMarried: true}
b, _ := json.Marshal(p.ToSnakeCaseMap())
fmt.Println(string(b))
// Output: {"name":"John Doe","age":30,"is_married":true}

下划线转驼峰

下划线转驼峰的实现方式与驼峰转下划线相似，步骤如下：

1. 定义一个结构体类型，并在结构体类型的字段上使用 json 标签，设置 json 序列化的键名。

    type Person struct {
        Name      string `json:"name"`
        Age       int    `json:"age"`
        IsMarried bool   `json:"is_married"`
    }

1. 定义一个函数，将下划线分隔的字段名转换成驼峰形式

    func toCamelCase(s string) string {
        res := strings.Builder{}
        words := strings.Split(s, "_")
        for i, word := range words {
            if i == 0 {
                res.WriteString(word)
            } else {
                res.WriteString(strings.Title(word))
            }
        }
        return res.String()
    }

1. 定义一个函数，将 map[string]interface{} 转换成结构体类型

    func (p *Person) FromSnakeCaseMap(m map[string]interface{}) error {
        val := reflect.ValueOf(p).Elem()
        typ := reflect.TypeOf(*p)

        for i := 0; i < typ.NumField(); i++ {
            field := typ.Field(i)
            fVal := val.Field(i)

            // Get JSON name
            name := field.Tag.Get("json")
            if name == "" {
                name = toSnakeCase(field.Name)
            }

            // Get value from map
            v, ok := m[name]
            if !ok {
                continue
            }

            // Set value
            if fVal.Kind() == reflect.Bool {
                fVal.SetBool(v.(bool))
            } else if fVal.Kind() == reflect.Int {
                fVal.SetInt(int64(v.(float64)))
            } else {
                fVal.Set(reflect.ValueOf(v))
            }
        }

        return nil
    }

这样我们就可以将一个下划线分隔的 JSON 字符串转换为驼峰形式的结构体了。

下面是转换后的结构体：

var p Person
jsonStr := `{"name":"John Doe","age":30,"is_married":true}`
json.Unmarshal([]byte(jsonStr), &mp)

fmt.Printf("%+v\n", p)
// Output: {Name:John Doe Age:30 IsMarried:true}