[TOC]
還有個包[https://github.com/buger/jsonparser](https://github.com/buger/jsonparser)
# 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數組,則返回值將是包含一個結果的數組。
~~~go
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文檔大寫或小寫
~~~go
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](https://godoc.org/github.com/tidwall/gjson#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`:
~~~shell
$ 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)
~~~
- 基礎
- 簡介
- 主要特征
- 變量和常量
- 編碼轉換
- 數組
- byte與rune
- big
- sort接口
- 和mysql類型對應
- 函數
- 閉包
- 工作區
- 復合類型
- 指針
- 切片
- map
- 結構體
- sync.Map
- 隨機數
- 面向對象
- 匿名組合
- 方法
- 接口
- 權限
- 類型查詢
- 異常處理
- error
- panic
- recover
- 自定義錯誤
- 字符串處理
- 正則表達式
- json
- 文件操作
- os
- 文件讀寫
- 目錄
- bufio
- ioutil
- gob
- 棧幀的內存布局
- shell
- 時間處理
- time詳情
- time使用
- new和make的區別
- container
- list
- heap
- ring
- 測試
- 單元測試
- Mock依賴
- delve
- 命令
- TestMain
- path和filepath包
- log日志
- 反射
- 詳解
- plugin包
- 信號
- goto
- 協程
- 簡介
- 創建
- 協程退出
- runtime
- channel
- select
- 死鎖
- 互斥鎖
- 讀寫鎖
- 條件變量
- 嵌套
- 計算單個協程占用內存
- 執行規則
- 原子操作
- WaitGroup
- 定時器
- 對象池
- sync.once
- 網絡編程
- 分層模型
- socket
- tcp
- udp
- 服務端
- 客戶端
- 并發服務器
- Http
- 簡介
- http服務器
- http客戶端
- 爬蟲
- 平滑重啟
- context
- httptest
- 優雅中止
- web服務平滑重啟
- beego
- 安裝
- 路由器
- orm
- 單表增刪改查
- 多級表
- orm使用
- 高級查詢
- 關系查詢
- SQL查詢
- 元數據二次定義
- 控制器
- 參數解析
- 過濾器
- 數據輸出
- 表單數據驗證
- 錯誤處理
- 日志
- 模塊
- cache
- task
- 調試模塊
- config
- 部署
- 一些包
- gjson
- goredis
- collection
- sjson
- redigo
- aliyunoss
- 密碼
- 對稱加密
- 非對稱加密
- 單向散列函數
- 消息認證
- 數字簽名
- mysql優化
- 常見錯誤
- go run的錯誤
- 新手常見錯誤
- 中級錯誤
- 高級錯誤
- 常用工具
- 協程-泄露
- go env
- gometalinter代碼檢查
- go build
- go clean
- go test
- 包管理器
- go mod
- gopm
- go fmt
- pprof
- 提高編譯
- go get
- 代理
- 其他的知識
- go內存對齊
- 細節總結
- nginx路由匹配
- 一些博客
- redis為什么快
- cpu高速緩存
- 常用命令
- Go 永久阻塞的方法
- 常用技巧
- 密碼加密解密
- for 循環迭代變量
- 備注
- 垃圾回收
- 協程和纖程
- tar-gz
- 紅包算法
- 解決golang.org/x 下載失敗
- 逃逸分析
- docker
- 鏡像
- 容器
- 數據卷
- 網絡管理
- 網絡模式
- dockerfile
- docker-composer
- 微服務
- protoBuf
- GRPC
- tls
- consul
- micro
- crontab
- shell調用
- gorhill/cronexpr
- raft
- go操作etcd
- mongodb