通用编解码-方法介绍

以下常用方法列表，文档更新可能滞后于代码新特性，更多的方法及示例请参考代码文档：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",
	//}
}

Content Menu

Space shortcuts

Page tree

通用编解码-方法介绍

New

NewWithTag

NewWithOptions

Load

LoadJson

LoadXml

LoadIni

LoadYaml

LoadToml

LoadContent

LoadContentType

IsValidDataType

Valid

Marshal

MarshalIndent

Unmarshal

Encode

MustEncode

EncodeString

MustEncodeString

Decode