通用编解码-方法介绍 | GoFrame官网 - 类似PHP-Laravel,Java-SpringBoot的Go企业级开发框架

Version: 2.4.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 格式数据，可以是 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",
      //}
}

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​

`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