Skip to main content

2 posts tagged with "json"

View All Tags

· 3 min read
wen

背景&需求​

在 Golang 中，我们经常会遇到需要解析 JSON 数据的场景，比如从 HTTP 请求中获取 JSON 数据，或者从文件中读取 JSON 数据。

通常我们会提前定义好对应的结构体，然后才能将 JSON 数据解析到结构体中。

比如：

type User struct {
    Name string `json:"name"`
    Age int `json:"age"`
}

func main() {
    jsonStr := `{"name": "wen", "age": 18}`
    var user User
    json.Unmarshal([]byte(jsonStr), &user)
    fmt.Println(user)
}

但是有时候我们并不知道 JSON 数据的结构，或者 JSON 数据的结构会经常变化，这时候我们就无法提前定义好对应的结构体。

解决方案​

可以使用 map[string]any (Golang1.18 之前的话 map[string]interface{} ) 来解析 JSON 数据，这样就不需要提前定义结构体了。

func main() {
    jsonStr := `{"name": "wen", "age": 18}`
    var user map[string]any
    json.Unmarshal([]byte(jsonStr), &user)
    fmt.Println(user)

    // 获取具体的值
    fmt.Println(user["name"])
    fmt.Println(user["age"])
}

扩展​

如果觉得 map[string]any 这种方式解析速度比较慢，可以使用 jsonparser 这个库来解析，速度会快很多。

我用 User 结构体来测试了一下，解析速度快了 8-9 倍左右 🚀 。

其他的比较大的 JSON 数据，解析速度也会快很多，具体可以看下这里的 benchmark。

NameIterationsns/op
BenchmarkEncodingJsonInterfaceUser-122540230460.6 ns/op
BenchmarkJsonParserUser-122141329655.91 ns/op
查看测试代码
// Just for emulating field access, so it will not throw "evaluated but not used"
func nothing(_ ...interface{}) {}

// 使用 jsonparser
func BenchmarkJsonParserUser(b *testing.B) {
    for i := 0; i < b.N; i++ {
        jsonparser.Get(user, "name")
        jsonparser.Get(user, "age")
        nothing()
    }
}

// 使用 map[string]any
func BenchmarkEncodingJsonInterfaceUser(b *testing.B) {
    for i := 0; i <details b.N; i++ {
        var data interface{}
        json.Unmarshal(user, &data)
        m := data.(map[string]interface{})

        nothing(m["name"].(string), m["age"])
    }
}

· 4 min read
wen

背景​

在使用 Golang 的时候，经常会遇到需要将结构体转换为 JSON 的情况，

但是在转换的时候，JSON 的字段顺序并不是我们想要的，这时候就需要我们自己来指定 JSON 的字段顺序。

解决方案​

一个比较简单的方案是利用结构体的 tag 来指定 JSON 的字段顺序，

然后在转换的时候，将结构体的字段按照 tag 中的顺序进行排序。

type User struct {
    Name  string `json:"name,order:2"`
    Age   int    `json:"age,order:1"`
}

代码实现​

package main

import (
    "encoding/json"
    "fmt"
    "reflect"
    "sort"
    "strconv"
    "strings"

    //orderedmap "github.com/wk8/go-ordered-map/v2"
    "github.com/iancoleman/orderedmap"
)

type User struct {
    Name  string `json:"name,order:3"`
    Age   int    `json:"age,order:2"`
    Score int    `json:"score,order:1"`
}

type Address struct {
    City    string `json:"city,order:10"`
    Street  string `json:"street,order:9"`
    ZipCode string `json:"zip_code,order:8"`
}

func main() {
    user := User{
        Name:  "Wen",
        Age:   30,
        Score: 100,
    }
    address := Address{
        City:    "Hangzhou",
        Street:  "XiHuDaDao",
        ZipCode: "10001",
    }

    // User構造体を指定した順序でJSONに変換
    userJSON, err := MarshalJSONWithOrder(user)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("User JSON:", string(userJSON))

    // Address構造体を指定した順序でJSONに変換
    addressJSON, err := MarshalJSONWithOrder(address)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    fmt.Println("Address JSON:", string(addressJSON))
}

// MarshalJSONWithOrder は構造体を指定した順序でJSONに変換する
// 構造体での指定方法： `json:"{struct field name},order:{integer}"`
// 指定例： `json:"name,order:10"`
func MarshalJSONWithOrder(obj interface{}) ([]byte, error) {
    val := reflect.ValueOf(obj)
    typ := reflect.TypeOf(obj)

    // ソート用のスライス
    var fields []fieldWithOrder

    // フィールドの数だけループ
    for i := 0; i < val.NumField(); i++ {
        fieldName := typ.Field(i).Name

        order := getTagValue(typ.Field(i), "json", "order")
        fields = append(fields, fieldWithOrder{
            Name:  fieldName,
            Order: order,
        })
    }

    // フィールドのソート
    sort.Slice(fields, func(i, j int) bool {
        return fields[i].Order < fields[j].Order
    })

    // ソート後の順序に従ってJSONを生成
    //result := orderedmap.New[string, any]()
    result := orderedmap.New()
    for _, f := range fields {
        //result[f.Name] = val.FieldByName(f.Name).Interface()
        result.Set(f.Name, val.FieldByName(f.Name).Interface())
    }

    // マーシャリング
    return json.Marshal(result)
}

// getTagValue は指定されたフィールドの指定されたタグの値を取得する
func getTagValue(field reflect.StructField, tag string, tagField string) int {
    tagValue, _ := field.Tag.Lookup(tag)

    // Split the tag string by ","
    tagParts := strings.Split(tagValue, ",")

    // Iterate through the tag parts to find the "order" value
    res := -1
    for _, part := range tagParts {
        // Check if the part starts with "order:"
        prefix := fmt.Sprintf("%s:", tagField)
        if strings.HasPrefix(part, prefix) {
            // Extract the numeric value after "order:"
            orderStr := strings.TrimPrefix(part, prefix)
            order, err := strconv.Atoi(orderStr)
            if err == nil {
                res = order
            }
        }
    }

    return res
}

// fieldWithOrder はソート用の構造体
type fieldWithOrder struct {
    Name  string
    Order int
}

NOTE​

  • Ordered Map 的使用

    Golang 中的 map 是无序的，如果需要有序的 map， 可以使用 wk8/go-ordered-map 或者 iancoleman/orderedmap。 由于后者的性能似乎比较好，代码中采用的是后者。

  • ChatGPT 的使用

    代码大部分是用 ChatGPT 生成的，但是生成的代码中有几个问题，例如上面的 Ordered Map，我尝试让 ChatGPT 修改了几次，都没有成功。 最后还是自己手动修改了代码。

    感觉 ChatGPT 对于代码的细节部分的理解还有待改善，而且有时候还胡说八道（现阶段生成式 AI 的通病）。