Golang高性能无结构JSON解析与转换插件库ujson的使用

ujson是一个快速、极简的JSON解析器和转换器，可以直接处理无结构的JSON数据。它通过解析输入并在遇到每个项时调用给定的回调函数来工作。

动机

有时我们只想对JSON文档进行最小更改，或者在不完全解组的情况下进行一些通用转换。例如，从响应JSON中移除黑名单字段。为什么要花费所有成本将JSON解组到map[string]interface{}中，然后再立即重新编组呢？

使用示例

1. 按顺序打印所有键和值

input := []byte(`{  
    "id": 12345,    
    "name": "foo",  
    "numbers": ["one", "two"],  
    "tags": {"color": "red", "priority": "high"},   
    "active": true  
}`)

ujson.Walk(input, func(level int, key, value []byte) bool {
    fmt.Printf("%2v% 12s : %s\n", level, key, value)
    return true
})

输出结果：

2. 重新格式化输入

input := []byte(`{"id":12345,"name":"foo","numbers":["one","two"],"tags":{"color":"red","priority":"high"},"active":true}`)

b := make([]byte, 0, 1024)
err := ujson.Walk(input, func(level int, key, value []byte) bool {
    if len(b) != 0 && ujson.ShouldAddComma(value, b[len(b)-1]) {
        b = append(b, ',')
    }
    b = append(b, '\n')
    for i := 0; i < level; i++ {
        b = append(b, '\t')
    }
    if len(key) > 0 {
        b = append(b, key...)
        b = append(b, ':')
    }
    b = append(b, value...)
    return true
})
if err != nil {
    panic(err)
}
fmt.Printf("%s\n", b)

输出结果：

{
    "id":12345,
    "name":"foo",
    "numbers":[
        "one",
        "two"
    ],
    "tags":{
        "color":"red",
        "priority":"high"
    },
    "active":true
}

3. 移除黑名单字段

input := []byte(`{
    "id": 12345,
    "name": "foo",
    "numbers": ["one", "two"],
    "tags": {"color": "red", "priority": "high"},
    "active": true
}`)

blacklistFields := [][]byte{
    []byte(`"numbers"`), // 注意引号
    []byte(`"active"`),
}
b := make([]byte, 0, 1024)
err := ujson.Walk(input, func(_ int, key, value []byte) bool {
    for _, blacklist := range blacklistFields {
        if bytes.Equal(key, blacklist) {
            // 从输出中移除键和值
            return false
        }
    }

    // 写入输出
    if len(b) != 0 && ujson.ShouldAddComma(value, b[len(b)-1]) {
        b = append(b, ',')
    }
    if len(key) > 0 {
        b = append(b, key...)
        b = append(b, ':')
    }
    b = append(b, value...)
    return true
})
if err != nil {
    panic(err)
}
fmt.Printf("%s\n", b)

输出结果：

{"id":12345,"name":"foo","tags":{"color":"red","priority":"high"}}

4. 将int64包装为字符串

input := []byte(`{"order_id": 12345678901234, "number": 12, "item_id": 12345678905678, "counting": [1,"2",3]}`)

suffix := []byte(`_id"`) // 注意结尾的引号"
b := make([]byte, 0, 256)
err := ujson.Walk(input, func(_ int, key, value []byte) bool {
    // 测试键是否以_id"结尾且值为int64数字
    shouldWrap := bytes.HasSuffix(key, suffix) && value[0] > '0' && value[0] <= '9'

    // 转换输入，将值用双引号包裹
    if len(b) != 0 && ujson.ShouldAddComma(value, b[len(b)-1]) {
        b = append(b, ',')
    }
    if len(key) > 0 {
        b = append(b, key...)
        b = append(b, ':')
    }
    if shouldWrap {
        b = append(b, '"')
    }
    b = append(b, value...)
    if shouldWrap {
        b = append(b, '"')
    }
    return true
})
if err != nil {
    panic(err)
}
fmt.Printf("%s\n", b)

输出结果：

{"order_id":"12345678901234","number":12,"item_id":"12345678905678","counting":[1,"2",3]}

注意事项

重要提示：对于无效的JSON，行为是未定义的。仅在受信任的输入上使用。对于不受信任的输入，你可能希望首先通过json.Valid()运行它。

替代方案

👉 查看新的库iter.json，它使用Go1.23迭代器语法来迭代无结构JSON 👈

package main

import "ezpkg.io/iter.json"

func main() {
    data := `{"id": 12345, "name": "foo", "numbers": ["one", "two"]}`
    // 👇 使用Go1.23迭代器语法迭代JSON
    for item, err := range iterjson.Parse([]byte(data)) {
        if err != nil { panic(err) }
        println(item.GetPathString(), item.Key, item.Token, item.Level)
    }
}

许可证

MIT