跳到主要内容
版本:2.1.x

以下常用方法列表,文档更新可能滞后于代码新特性,更多的方法及示例请参考代码文档: https://pkg.go.dev/github.com/gogf/gf/v2/encoding/gjson

New

  • 说明: New 可以用任意类型的值 data 创建一个 Json 对象,但是由于数据访问的关系, data 应该是一个 map 或者 slice,否则是无意义的。

  • 注意: safe 参数决定了 Json 对象是否是并发安全的,默认为 false

  • 格式:

func New(data interface{}, safe ...bool) *Json
  • 示例:
func ExampleNew() {
jsonContent := `{"name":"john", "score":"100"}`
j := gjson.New(jsonContent)
fmt.Println(j.Get("name"))
fmt.Println(j.Get("score"))

// Output:
// john
// 100
}

NewWithTag

  • 说明: NewWithTag 可以用任意类型的值 data 创建一个 Json 对象,但是由于数据访问的关系, data 应该是一个 map 或者 slice,否则是无意义的。

  • 注意: tgts 参数指定了结构体转换到map的标签名的优先级,多个标签用 ',' 分割。

  • safe 参数决定了 Json 对象是否是并发安全的,默认为 false

  • 格式:

func NewWithTag(data interface{}, tags string, safe ...bool) *Json
  • 示例:
func ExampleNewWithTag() {
type Me struct {
Name string `tag:"name"`
Score int `tag:"score"`
Title string
}
me := Me{
Name: "john",
Score: 100,
Title: "engineer",
}
j := gjson.NewWithTag(me, "tag", true)
fmt.Println(j.Get("name"))
fmt.Println(j.Get("score"))
fmt.Println(j.Get("Title"))

// Output:
// john
// 100
// engineer
}

NewWithOptions

  • 说明: NewWithOptions 可以用任意类型的值 data 创建一个 Json 对象,但是由于数据访问的关系, data 应该是一个 map 或者 slice,否则是无意义的。

  • 格式:

func NewWithOptions(data interface{}, options Options) *Json
  • 示例:
func ExampleNewWithOptions() {
type Me struct {
Name string `tag:"name"`
Score int `tag:"score"`
Title string
}
me := Me{
Name: "john",
Score: 100,
Title: "engineer",
}

j := gjson.NewWithOptions(me, gjson.Options{
Tags: "tag",
})
fmt.Println(j.Get("name"))
fmt.Println(j.Get("score"))
fmt.Println(j.Get("Title"))

// Output:
// john
// 100
// engineer
}
func ExampleNewWithOptions_UTF8BOM() {
jsonContent := `{"name":"john", "score":"100"}`

content := make([]byte, 3, len(jsonContent)+3)
content[0] = 0xEF
content[1] = 0xBB
content[2] = 0xBF
content = append(content, jsonContent...)

j := gjson.NewWithOptions(content, gjson.Options{
Tags: "tag",
})
fmt.Println(j.Get("name"))
fmt.Println(j.Get("score"))

// Output:
// john
// 100
}

Load

  • 说明:Load 从指定的文件 path 中加载内容,并将其内容创建一个 Json 对象。

  • 格式:

func Load(path string, safe ...bool) (*Json, error)
  • 示例:
func ExampleLoad() {
jsonFilePath := gtest.DataPath("json", "data1.json")
j, _ := gjson.Load(jsonFilePath)
fmt.Println(j.Get("name"))
fmt.Println(j.Get("score"))

notExistFilePath := gtest.DataPath("json", "data2.json")
j2, _ := gjson.Load(notExistFilePath)
fmt.Println(j2.Get("name"))

// Output:
// john
// 100
}
func ExampleLoad_Xml() {
jsonFilePath := gtest.DataPath("xml", "data1.xml")
j, _ := gjson.Load(jsonFilePath)
fmt.Println(j.Get("doc.name"))
fmt.Println(j.Get("doc.score"))
}

LoadJson

  • 说明: LoadJson 用给定的 JSON 格式的内容创建一个 Json 对象。

  • 格式:

func LoadJson(data interface{}, safe ...bool) (*Json, error)
  • 示例:
func ExampleLoadJson() {
jsonContent := `{"name":"john", "score":"100"}`
j, _ := gjson.LoadJson(jsonContent)
fmt.Println(j.Get("name"))
fmt.Println(j.Get("score"))

// Output:
// john
// 100
}

LoadXml

  • 说明: LoadXml 用给定的 XML 格式的内容创建一个 Json 对象。

  • 格式:

func LoadXml(data interface{}, safe ...bool) (*Json, error)
  • 示例:
func ExampleLoadXml() {
xmlContent := `<?xml version="1.0" encoding="UTF-8"?>
<base>
<name>john</name>
<score>100</score>
</base>`
j, _ := gjson.LoadXml(xmlContent)
fmt.Println(j.Get("base.name"))
fmt.Println(j.Get("base.score"))

// Output:
// john
// 100
}

LoadIni

  • 说明: LoadIni 用给定的 INI 格式的内容创建一个 Json 对象。

  • 格式:

func LoadIni(data interface{}, safe ...bool) (*Json, error)
  • 示例:
func ExampleLoadIni() {
iniContent := `
[base]
name = john
score = 100
`
j, _ := gjson.LoadIni(iniContent)
fmt.Println(j.Get("base.name"))
fmt.Println(j.Get("base.score"))

// Output:
// john
// 100
}

LoadYaml

  • 说明: LoadYaml 用给定的 YAML 格式的内容创建一个 Json 对象。

  • 格式:

func LoadYaml(data interface{}, safe ...bool) (*Json, error)
  • 示例:
func ExampleLoadYaml() {
yamlContent :=
`base:
name: john
score: 100`

j, _ := gjson.LoadYaml(yamlContent)
fmt.Println(j.Get("base.name"))
fmt.Println(j.Get("base.score"))

// Output:
// john
// 100
}

LoadToml

  • 说明: LoadToml 用给定的 TOML 格式的内容创建一个 Json 对象。

  • 格式:

func LoadToml(data interface{}, safe ...bool) (*Json, error)
  • 示例:
func ExampleLoadToml() {
tomlContent :=
`[base]
name = "john"
score = 100`

j, _ := gjson.LoadToml(tomlContent)
fmt.Println(j.Get("base.name"))
fmt.Println(j.Get("base.score"))

// Output:
// john
// 100
}

LoadContent

  • 说明:LoadContent 根据给定的内容创建一个 Json 对象,它自动检查 content 的数据类型,支持的内容类型如下: JSON, XML, INI, YAML和TOML

  • 格式:

func LoadContent(data interface{}, safe ...bool) (*Json, error)
  • 示例:
func ExampleLoadContent() {
jsonContent := `{"name":"john", "score":"100"}`

j, _ := gjson.LoadContent(jsonContent)

fmt.Println(j.Get("name"))
fmt.Println(j.Get("score"))

// Output:
// john
// 100
}
func ExampleLoadContent_UTF8BOM() {
jsonContent := `{"name":"john", "score":"100"}`

content := make([]byte, 3, len(jsonContent)+3)
content[0] = 0xEF
content[1] = 0xBB
content[2] = 0xBF
content = append(content, jsonContent...)

j, _ := gjson.LoadContent(content)

fmt.Println(j.Get("name"))
fmt.Println(j.Get("score"))

// Output:
// john
// 100
}
func ExampleLoadContent_Xml() {
xmlContent := `<?xml version="1.0" encoding="UTF-8"?>
<base>
<name>john</name>
<score>100</score>
</base>`

x, _ := gjson.LoadContent(xmlContent)

fmt.Println(x.Get("base.name"))
fmt.Println(x.Get("base.score"))

// Output:
// john
// 100
}

LoadContentType

  • 说明:LoadContentType 根据给定的内容和类型创建一个 Json 对象,支持的内容类型如下: Json, XML, INI, YAML和TOML

  • 格式:

func LoadContentType(dataType string, data interface{}, safe ...bool) (*Json, error)
  • 示例:
func ExampleLoadContentType() {
jsonContent := `{"name":"john", "score":"100"}`
xmlContent := `<?xml version="1.0" encoding="UTF-8"?>
<base>
<name>john</name>
<score>100</score>
</base>`

j, _ := gjson.LoadContentType("json", jsonContent)
x, _ := gjson.LoadContentType("xml", xmlContent)
j1, _ := gjson.LoadContentType("json", "")

fmt.Println(j.Get("name"))
fmt.Println(j.Get("score"))
fmt.Println(x.Get("base.name"))
fmt.Println(x.Get("base.score"))
fmt.Println(j1.Get(""))

// Output:
// john
// 100
// john
// 100
}

IsValidDataType

  • 说明:IsValidDataType 检查给定的 dataType 是否是可以用于加载的有效数据内容。

  • 格式:

func IsValidDataType(dataType string) bool
  • 示例:
func ExampleIsValidDataType() {
fmt.Println(gjson.IsValidDataType("json"))
fmt.Println(gjson.IsValidDataType("yml"))
fmt.Println(gjson.IsValidDataType("js"))
fmt.Println(gjson.IsValidDataType("mp4"))
fmt.Println(gjson.IsValidDataType("xsl"))
fmt.Println(gjson.IsValidDataType("txt"))
fmt.Println(gjson.IsValidDataType(""))
fmt.Println(gjson.IsValidDataType(".json"))

// Output:
// true
// true
// true
// false
// false
// false
// false
// true
}

Valid

  • 说明:Valid 检查 data 是否为有效的 JSON 数据类型。 参数 data 指定 JSON 格式数据,可以是 bytesstring 类型。

  • 格式:

func Valid(data interface{}) bool
  • 示例:
func ExampleValid() {
data1 := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
data2 := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]`)
fmt.Println(gjson.Valid(data1))
fmt.Println(gjson.Valid(data2))

// Output:
// true
// false
}

Marshal

  • 说明:MarshalEncode 的别名。

  • 格式:

func Marshal(v interface{}) (marshaledBytes []byte, err error)
  • 示例:
func ExampleMarshal() {
data := map[string]interface{}{
"name": "john",
"score": 100,
}

jsonData, _ := gjson.Marshal(data)
fmt.Println(string(jsonData))

type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "Guo Qiang",
Age: 18,
}

infoData, _ := gjson.Marshal(info)
fmt.Println(string(infoData))

// Output:
// {"name":"john","score":100}
// {"Name":"Guo Qiang","Age":18}
}

MarshalIndent

  • 说明:MarshalIndentjson.``MarshalIndent 的别名 。

  • 格式:

func MarshalIndent(v interface{}, prefix, indent string) (marshaledBytes []byte, err error)
  • 示例:
func ExampleMarshalIndent() {
type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "John",
Age: 18,
}

infoData, _ := gjson.MarshalIndent(info, "", "\t")
fmt.Println(string(infoData))

// Output:
// {
// "Name": "John",
// "Age": 18
// }
}

Unmarshal

  • 说明: UnmarshalDecodeTo 的别名。

  • 格式:

func Unmarshal(data []byte, v interface{}) (err error)
  • 示例:
func ExampleUnmarshal() {
type BaseInfo struct {
Name string
Score int
}

var info BaseInfo

jsonContent := "{\"name\":\"john\",\"score\":100}"
gjson.Unmarshal([]byte(jsonContent), &info)
fmt.Printf("%+v", info)

// Output:
// {Name:john Score:100}
}

Encode

  • 说明: Encode 将任意类型 value 序列化为内容为 JSONbyte 数组。

  • 格式:

func Encode(value interface{}) ([]byte, error)
  • 示例:
func ExampleEncode() {
type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "John",
Age: 18,
}

infoData, _ := gjson.Encode(info)
fmt.Println(string(infoData))

// Output:
// {"Name":"John","Age":18}
}

MustEncode

  • 说明:MustEncode 执行 Encode 操作,但如果发生任何错误,它会 panic

  • 格式:

func MustEncode(value interface{}) []byte
  • 示例:
func ExampleMustEncode() {
type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "John",
Age: 18,
}

infoData := gjson.MustEncode(info)
fmt.Println(string(infoData))

// Output:
// {"Name":"John","Age":18}
}

EncodeString

  • 说明: EncodeString 将任意类型 value 序列化为内容为 JSONstring

  • 格式:

func EncodeString(value interface{}) (string, error)
  • 示例:
func ExampleEncodeString() {
type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "John",
Age: 18,
}

infoData, _ := gjson.EncodeString(info)
fmt.Println(infoData)

// Output:
// {"Name":"John","Age":18}
}

MustEncodeString

  • 说明: MustEncodeString 将任意类型 value 序列化为内容为 JSONstring,但如果发生任何错误,它会 panic

  • 格式:

func MustEncodeString(value interface{}) string
  • 示例:
func ExampleMustEncodeString() {
type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "John",
Age: 18,
}

infoData := gjson.MustEncodeString(info)
fmt.Println(infoData)

// Output:
// {"Name":"John","Age":18}
}

Decode

  • 说明:DecodeJSON 格式的内容 data 解码为 interface{}。 参数 data 可以是 []bytestring

  • 格式:

func Decode(data interface{}, options ...Options) (interface{}, error)
  • 示例:
func ExampleDecode() {
jsonContent := `{"name":"john","score":100}`
info, _ := gjson.Decode([]byte(jsonContent))
fmt.Println(info)

// Output:
// map[name:john score:100]
}

DecodeTo

  • 说明:DecodeToJSON 格式的数据 data 解码到指定的 interface 类型的变量 v 中。参数 data 可以是 []bytestring。参数 v 应该是指针类型。

  • 格式:

func DecodeTo(data interface{}, v interface{}, options ...Options) (err error)
  • 示例:
func ExampleDecodeTo() {
type BaseInfo struct {
Name string
Score int
}

var info BaseInfo

jsonContent := "{\"name\":\"john\",\"score\":100}"
gjson.DecodeTo([]byte(jsonContent), &info)
fmt.Printf("%+v", info)

// Output:
// {Name:john Score:100}
}

DecodeToJson

  • 说明:DecodeToJsonJSON 格式的数据 data 编码为 json 对象。参数 data 可以是 []bytestring

  • 格式:

func DecodeToJson(data interface{}, options ...Options) (*Json, error)
  • 示例:
func ExampleDecodeToJson() {
jsonContent := `{"name":"john","score":100}"`
j, _ := gjson.DecodeToJson([]byte(jsonContent))
fmt.Println(j.Map())

// May Output:
// map[name:john score:100]
}


SetSplitChar

  • 说明:SetSplitChar 设置数据访问的层级分隔符。

  • 格式:

func (j *Json) SetSplitChar(char byte)
  • 示例:
func ExampleJson_SetSplitChar() {
data :=
`{
"users" : {
"count" : 2,
"list" : [
{"name" : "Ming", "score" : 60},
{"name" : "John", "score" : 99.5}
]
}
}`
if j, err := gjson.DecodeToJson(data); err != nil {
panic(err)
} else {
j.SetSplitChar('#')
fmt.Println("John Score:", j.Get("users#list#1#score").Float32())
}
// Output:
// John Score: 99.5
}

SetViolenceCheck

  • 说明: SetViolenceCheck 启用/禁用数据层级访问的暴力检查。

  • 格式:

func (j *Json) SetViolenceCheck(enabled bool)
  • 示例:
func ExampleJson_SetViolenceCheck() {
data :=
`{
"users" : {
"count" : 100
},
"users.count" : 101
}`
if j, err := gjson.DecodeToJson(data); err != nil {
fmt.Println(err)
} else {
j.SetViolenceCheck(true)
fmt.Println("Users Count:", j.Get("users.count"))
}
// Output:
// Users Count: 101
}

ToJson

  • 说明: ToJson 返回类型为 []byteJSON 内容。

  • 格式:

func (j *Json) ToJson() ([]byte, error)
  • 示例:
func ExampleJson_ToJson() {
type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "John",
Age: 18,
}

j := gjson.New(info)
jsonBytes, _ := j.ToJson()
fmt.Println(string(jsonBytes))

// Output:
// {"Age":18,"Name":"John"}
}

ToJsonString

  • 说明: ToJsonString 返回类型为 stringJSON 内容。

  • 格式:

func (j *Json) ToJsonString() (string, error)
  • 示例:
func ExampleJson_ToJsonString() {
type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "John",
Age: 18,
}

j := gjson.New(info)
jsonStr, _ := j.ToJsonString()
fmt.Println(jsonStr)

// Output:
// {"Age":18,"Name":"John"}
}

ToJsonIndent

  • 说明: ToJsonIndent 返回类型为 []byte 的带缩进格式的 JSON 内容。

  • 格式:

func (j *Json) ToJsonIndent() ([]byte, error)
  • 示例:
func ExampleJson_ToJsonIndent() {
type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "John",
Age: 18,
}

j := gjson.New(info)
jsonBytes, _ := j.ToJsonIndent()
fmt.Println(string(jsonBytes))

// Output:
//{
// "Age": 18,
// "Name": "John"
//}
}

ToJsonIndentString

  • 说明: ToJsonIndentString 返回类型为 string 的带缩进格式的 JSON 内容。

  • 格式:

func (j *Json) ToJsonIndentString() (string, error)
  • 示例:
func ExampleJson_ToJsonIndentString() {
type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "John",
Age: 18,
}

j := gjson.New(info)
jsonStr, _ := j.ToJsonIndentString()
fmt.Println(jsonStr)

// Output:
//{
// "Age": 18,
// "Name": "John"
//}
}

MustToJson

  • 说明: MustToJson 返回类型为 []byteJSON 内容,如果发生任何错误,会发生 panic

  • 格式:

func (j *Json) MustToJson() []byte
  • 示例:
func ExampleJson_MustToJson() {
type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "John",
Age: 18,
}

j := gjson.New(info)
jsonBytes := j.MustToJson()
fmt.Println(string(jsonBytes))

// Output:
// {"Age":18,"Name":"John"}
}

MustToJsonString

  • 说明: MustToJsonString 返回类型为 stringJSON 内容,如果发生任何错误,会发生 panic

  • 格式:

func (j *Json) MustToJsonString() string
  • 示例:
func ExampleJson_MustToJsonString() {
type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "John",
Age: 18,
}

j := gjson.New(info)
jsonStr := j.MustToJsonString()
fmt.Println(jsonStr)

// Output:
// {"Age":18,"Name":"John"}
}

MustToJsonIndent

  • 说明: MustToJsonStringIndent 返回类型为 []byte 的带缩进格式的 JSON 内容,如果发生任何错误,会发生 panic

  • 格式:

func (j *Json) MustToJsonIndent() []byte
  • 示例:
func ExampleJson_MustToJsonIndent() {
type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "John",
Age: 18,
}

j := gjson.New(info)
jsonBytes := j.MustToJsonIndent()
fmt.Println(string(jsonBytes))

// Output:
//{
// "Age": 18,
// "Name": "John"
//}
}

MustToJsonIndentString

  • 说明: MustToJsonStringIndent 返回类型为 string 的带缩进格式的 JSON 内容,如果发生任何错误,会发生 panic

  • 格式:

func (j *Json) MustToJsonIndentString() string
  • 示例:
func ExampleJson_MustToJsonIndentString() {
type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "John",
Age: 18,
}

j := gjson.New(info)
jsonStr := j.MustToJsonIndentString()
fmt.Println(jsonStr)

// Output:
//{
// "Age": 18,
// "Name": "John"
//}
}

ToXml

  • 说明: ToXml 返回类型为 []byte 格式为 XML 的内容。

  • 格式:

func (j *Json) ToXml(rootTag ...string) ([]byte, error)
  • 示例:
func ExampleJson_ToXml() {
type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "John",
Age: 18,
}

j := gjson.New(info)
xmlBytes, _ := j.ToXml()
fmt.Println(string(xmlBytes))

// Output:
// <doc><Age>18</Age><Name>John</Name></doc>
}

ToXmlString

  • 说明: ToXmlString 返回类型为 string 格式为 XML 的内容。

  • 格式:

func (j *Json) ToXmlString(rootTag ...string) (string, error)
  • 示例:
func ExampleJson_ToXmlString() {
type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "John",
Age: 18,
}

j := gjson.New(info)
xmlStr, _ := j.ToXmlString()
fmt.Println(string(xmlStr))

// Output:
// <doc><Age>18</Age><Name>John</Name></doc>
}

ToXmlIndent

  • 说明: ToXmlIndent 返回类型为 []byte 的带缩进格式的 XML 内容。

  • 格式:

func (j *Json) ToXmlIndent(rootTag ...string) ([]byte, error)
  • 示例:
func ExampleJson_ToXmlIndent() {
type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "John",
Age: 18,
}

j := gjson.New(info)
xmlBytes, _ := j.ToXmlIndent()
fmt.Println(string(xmlBytes))

// Output:
//<doc>
// <Age>18</Age>
// <Name>John</Name>
//</doc>
}

ToXmlIndentString

  • 说明: ToXmlIndentString 返回类型为 string 的带缩进格式的 XML 内容。

  • 格式:

func (j *Json) ToXmlIndentString(rootTag ...string) (string, error)
  • 示例:
func ExampleJson_ToXmlIndentString() {
type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "John",
Age: 18,
}

j := gjson.New(info)
xmlStr, _ := j.ToXmlIndentString()
fmt.Println(string(xmlStr))

// Output:
//<doc>
// <Age>18</Age>
// <Name>John</Name>
//</doc>
}

MustToXml

  • 说明: MustToXml 返回类型为 []byte 格式为 XML 的内容。如果发生任何错误,会发生 panic

  • 格式:

func (j *Json) MustToXml(rootTag ...string) []byte
  • 示例:
func ExampleJson_MustToXml() {
type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "John",
Age: 18,
}

j := gjson.New(info)
xmlBytes := j.MustToXml()
fmt.Println(string(xmlBytes))

// Output:
// <doc><Age>18</Age><Name>John</Name></doc>
}

MustToXmlString

  • 说明: MustToXmlString 返回类型为 string 格式为 XML 的内容。如果发生任何错误,会发生 panic

  • 格式:

func (j *Json) MustToXmlString(rootTag ...string) string
  • 示例:
func ExampleJson_MustToXmlString() {
type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "John",
Age: 18,
}

j := gjson.New(info)
xmlStr := j.MustToXmlString()
fmt.Println(string(xmlStr))

// Output:
// <doc><Age>18</Age><Name>John</Name></doc>
}

MustToXmlIndent

  • 说明: MustToXmlStringIndent 返回类型为 []byte 带缩进格式的 XML 内容。如果发生任何错误,会发生 panic

  • 格式:

func (j *Json) MustToXmlIndent(rootTag ...string) []byte
  • 示例:
func ExampleJson_MustToXmlIndent() {
type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "John",
Age: 18,
}

j := gjson.New(info)
xmlBytes := j.MustToXmlIndent()
fmt.Println(string(xmlBytes))

// Output:
//<doc>
// <Age>18</Age>
// <Name>John</Name>
//</doc>
}

MustToXmlIndentString

  • 说明: MustToXmlStringIndentString 返回类型为 string 带缩进格式的 XML 内容。如果发生任何错误,会发生 panic

  • 格式:

func (j *Json) MustToXmlIndentString(rootTag ...string) string
  • 示例:
func ExampleJson_MustToXmlIndentString() {
type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "John",
Age: 18,
}

j := gjson.New(info)
xmlStr := j.MustToXmlIndentString()
fmt.Println(string(xmlStr))

// Output:
//<doc>
// <Age>18</Age>
// <Name>John</Name>
//</doc>
}

ToYaml

  • 说明: ToYaml 返回类型为 []byte 格式为 YAML 的内容。

  • 格式:

func (j *Json) ToYaml() ([]byte, error)
  • 示例:
func ExampleJson_ToYaml() {
type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "John",
Age: 18,
}

j := gjson.New(info)
YamlBytes, _ := j.ToYaml()
fmt.Println(string(YamlBytes))

// Output:
//Age: 18
//Name: John
}

ToYamlIndent

  • 说明: ToYamlIndent 返回类型为 []byte 带缩进格式的 YAML 内容。

  • 格式:

func (j *Json) ToYamlIndent(indent string) ([]byte, error)
  • 示例:
func ExampleJson_ToYamlIndent() {
type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "John",
Age: 18,
}

j := gjson.New(info)
YamlBytes, _ := j.ToYamlIndent("")
fmt.Println(string(YamlBytes))

// Output:
//Age: 18
//Name: John
}

ToYamlString

  • 说明: ToYamlString 返回类型为 string 格式为 YAML 的内容。

  • 格式:

func (j *Json) ToYamlString() (string, error)
  • 示例:
func ExampleJson_ToYamlString() {
type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "John",
Age: 18,
}

j := gjson.New(info)
YamlStr, _ := j.ToYamlString()
fmt.Println(string(YamlStr))

// Output:
//Age: 18
//Name: John
}

MustToYaml

  • 说明: MustToYaml 返回类型为 []byte 格式为 YAML 的内容。如果发生任何错误,会发生 panic

  • 格式:

func (j *Json) MustToYaml() []byte
  • 示例:
func ExampleJson_MustToYaml() {
type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "John",
Age: 18,
}

j := gjson.New(info)
YamlBytes := j.MustToYaml()
fmt.Println(string(YamlBytes))

// Output:
//Age: 18
//Name: John
}

MustToYamlString

  • 说明: MustToYamlString 返回类型为 string 格式为 YAML 的内容。如果发生任何错误,会发生 panic

  • 格式:

func (j *Json) MustToYamlString() string
  • 示例:
func ExampleJson_MustToYamlString() {
type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "John",
Age: 18,
}

j := gjson.New(info)
YamlStr := j.MustToYamlString()
fmt.Println(string(YamlStr))

// Output:
//Age: 18
//Name: John
}

ToToml

  • 说明: ToToml 返回类型为 []byte 格式为 TOML 的内容。

  • 格式:

func (j *Json) ToToml() ([]byte, error)
  • 示例:
func ExampleJson_ToToml() {
type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "John",
Age: 18,
}

j := gjson.New(info)
TomlBytes, _ := j.ToToml()
fmt.Println(string(TomlBytes))

// Output:
//Age = 18
//Name = "John"
}

ToTomlString

  • 说明: ToTomlString 返回类型为 string 格式为 TOML 的内容。

  • 格式:

func (j *Json) ToTomlString() (string, error)
  • 示例:
func ExampleJson_ToTomlString() {
type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "John",
Age: 18,
}

j := gjson.New(info)
TomlStr, _ := j.ToTomlString()
fmt.Println(string(TomlStr))

// Output:
//Age = 18
//Name = "John"
}

MustToToml

  • 说明: MustToToml 返回类型为 []byte 格式为 TOML 的内容。如果发生任何错误,会发生 panic

  • 格式:

func (j *Json) MustToToml() []byte
  • 示例:
func ExampleJson_MustToToml() {
type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "John",
Age: 18,
}

j := gjson.New(info)
TomlBytes := j.MustToToml()
fmt.Println(string(TomlBytes))

// Output:
//Age = 18
//Name = "John"
}

MustToTomlString

  • 说明: MustToTomlString 返回类型为 string 格式为 TOML 的内容。如果发生任何错误,会发生 panic

  • 格式:

func (j *Json) MustToTomlString() string
  • 示例:
func ExampleJson_MustToTomlString() {
type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "John",
Age: 18,
}

j := gjson.New(info)
TomlStr := j.MustToTomlString()
fmt.Println(string(TomlStr))

// Output:
//Age = 18
//Name = "John"
}

ToIni

  • 说明: ToIni 返回类型为 []byte 格式为 INI 的内容。

  • 格式:

func (j *Json) ToIni() ([]byte, error)
  • 示例:
func ExampleJson_ToIni() {
type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "John",
Age: 18,
}

j := gjson.New(info)
IniBytes, _ := j.ToIni()
fmt.Println(string(IniBytes))

// May Output:
//Name=John
//Age=18
}

ToIniString

  • 说明: ToIniString 返回类型为 string 格式为 INI 的内容。

  • 格式:

func (j *Json) ToIniString() (string, error)
  • 示例:
func ExampleJson_ToIniString() {
type BaseInfo struct {
Name string
}

info := BaseInfo{
Name: "John",
}

j := gjson.New(info)
IniStr, _ := j.ToIniString()
fmt.Println(string(IniStr))

// Output:
//Name=John
}

MustToIni

  • 说明: MustToIni 返回类型为 []byte 格式为 INI 的内容。如果发生任何错误,会发生 panic

  • 格式:

func (j *Json) MustToIni() []byte
  • 示例:
func ExampleJson_MustToIni() {
type BaseInfo struct {
Name string
}

info := BaseInfo{
Name: "John",
}

j := gjson.New(info)
IniBytes := j.MustToIni()
fmt.Println(string(IniBytes))

// Output:
//Name=John
}

MustToIniString

  • 说明: MustToIniString 返回类型为 string 格式为 INI 的内容。如果发生任何错误,会发生 panic

  • 格式:

func (j *Json) MustToIniString() string
  • 示例:
func ExampleJson_MustToIniString() {
type BaseInfo struct {
Name string
}

info := BaseInfo{
Name: "John",
}

j := gjson.New(info)
IniStr := j.MustToIniString()
fmt.Println(string(IniStr))

// Output:
//Name=John
}

MarshalJSON

  • 说明:MarshalJSON 实现了 json.Marshal 的接口 MarshalJSON

  • 格式:

func (j Json) MarshalJSON() ([]byte, error)
  • 示例:
func ExampleJson_MarshalJSON() {
type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "John",
Age: 18,
}

j := gjson.New(info)
jsonBytes, _ := j.MarshalJSON()
fmt.Println(string(jsonBytes))

// Output:
// {"Age":18,"Name":"John"}
}

UnmarshalJSON

  • 说明: UnmarshalJSON 实现了 json.Unmarshal 的接口 UnmarshalJSON

  • 格式:

func (j *Json) UnmarshalJSON(b []byte) error
  • 示例:
func ExampleJson_UnmarshalJSON() {
jsonStr := `{"Age":18,"Name":"John"}`

j := gjson.New("")
j.UnmarshalJSON([]byte(jsonStr))
fmt.Println(j.Map())

// Output:
// map[Age:18 Name:John]
}

UnmarshalValue

  • 说明:UnmarshalValue 是一个为 Json 设置任何类型的值的接口实现。

  • 格式:

func (j *Json) UnmarshalValue(value interface{}) error
  • 示例:
func ExampleJson_UnmarshalValue_Yaml() {
yamlContent :=
`base:
name: john
score: 100`

j := gjson.New("")
j.UnmarshalValue([]byte(yamlContent))
fmt.Println(j.Var().String())

// Output:
// {"base":{"name":"john","score":100}}
}
func ExampleJson_UnmarshalValue_Xml() {
xmlStr := `<?xml version="1.0" encoding="UTF-8"?><doc><name>john</name><score>100</score></doc>`

j := gjson.New("")
j.UnmarshalValue([]byte(xmlStr))
fmt.Println(j.Var().String())

// Output:
// {"doc":{"name":"john","score":"100"}}
}

MapStrAny

  • 说明: MapStrAny 实现了接口方法 MapStrAny()

  • 格式:

func (j *Json) MapStrAny() map[string]interface{}
  • 示例:
func ExampleJson_MapStrAny() {
type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "John",
Age: 18,
}

j := gjson.New(info)
fmt.Println(j.MapStrAny())

// Output:
// map[Age:18 Name:John]
}

Interfaces

  • 说明: Interfaces 实现了接口方法 Interfaces()

  • 格式:

func (j *Json) Interfaces() []interface{}
  • 示例:
func ExampleJson_Interfaces() {
type BaseInfo struct {
Name string
Age int
}

infoList := []BaseInfo{
BaseInfo{
Name: "John",
Age: 18,
},
BaseInfo{
Name: "Tom",
Age: 20,
},
}

j := gjson.New(infoList)
fmt.Println(j.Interfaces())

// Output:
// [{John 18} {Tom 20}]
}

Interface

  • 说明: Interface 返回 Json 对象的值。

  • 格式:

func (j *Json) Interface() interface{}
  • 示例:
func ExampleJson_Interface() {
type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "John",
Age: 18,
}

j := gjson.New(info)
fmt.Println(j.Interface())

var nilJ *gjson.Json = nil
fmt.Println(nilJ.Interface())

// Output:
// map[Age:18 Name:John]
// <nil>
}

Var

  • 说明: Var 返回类型为 *gvar.VarJson 对象的值。

  • 格式:

func (j *Json) Var() *gvar.Var
  • 示例:
func ExampleJson_Var() {
type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "John",
Age: 18,
}

j := gjson.New(info)
fmt.Println(j.Var().String())
fmt.Println(j.Var().Map())

// Output:
// {"Age":18,"Name":"John"}
// map[Age:18 Name:John]
}

IsNil

  • 说明: IsNil 检查Json对象值是否为 nil

  • 格式:

func (j *Json) IsNil() bool
  • 示例:
func ExampleJson_IsNil() {
data1 := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
data2 := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]`)

j1, _ := gjson.LoadContent(data1)
fmt.Println(j1.IsNil())

j2, _ := gjson.LoadContent(data2)
fmt.Println(j2.IsNil())

// Output:
// false
// true
}

Get

  • 说明:Get 根据指定的 pattern 检索并返回值。如果 pattern 给的是 ".",将返回当前 Json 对象的所有值。没有 pattern 没有找到,则返回 nil

  • 格式:

func (j *Json) Get(pattern string, def ...interface{}) *gvar.Var
  • 示例:
func ExampleJson_Get() {
data :=
`{
"users" : {
"count" : 1,
"array" : ["John", "Ming"]
}
}`

j, _ := gjson.LoadContent(data)
fmt.Println(j.Get("."))
fmt.Println(j.Get("users"))
fmt.Println(j.Get("users.count"))
fmt.Println(j.Get("users.array"))

var nilJ *gjson.Json = nil
fmt.Println(nilJ.Get("."))

// Output:
// {"users":{"array":["John","Ming"],"count":1}}
// {"array":["John","Ming"],"count":1}
// 1
// ["John","Ming"]
}

GetJson

  • 说明:GetJson 通过指定的 pattern 获取值,并将其转换为一个非并发安全的 Json 对象。

  • 格式:

func (j *Json) GetJson(pattern string, def ...interface{}) *Json
  • 示例:
func ExampleJson_GetJson() {
data :=
`{
"users" : {
"count" : 1,
"array" : ["John", "Ming"]
}
}`

j, _ := gjson.LoadContent(data)

fmt.Println(j.GetJson("users.array").Array())

// Output:
// [John Ming]
}

GetJsons

  • 说明:GetJsons 通过指定的 pattern 获取值,并将其转换为一个非并发安全的 Json 对象切片。

  • 格式:

func (j *Json) GetJsons(pattern string, def ...interface{}) []*Json
  • 示例:
func ExampleJson_GetJsons() {
data :=
`{
"users" : {
"count" : 3,
"array" : [{"Age":18,"Name":"John"}, {"Age":20,"Name":"Tom"}]
}
}`

j, _ := gjson.LoadContent(data)

jsons := j.GetJsons("users.array")
for _, json := range jsons {
fmt.Println(json.Interface())
}

// Output:
// map[Age:18 Name:John]
// map[Age:20 Name:Tom]
}

GetJsonMap

  • 说明:GetJsonMap 通过指定的 pattern 获取值,并将其转换为一个非并发安全的 Json 对象的 map

  • 格式:

func (j *Json) GetJsonMap(pattern string, def ...interface{}) map[string]*Json
  • 示例:
func ExampleJson_GetJsonMap() {
data :=
`{
"users" : {
"count" : 1,
"array" : {
"info" : {"Age":18,"Name":"John"},
"addr" : {"City":"Chengdu","Company":"Tencent"}
}
}
}`

j, _ := gjson.LoadContent(data)

jsonMap := j.GetJsonMap("users.array")

for _, json := range jsonMap {
fmt.Println(json.Interface())
}

// May Output:
// map[City:Chengdu Company:Tencent]
// map[Age:18 Name:John]
}

Set

  • 说明:Set 设置指定 pattern 的值。 它默认支持通过字符 '.' 进行数据层级访问。

  • 格式:

func (j *Json) Set(pattern string, value interface{}) error
  • 示例:
func ExampleJson_Set() {
type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "John",
Age: 18,
}

j := gjson.New(info)
j.Set("Addr", "ChengDu")
j.Set("Friends.0", "Tom")
fmt.Println(j.Var().String())

// Output:
// {"Addr":"ChengDu","Age":18,"Friends":["Tom"],"Name":"John"}
}

MustSet

  • 说明:MustSet 执行 Set,但如果有任何错误,会发生 panic

  • 格式:

func (j *Json) MustSet(pattern string, value interface{})
  • 示例:
func ExampleJson_MustSet() {
type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "John",
Age: 18,
}

j := gjson.New(info)
j.MustSet("Addr", "ChengDu")
fmt.Println(j.Var().String())

// Output:
// {"Addr":"ChengDu","Age":18,"Name":"John"}
}

Remove

  • 说明: Remove 删除指定 pattern 的值。 它默认支持通过字符 '.' 进行数据层级访问。

  • 格式:

func (j *Json) Remove(pattern string) error
  • 示例:
func ExampleJson_Remove() {
type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "John",
Age: 18,
}

j := gjson.New(info)
j.Remove("Age")
fmt.Println(j.Var().String())

// Output:
// {"Name":"John"}
}

MustRemove

  • 说明:MustRemove 执行Remove,但如果有任何错误,会发生 panic

  • 格式:

func (j *Json) MustRemove(pattern string)
  • 示例:
func ExampleJson_MustRemove() {
type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "John",
Age: 18,
}

j := gjson.New(info)
j.MustRemove("Age")
fmt.Println(j.Var().String())

// Output:
// {"Name":"John"}
}

Contains

  • 说明: Contains 检查指定 pattern 的值是否存在。

  • 格式:

func (j *Json) Contains(pattern string) bool
  • 示例:
func ExampleJson_Contains() {
type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{
Name: "John",
Age: 18,
}

j := gjson.New(info)
fmt.Println(j.Contains("Age"))
fmt.Println(j.Contains("Addr"))

// Output:
// true
// false
}

Len

  • 说明:Len 根据指定的 pattern 返回 值的长度/大小。 pattern 的值应该是 slicemap 的类型。 如果找不到目标值或类型无效,则返回 -1

  • 格式:

func (j *Json) Len(pattern string) int
  • 示例:
func ExampleJson_Len() {
data :=
`{
"users" : {
"count" : 1,
"nameArray" : ["Join", "Tom"],
"infoMap" : {
"name" : "Join",
"age" : 18,
"addr" : "ChengDu"
}
}
}`

j, _ := gjson.LoadContent(data)

fmt.Println(j.Len("users.nameArray"))
fmt.Println(j.Len("users.infoMap"))

// Output:
// 2
// 3
}

Append

  • 说明:Append 通过指定的 pattern 将值追加到 Json 对象中。 pattern 的值的类型应该是 slice

  • 格式:

func (j *Json) Append(pattern string, value interface{}) error
  • 示例:
func ExampleJson_Append() {
data :=
`{
"users" : {
"count" : 1,
"array" : ["John", "Ming"]
}
}`

j, _ := gjson.LoadContent(data)

j.Append("users.array", "Lily")

fmt.Println(j.Get("users.array").Array())

// Output:
// [John Ming Lily]
}

MustAppend

  • 说明:MustAppend 执行 Append,但如果有任何错误,会发生 panic

  • 格式:

func (j *Json) MustAppend(pattern string, value interface{})
  • 示例:
func ExampleJson_MustAppend() {
data :=
`{
"users" : {
"count" : 1,
"array" : ["John", "Ming"]
}
}`

j, _ := gjson.LoadContent(data)

j.MustAppend("users.array", "Lily")

fmt.Println(j.Get("users.array").Array())

// Output:
// [John Ming Lily]
}

Map

  • 说明: Map 将当前 Json 对象转换为 map[string]interface{}。 如果失败,则返回 nil

  • 格式:

func (j *Json) Map() map[string]interface{}
  • 示例:
func ExampleJson_Map() {
data :=
`{
"users" : {
"count" : 1,
"info" : {
"name" : "John",
"age" : 18,
"addr" : "ChengDu"
}
}
}`

j, _ := gjson.LoadContent(data)

fmt.Println(j.Get("users.info").Map())

// Output:
// map[addr:ChengDu age:18 name:John]
}

Array

  • 说明:Array 将当前 Json 对象转换为 []interface{}。 如果失败,则返回 nil

  • 格式:

func (j *Json) Array() []interface{}
  • 示例:
func ExampleJson_Array() {
data :=
`{
"users" : {
"count" : 1,
"array" : ["John", "Ming"]
}
}`

j, _ := gjson.LoadContent(data)

fmt.Println(j.Get("users.array"))

// Output:
// ["John","Ming"]
}

Scan

  • 说明: Scan 自动调用 StructStructs 函数根据参数 pointer 的类型来进行转换。

  • 格式:

func (j *Json) Scan(pointer interface{}, mapping ...map[string]string) error
  • 示例:
func ExampleJson_Scan() {
data := `{"name":"john","age":"18"}`

type BaseInfo struct {
Name string
Age int
}

info := BaseInfo{}

j, _ := gjson.LoadContent(data)
j.Scan(&info)

fmt.Println(info)

// May Output:
// {john 18}
}

Dump

  • 说明: Dump 以可读性更高的方式打印 Json 对象。

  • 格式:

func (j *Json) Dump()
  • 示例:
func ExampleJson_Dump() {
data := `{"name":"john","age":"18"}`

j, _ := gjson.LoadContent(data)
j.Dump()

// May Output:
//{
// "name": "john",
// "age": "18",
//}
}