通用编解码-gjson - 通用编解码-方法介绍 - 《GoFrame v2.4 开发文档》

New
NewWithTag
NewWithOptions
Load
LoadJson
LoadXml
LoadIni
LoadYaml
LoadToml
LoadContent
LoadContentType
IsValidDataType
Valid
Marshal
MarshalIndent
Unmarshal
Encode
MustEncode
EncodeString
MustEncodeString
Decode
DecodeTo
DecodeToJson
SetSplitChar
SetViolenceCheck
ToJson
ToJsonString
ToJsonIndent
ToJsonIndentString
MustToJson
MustToJsonString
MustToJsonIndent
MustToJsonIndentString
ToXml
ToXmlString
ToXmlIndent
ToXmlIndentString
MustToXml
MustToXmlString
MustToXmlIndent
MustToXmlIndentString
ToYaml
ToYamlIndent
ToYamlString
MustToYaml
MustToYamlString
ToToml
ToTomlString
MustToToml
MustToTomlString
ToIni
ToIniString
MustToIni
MustToIniString
MarshalJSON
UnmarshalJSON
UnmarshalValue
MapStrAny
Interfaces
Interface
Var
IsNil
Get
GetJson
GetJsons
GetJsonMap
Set
MustSet
Remove
MustRemove
Contains
Len
Append
MustAppend
Map
Array
Scan
Dump

以下常用方法列表，文档更新可能滞后于代码新特性，更多的方法及示例请参考代码文档：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格式数据，可以是bytes或string类型。
格式：
```
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

说明：Marshal是Encode的别名。

格式：

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`

说明：MarshalIndent是json.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

说明：Unmarshal是DecodeTo的别名。

格式：

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序列化为内容为JSON的byte数组。

格式：

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序列化为内容为JSON的string 。

格式：

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序列化为内容为JSON的string，但如果发生任何错误，它会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`

说明：Decode将JSON格式的内容data解码为interface{}。参数data可以是[]byte或string。

格式：

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

说明：DecodeTo将JSON格式的数据data解码到指定的interface类型的变量v中。参数data可以是[]byte或string。参数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`

说明：DecodeToJson将JSON格式的数据data编码为json对象。参数data可以是[]byte或string。

格式：

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返回类型为[]byte的JSON内容。
格式：
```
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返回类型为string的JSON内容。

格式：

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返回类型为[]byte的JSON内容，如果发生任何错误，会发生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返回类型为string的JSON内容，如果发生任何错误，会发生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.Var的Json对象的值。
格式：
```
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的值应该是slice或map的类型。如果找不到目标值或类型无效，则返回-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自动调用Struct或Structs函数根据参数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",
    //}
}