随笔- 454 文章- 302 评论- 28 阅读- 65万

gjson包
安装使用
go get -u github.com/tidwall/gjson
const json = `{"name":[{"first":"Janet","last":"Prichard"}, {"abc": 1, "e" : 2}],"age":47}`

func main() {

v := gjson.Get(json, "name")

if v.String() == "" {
fmt.Println("nil")
} else {
fmt.Println(v.String())
fmt.Println(v.Type)
}
}
简单的解析和获取
有一个Parse(json)函数可以进行简单的解析，然后result.Get(path)搜索结果。

例如，所有这些都将返回相同的结果

gjson.Parse(json).Get("name").Get("last")
gjson.Get(json, "name").Get("last")
gjson.Get(json, "name.last")
路径匹配
路径是由点分隔的一系列键。密钥可能包含特殊的通配符'*'和'？'。要访问数组值，请使用索引作为键。要获取数组中的元素数或访问子路径，请使用“＃”字符。点和通配符可以使用'\'进行转义

{
"name": {"first": "Tom", "last": "Anderson"},
"age":37,
"children": ["Sara","Alex","Jack"],
"fav.movie": "Deer Hunter",
"friends": [
{"first": "Dale", "last": "Murphy", "age": 44},
{"first": "Roger", "last": "Craig", "age": 68},
{"first": "Jane", "last": "Murphy", "age": 47}
]
}
匹配结果

"name.last" >> "Anderson"
"age" >> 37
"children" >> ["Sara","Alex","Jack"]
"children.#" >> 3
"children.1" >> "Alex"
"child*.2" >> "Jack"
"c?ildren.0" >> "Sara"
"fav\.movie" >> "Deer Hunter"
"friends.#.first" >> ["Dale","Roger","Jane"]
"friends.1.last" >> "Craig"
反向匹配
您还可以使用#[...]或查找所有匹配项来查询第一个匹配项的数组#[...]#。查询支持==，!=，<，<=，>，>=比较运算符和简单模式匹配%（像）和!%选项

friends.#[last=="Murphy"].first >> "Dale"
friends.#[last=="Murphy"]#.first >> ["Dale","Jane"]
friends.#[age>45]#.last >> ["Craig","Murphy"]
friends.#[first%"D*"].last >> "Murphy"
结果类型
GJSON支持JSON类型string，number，bool，和null。数组和对象作为原始json类型返回。

该Result类型包含以下其中一种：

bool, for JSON booleans
float64, for JSON numbers
string, for JSON string literals
nil, for JSON null
要直接访问该值：

result.Type //可以是String，Number，True，False，Null或JSON
result.Str //保存字符串
result.Num //保存float64数字
result.Raw //保存原始json
result.Index //原始json中原始值的索引，零表示索引未知
有各种方便的功能可以处理结果

result.Exists() bool
result.Value() interface{}
result.Int() int64
result.Uint() uint64
result.Float() float64
result.String() string
result.Bool() bool
result.Time() time.Time
result.Array() []gjson.Result
result.Map() map[string]gjson.Result
result.Get(path string) Result
result.ForEach(iterator func(key, value Result) bool)
result.Less(token Result, caseSensitive bool) bool
该result.Value()函数返回一个interface{}需要类型断言的函数，它是以下Go类型之一：

该result.Array()函数返回一组值。如果结果表示不存在的值，则返回空数组。如果结果不是JSON数组，则返回值将是包含一个结果的数组。

boolean >> bool
number >> float64
string >> string
null >> nil
array >> [] interface {}
object >> map [ string ] interface {}
判断某个值是否存在：
value := gjson.Get(json, "name.last")
if !value.Exists() {
println("no last name")
} else {
println(value.String())
}

// Or as one step
if gjson.Get(json, "name.last").Exists() {
println("has a last name")
}
验证json格式
if !gjson.Valid(json) {
return errors.New("invalid json")
}
value := gjson.Get(json, "name.last")
修饰符和路径链接
版本1.2中的新功能支持修改器功能和路径链接。

修饰符是在json上执行自定义处理的路径组件。

可以使用管道字符将多个路径“链接”在一起。这对于从修改后的查询中获取结果非常有用。

例如，使用@reverse上面json文档中的内置修饰符，我们将得到children数组并反转顺序：

"children|@reverse" >> ["Jack","Alex","Sara"]
"children|@reverse|0" >> "Jack"

目前有三种内置修饰符：

@reverse：反转数组或对象的成员。
@ugly：从json文档中删除所有空格。
@pretty：使json文档更具人性化
自定义修改器
您还可以添加自定义修改器。

例如，这里我们创建一个修饰符，使整个json文档大写或小写

gjson.AddModifier("case", func(json, arg string) string {
if arg == "upper" {
return strings.ToUpper(json)
}
if arg == "lower" {
return strings.ToLower(json)
}
return json
})
"children|@case:upper" >> ["SARA","ALEX","JACK"]
"children|@case:lower|@reverse" >> ["jack","alex","sara"]
json Lines
{"name": "Gilbert", "age": 61}
{"name": "Alexa", "age": 34}
{"name": "May", "age": 57}
{"name": "Deloise", "age": 44}

..# >> 4
..1 >> {"name": "Alexa", "age": 34}
..3 >> {"name": "Deloise", "age": 44}
..#.name >> ["Gilbert","Alexa","May","Deloise"]
..#[name="May"].age >> 57
该ForEachLines函数将遍历JSON行

gjson.ForEachLine(json, func(line gjson.Result) bool{
println(line.String())
return true
})
获取嵌套数组值
假设您想要以下json中的所有姓氏

{
"programmers": [
{
"firstName": "Janet",
"lastName": "McLaughlin",
}, {
"firstName": "Elliotte",
"lastName": "Hunter",
}, {
"firstName": "Jason",
"lastName": "Harold",
}
]
}
获取所有的lastName

result := gjson.Get(json, "programmers.#.lastName")
for _, name := range result.Array() {
println(name.String())
}
您还可以查询数组中的对象：

name := gjson.Get(json, `programmers.#[lastName="Hunter"].firstName`)
println(name.String()) // prints "Elliotte"
遍历对象或数组
该ForEach函数允许快速迭代对象或数组。键和值将传递给对象的迭代器函数。仅为数组传递值。false从迭代器返回将停止迭代

result := gjson.Get(json, "programmers")
result.ForEach(func(key, value gjson.Result) bool {
println(value.String())
return true // keep iterating
})
解开到map
解开到map[string]interface{}

m, ok := gjson.Parse(json).Value().(map[string]interface{})
if !ok {
// not a map
}
使用字节
如果您的JSON包含在[]byte切片中，那么就是GetBytes函数。这是优先的Get(string(data), path)

var json []byte = ...
result := gjson.GetBytes(json, path)
如果您正在使用该gjson.GetBytes(json, path)功能并且想要避免转换result.Raw为a[]byte，则可以使用此模式

var json []byte = ...
result := gjson.GetBytes(json, path)
var raw []byte
if result.Index > 0 {
raw = json[result.Index:result.Index+len(result.Raw)]
} else {
raw = []byte(result.Raw)
}
这是原始json的尽力而为的无分配子切片。该方法利用result.Index字段，该字段是原始json中原始数据的位置。有可能值result.Index等于零，在这种情况下result.Raw转换为a[]byte

一次获取多个值
该GetMany函数可用于同时获取多个值

results := gjson.GetMany(json, "name.first", "name.last", "age")
返回值为a[]Result，它将始终包含与输入路径完全相同的项目数

格式化
要开始使用Pretty，请安装Go并运行go get：

$ go get -u github.com/tidwall/pretty
const json = `{
"name": {"first": "Tom", "last": "Anderson"},
"age":37,
"children": ["Sara","Alex","Jack"],
"fav.movie": "Deer Hunter",
"friends": [
{"first": "Dale", "last": "Murphy", "age": 44},
{"first": "Roger", "last": "Craig", "age": 68},
{"first": "Jane", "last": "Murphy", "age": 47}
]
}`

func main() {

var byteSlice []byte
byteSlice = []byte(json)

res := pretty.Pretty(byteSlice)
fmt.Println(string(res))
}
复制

加上颜色

result = pretty.Color(json, nil)
————————————————
版权声明：本文为CSDN博主「晨梦思雨」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/ma2595162349/article/details/113003728