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

New

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

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

    func New(data interface{}, safe ...bool) *Json
  • 示例:

    func ExampleNew() {
    	jsonContent := `{"name":"john", "score":"100"}`
    	j := gjson.New(jsonContent)
    	fmt.Println(j.Get("name"))
    	fmt.Println(j.Get("score"))
    
    	// Output:
    	// john
    	// 100
    }

NewWithTag

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

  • 注意:tgts参数指定了结构体转换到map的标签名的优先级,多个标签用','分割。
  •            safe参数决定了Json对象是否是并发安全的,默认为false
  • 格式:

    func NewWithTag(data interface{}, tags string, safe ...bool) *Json
  • 示例:

    func ExampleNewWithTag() {
    	type Me struct {
    		Name  string `tag:"name"`
    		Score int    `tag:"score"`
    		Title string
    	}
    	me := Me{
    		Name:  "john",
    		Score: 100,
    		Title: "engineer",
    	}
    	j := gjson.NewWithTag(me, "tag", true)
    	fmt.Println(j.Get("name"))
    	fmt.Println(j.Get("score"))
    	fmt.Println(j.Get("Title"))
    
    	// Output:
    	// john
    	// 100
    	// engineer
    }

NewWithOptions

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

  • 格式:

    func NewWithOptions(data interface{}, options Options) *Json
  • 示例:

    func ExampleNewWithOptions() {
    	type Me struct {
    		Name  string `tag:"name"`
    		Score int    `tag:"score"`
    		Title string
    	}
    	me := Me{
    		Name:  "john",
    		Score: 100,
    		Title: "engineer",
    	}
    
    	j := gjson.NewWithOptions(me, gjson.Options{
    		Tags: "tag",
    	})
    	fmt.Println(j.Get("name"))
    	fmt.Println(j.Get("score"))
    	fmt.Println(j.Get("Title"))
    
    	// Output:
    	// john
    	// 100
    	// engineer
    }
    func ExampleNewWithOptions_UTF8BOM() {
    	jsonContent := `{"name":"john", "score":"100"}`
    
    	content := make([]byte, 3, len(jsonContent)+3)
    	content[0] = 0xEF
    	content[1] = 0xBB
    	content[2] = 0xBF
    	content = append(content, jsonContent...)
    
    	j := gjson.NewWithOptions(content, gjson.Options{
    		Tags: "tag",
    	})
    	fmt.Println(j.Get("name"))
    	fmt.Println(j.Get("score"))
    
    	// Output:
    	// john
    	// 100
    }

Load

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

  • 格式:

    func Load(path string, safe ...bool) (*Json, error)
  • 示例:

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

LoadJson

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

  • 格式:

    func LoadJson(data interface{}, safe ...bool) (*Json, error)
  • 示例:

    func ExampleLoadJson() {
    	jsonContent := `{"name":"john", "score":"100"}`
    	j, _ := gjson.LoadJson(jsonContent)
    	fmt.Println(j.Get("name"))
    	fmt.Println(j.Get("score"))
    
    	// Output:
    	// john
    	// 100
    }

LoadXml

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

  • 格式:

    func LoadXml(data interface{}, safe ...bool) (*Json, error)
  • 示例:

    func ExampleLoadXml() {
    	xmlContent := `<?xml version="1.0" encoding="UTF-8"?>
    	<base>
    		<name>john</name>
    		<score>100</score>
    	</base>`
    	j, _ := gjson.LoadXml(xmlContent)
    	fmt.Println(j.Get("base.name"))
    	fmt.Println(j.Get("base.score"))
    
    	// Output:
    	// john
    	// 100
    }

LoadIni

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

  • 格式:

    func LoadIni(data interface{}, safe ...bool) (*Json, error)
  • 示例:

    func ExampleLoadIni() {
    	iniContent := `
    	[base]
    	name = john
    	score = 100
    	`
    	j, _ := gjson.LoadIni(iniContent)
    	fmt.Println(j.Get("base.name"))
    	fmt.Println(j.Get("base.score"))
    
    	// Output:
    	// john
    	// 100
    }

LoadYaml

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

  • 格式:

    func LoadYaml(data interface{}, safe ...bool) (*Json, error)
  • 示例:

    func ExampleLoadYaml() {
    	yamlContent :=
    		`base:
      name: john
      score: 100`
    
    	j, _ := gjson.LoadYaml(yamlContent)
    	fmt.Println(j.Get("base.name"))
    	fmt.Println(j.Get("base.score"))
    
    	// Output:
    	// john
    	// 100
    }

LoadToml

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

  • 格式:

    func LoadToml(data interface{}, safe ...bool) (*Json, error)
  • 示例:

    func ExampleLoadToml() {
    	tomlContent :=
    		`[base]
      name = "john"
      score = 100`
    
    	j, _ := gjson.LoadToml(tomlContent)
    	fmt.Println(j.Get("base.name"))
    	fmt.Println(j.Get("base.score"))
    
    	// Output:
    	// john
    	// 100
    }

LoadContent

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

  • 格式:

    func LoadContent(data interface{}, safe ...bool) (*Json, error)
  • 示例:

    func ExampleLoadContent() {
    	jsonContent := `{"name":"john", "score":"100"}`
    
    	j, _ := gjson.LoadContent(jsonContent)
    
    	fmt.Println(j.Get("name"))
    	fmt.Println(j.Get("score"))
    
    	// Output:
    	// john
    	// 100
    }
    func ExampleLoadContent_UTF8BOM() {
    	jsonContent := `{"name":"john", "score":"100"}`
    
    	content := make([]byte, 3, len(jsonContent)+3)
    	content[0] = 0xEF
    	content[1] = 0xBB
    	content[2] = 0xBF
    	content = append(content, jsonContent...)
    
    	j, _ := gjson.LoadContent(content)
    
    	fmt.Println(j.Get("name"))
    	fmt.Println(j.Get("score"))
    
    	// Output:
    	// john
    	// 100
    }
    func ExampleLoadContent_Xml() {
    	xmlContent := `<?xml version="1.0" encoding="UTF-8"?>
    	<base>
    		<name>john</name>
    		<score>100</score>
    	</base>`
    
    	x, _ := gjson.LoadContent(xmlContent)
    
    	fmt.Println(x.Get("base.name"))
    	fmt.Println(x.Get("base.score"))
    
    	// Output:
    	// john
    	// 100
    }

LoadContentType

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

  • 格式:

    func LoadContentType(dataType string, data interface{}, safe ...bool) (*Json, error)
  • 示例:

    func ExampleLoadContentType() {
    	jsonContent := `{"name":"john", "score":"100"}`
    	xmlContent := `<?xml version="1.0" encoding="UTF-8"?>
    	<base>
    		<name>john</name>
    		<score>100</score>
    	</base>`
    
    	j, _ := gjson.LoadContentType("json", jsonContent)
    	x, _ := gjson.LoadContentType("xml", xmlContent)
    	j1, _ := gjson.LoadContentType("json", "")
    
    	fmt.Println(j.Get("name"))
    	fmt.Println(j.Get("score"))
    	fmt.Println(x.Get("base.name"))
    	fmt.Println(x.Get("base.score"))
    	fmt.Println(j1.Get(""))
    
    	// Output:
    	// john
    	// 100
    	// john
    	// 100
    }

IsValidDataType

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

  • 格式:

    func IsValidDataType(dataType string) bool
  • 示例:

    func ExampleIsValidDataType() {
    	fmt.Println(gjson.IsValidDataType("json"))
    	fmt.Println(gjson.IsValidDataType("yml"))
    	fmt.Println(gjson.IsValidDataType("js"))
    	fmt.Println(gjson.IsValidDataType("mp4"))
    	fmt.Println(gjson.IsValidDataType("xsl"))
    	fmt.Println(gjson.IsValidDataType("txt"))
    	fmt.Println(gjson.IsValidDataType(""))
    	fmt.Println(gjson.IsValidDataType(".json"))
    
    	// Output:
    	// true
    	// true
    	// true
    	// false
    	// false
    	// false
    	// false
    	// true
    }

Valid

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

  • 格式:

    func Valid(data interface{}) bool
  • 示例:

    func ExampleValid() {
    	data1 := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
    	data2 := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]`)
    	fmt.Println(gjson.Valid(data1))
    	fmt.Println(gjson.Valid(data2))
    
    	// Output:
    	// true
    	// false
    }

Marshal

  • 说明:MarshalEncode的别名。

  • 格式:

    func Marshal(v interface{}) (marshaledBytes []byte, err error)
  • 示例:

    func ExampleMarshal() {
    	data := map[string]interface{}{
    		"name":  "john",
    		"score": 100,
    	}
    
    	jsonData, _ := gjson.Marshal(data)
    	fmt.Println(string(jsonData))
    
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "Guo Qiang",
    		Age:  18,
    	}
    
    	infoData, _ := gjson.Marshal(info)
    	fmt.Println(string(infoData))
    
    	// Output:
    	// {"name":"john","score":100}
    	// {"Name":"Guo Qiang","Age":18}
    }

MarshalIndent

  • 说明:MarshalIndentjson.MarshalIndent的别名 。

  • 格式:

    func MarshalIndent(v interface{}, prefix, indent string) (marshaledBytes []byte, err error)
  • 示例:

    func ExampleMarshalIndent() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "John",
    		Age:  18,
    	}
    
    	infoData, _ := gjson.MarshalIndent(info, "", "\t")
    	fmt.Println(string(infoData))
    
    	// Output:
    	// {
    	//	"Name": "John",
    	//	"Age": 18
    	// }
    }

Unmarshal

  • 说明:UnmarshalDecodeTo的别名。

  • 格式:

    func Unmarshal(data []byte, v interface{}) (err error)
  • 示例:

    func ExampleUnmarshal() {
    	type BaseInfo struct {
    		Name  string
    		Score int
    	}
    
    	var info BaseInfo
    
    	jsonContent := "{\"name\":\"john\",\"score\":100}"
    	gjson.Unmarshal([]byte(jsonContent), &info)
    	fmt.Printf("%+v", info)
    
    	// Output:
    	// {Name:john Score:100}
    }

Encode

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

  • 格式:

    func Encode(value interface{}) ([]byte, error)
  • 示例:

    func ExampleEncode() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "John",
    		Age:  18,
    	}
    
    	infoData, _ := gjson.Encode(info)
    	fmt.Println(string(infoData))
    
    	// Output:
    	// {"Name":"John","Age":18}
    }

MustEncode

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

  • 格式:

    func MustEncode(value interface{}) []byte
  • 示例:

    func ExampleMustEncode() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "John",
    		Age:  18,
    	}
    
    	infoData := gjson.MustEncode(info)
    	fmt.Println(string(infoData))
    
    	// Output:
    	// {"Name":"John","Age":18}
    }

EncodeString

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

  • 格式:

    func EncodeString(value interface{}) (string, error)
  • 示例:

    func ExampleEncodeString() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "John",
    		Age:  18,
    	}
    
    	infoData, _ := gjson.EncodeString(info)
    	fmt.Println(infoData)
    
    	// Output:
    	// {"Name":"John","Age":18}
    }

MustEncodeString

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

  • 格式:

    func MustEncodeString(value interface{}) string
  • 示例:

    func ExampleMustEncodeString() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "John",
    		Age:  18,
    	}
    
    	infoData := gjson.MustEncodeString(info)
    	fmt.Println(infoData)
    
    	// Output:
    	// {"Name":"John","Age":18}
    }

Decode

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

  • 格式:

    func Decode(data interface{}, options ...Options) (interface{}, error)
  • 示例:

    func ExampleDecode() {
    	jsonContent := `{"name":"john","score":100}`
    	info, _ := gjson.Decode([]byte(jsonContent))
    	fmt.Println(info)
    
    	// Output:
    	// map[name:john score:100]
    }

DecodeTo

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

  • 格式:

    func DecodeTo(data interface{}, v interface{}, options ...Options) (err error)
  • 示例:

    func ExampleDecodeTo() {
    	type BaseInfo struct {
    		Name  string
    		Score int
    	}
    
    	var info BaseInfo
    
    	jsonContent := "{\"name\":\"john\",\"score\":100}"
    	gjson.DecodeTo([]byte(jsonContent), &info)
    	fmt.Printf("%+v", info)
    
    	// Output:
    	// {Name:john Score:100}
    }

DecodeToJson

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

  • 格式:

    func DecodeToJson(data interface{}, options ...Options) (*Json, error)
  • 示例:

    func ExampleDecodeToJson() {
    	jsonContent := `{"name":"john","score":100}"`
    	j, _ := gjson.DecodeToJson([]byte(jsonContent))
    	fmt.Println(j.Map())
    
    	// May Output:
    	// map[name:john score:100]
    }
    
    

SetSplitChar

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

  • 格式:

    func (j *Json) SetSplitChar(char byte)
  • 示例:

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

SetViolenceCheck

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

  • 格式:

    func (j *Json) SetViolenceCheck(enabled bool)
  • 示例:

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

ToJson

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

  • 格式:

    func (j *Json) ToJson() ([]byte, error)
  • 示例:

    func ExampleJson_ToJson() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "John",
    		Age:  18,
    	}
    
    	j := gjson.New(info)
    	jsonBytes, _ := j.ToJson()
    	fmt.Println(string(jsonBytes))
    
    	// Output:
    	// {"Age":18,"Name":"John"}
    }

ToJsonString

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

  • 格式:

    func (j *Json) ToJsonString() (string, error)
  • 示例:

    func ExampleJson_ToJsonString() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "John",
    		Age:  18,
    	}
    
    	j := gjson.New(info)
    	jsonStr, _ := j.ToJsonString()
    	fmt.Println(jsonStr)
    
    	// Output:
    	// {"Age":18,"Name":"John"}
    }

ToJsonIndent

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

  • 格式:

    func (j *Json) ToJsonIndent() ([]byte, error)
  • 示例:

    func ExampleJson_ToJsonIndent() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "John",
    		Age:  18,
    	}
    
    	j := gjson.New(info)
    	jsonBytes, _ := j.ToJsonIndent()
    	fmt.Println(string(jsonBytes))
    
    	// Output:
    	//{
    	//	"Age": 18,
    	//	"Name": "John"
    	//}
    }

ToJsonIndentString

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

  • 格式:

    func (j *Json) ToJsonIndentString() (string, error)
  • 示例:

    func ExampleJson_ToJsonIndentString() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "John",
    		Age:  18,
    	}
    
    	j := gjson.New(info)
    	jsonStr, _ := j.ToJsonIndentString()
    	fmt.Println(jsonStr)
    
    	// Output:
    	//{
    	//	"Age": 18,
    	//	"Name": "John"
    	//}
    }

MustToJson

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

  • 格式:

    func (j *Json) MustToJson() []byte
  • 示例:

    func ExampleJson_MustToJson() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "John",
    		Age:  18,
    	}
    
    	j := gjson.New(info)
    	jsonBytes := j.MustToJson()
    	fmt.Println(string(jsonBytes))
    
    	// Output:
    	// {"Age":18,"Name":"John"}
    }

MustToJsonString

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

  • 格式:

    func (j *Json) MustToJsonString() string
  • 示例:

    func ExampleJson_MustToJsonString() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "John",
    		Age:  18,
    	}
    
    	j := gjson.New(info)
    	jsonStr := j.MustToJsonString()
    	fmt.Println(jsonStr)
    
    	// Output:
    	// {"Age":18,"Name":"John"}
    }

MustToJsonIndent

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

  • 格式:

    func (j *Json) MustToJsonIndent() []byte
  • 示例:

    func ExampleJson_MustToJsonIndent() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "John",
    		Age:  18,
    	}
    
    	j := gjson.New(info)
    	jsonBytes := j.MustToJsonIndent()
    	fmt.Println(string(jsonBytes))
    
    	// Output:
    	//{
    	//	"Age": 18,
    	//	"Name": "John"
    	//}
    }

MustToJsonIndentString

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

  • 格式:

    func (j *Json) MustToJsonIndentString() string
  • 示例:

    func ExampleJson_MustToJsonIndentString() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "John",
    		Age:  18,
    	}
    
    	j := gjson.New(info)
    	jsonStr := j.MustToJsonIndentString()
    	fmt.Println(jsonStr)
    
    	// Output:
    	//{
    	//	"Age": 18,
    	//	"Name": "John"
    	//}
    }

ToXml

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

  • 格式:

    func (j *Json) ToXml(rootTag ...string) ([]byte, error)
  • 示例:

    func ExampleJson_ToXml() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "John",
    		Age:  18,
    	}
    
    	j := gjson.New(info)
    	xmlBytes, _ := j.ToXml()
    	fmt.Println(string(xmlBytes))
    
    	// Output:
    	// <doc><Age>18</Age><Name>John</Name></doc>
    }

ToXmlString

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

  • 格式:

    func (j *Json) ToXmlString(rootTag ...string) (string, error)
  • 示例:

    func ExampleJson_ToXmlString() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "John",
    		Age:  18,
    	}
    
    	j := gjson.New(info)
    	xmlStr, _ := j.ToXmlString()
    	fmt.Println(string(xmlStr))
    
    	// Output:
    	// <doc><Age>18</Age><Name>John</Name></doc>
    }

ToXmlIndent

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

  • 格式:

    func (j *Json) ToXmlIndent(rootTag ...string) ([]byte, error)
  • 示例:

    func ExampleJson_ToXmlIndent() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "John",
    		Age:  18,
    	}
    
    	j := gjson.New(info)
    	xmlBytes, _ := j.ToXmlIndent()
    	fmt.Println(string(xmlBytes))
    
    	// Output:
    	//<doc>
    	//	<Age>18</Age>
    	//	<Name>John</Name>
    	//</doc>
    }

ToXmlIndentString

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

  • 格式:

    func (j *Json) ToXmlIndentString(rootTag ...string) (string, error)
  • 示例:

    func ExampleJson_ToXmlIndentString() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "John",
    		Age:  18,
    	}
    
    	j := gjson.New(info)
    	xmlStr, _ := j.ToXmlIndentString()
    	fmt.Println(string(xmlStr))
    
    	// Output:
    	//<doc>
    	//	<Age>18</Age>
    	//	<Name>John</Name>
    	//</doc>
    }

MustToXml

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

  • 格式:

    func (j *Json) MustToXml(rootTag ...string) []byte
  • 示例:

    func ExampleJson_MustToXml() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "John",
    		Age:  18,
    	}
    
    	j := gjson.New(info)
    	xmlBytes := j.MustToXml()
    	fmt.Println(string(xmlBytes))
    
    	// Output:
    	// <doc><Age>18</Age><Name>John</Name></doc>
    }

MustToXmlString

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

  • 格式:

    func (j *Json) MustToXmlString(rootTag ...string) string
  • 示例:

    func ExampleJson_MustToXmlString() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "John",
    		Age:  18,
    	}
    
    	j := gjson.New(info)
    	xmlStr := j.MustToXmlString()
    	fmt.Println(string(xmlStr))
    
    	// Output:
    	// <doc><Age>18</Age><Name>John</Name></doc>
    }

MustToXmlIndent

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

  • 格式:

    func (j *Json) MustToXmlIndent(rootTag ...string) []byte
  • 示例:

    func ExampleJson_MustToXmlIndent() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "John",
    		Age:  18,
    	}
    
    	j := gjson.New(info)
    	xmlBytes := j.MustToXmlIndent()
    	fmt.Println(string(xmlBytes))
    
    	// Output:
    	//<doc>
    	//	<Age>18</Age>
    	//	<Name>John</Name>
    	//</doc>
    }


MustToXmlIndentString

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

  • 格式:

    func (j *Json) MustToXmlIndentString(rootTag ...string) string
  • 示例:

    func ExampleJson_MustToXmlIndentString() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "John",
    		Age:  18,
    	}
    
    	j := gjson.New(info)
    	xmlStr := j.MustToXmlIndentString()
    	fmt.Println(string(xmlStr))
    
    	// Output:
    	//<doc>
    	//	<Age>18</Age>
    	//	<Name>John</Name>
    	//</doc>
    }

ToYaml

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

  • 格式:

    func (j *Json) ToYaml() ([]byte, error)
  • 示例:

    func ExampleJson_ToYaml() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "John",
    		Age:  18,
    	}
    
    	j := gjson.New(info)
    	YamlBytes, _ := j.ToYaml()
    	fmt.Println(string(YamlBytes))
    
    	// Output:
    	//Age: 18
    	//Name: John
    }

ToYamlIndent

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

  • 格式:

    func (j *Json) ToYamlIndent(indent string) ([]byte, error)
  • 示例:

    func ExampleJson_ToYamlIndent() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "John",
    		Age:  18,
    	}
    
    	j := gjson.New(info)
    	YamlBytes, _ := j.ToYamlIndent("")
    	fmt.Println(string(YamlBytes))
    
    	// Output:
    	//Age: 18
    	//Name: John
    }

ToYamlString

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

  • 格式:

    func (j *Json) ToYamlString() (string, error)
  • 示例:

    func ExampleJson_ToYamlString() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "John",
    		Age:  18,
    	}
    
    	j := gjson.New(info)
    	YamlStr, _ := j.ToYamlString()
    	fmt.Println(string(YamlStr))
    
    	// Output:
    	//Age: 18
    	//Name: John
    }

MustToYaml

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

  • 格式:

    func (j *Json) MustToYaml() []byte
  • 示例:

    func ExampleJson_MustToYaml() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "John",
    		Age:  18,
    	}
    
    	j := gjson.New(info)
    	YamlBytes := j.MustToYaml()
    	fmt.Println(string(YamlBytes))
    
    	// Output:
    	//Age: 18
    	//Name: John
    }

MustToYamlString

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

  • 格式:

    func (j *Json) MustToYamlString() string
  • 示例:

    func ExampleJson_MustToYamlString() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "John",
    		Age:  18,
    	}
    
    	j := gjson.New(info)
    	YamlStr := j.MustToYamlString()
    	fmt.Println(string(YamlStr))
    
    	// Output:
    	//Age: 18
    	//Name: John
    }

ToToml

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

  • 格式:

    func (j *Json) ToToml() ([]byte, error)
  • 示例:

    func ExampleJson_ToToml() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "John",
    		Age:  18,
    	}
    
    	j := gjson.New(info)
    	TomlBytes, _ := j.ToToml()
    	fmt.Println(string(TomlBytes))
    
    	// Output:
    	//Age = 18
    	//Name = "John"
    }

ToTomlString

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

  • 格式:

    func (j *Json) ToTomlString() (string, error)
  • 示例:

    func ExampleJson_ToTomlString() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "John",
    		Age:  18,
    	}
    
    	j := gjson.New(info)
    	TomlStr, _ := j.ToTomlString()
    	fmt.Println(string(TomlStr))
    
    	// Output:
    	//Age = 18
    	//Name = "John"
    }

MustToToml

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

  • 格式:

    func (j *Json) MustToToml() []byte
  • 示例:

    func ExampleJson_MustToToml() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "John",
    		Age:  18,
    	}
    
    	j := gjson.New(info)
    	TomlBytes := j.MustToToml()
    	fmt.Println(string(TomlBytes))
    
    	// Output:
    	//Age = 18
    	//Name = "John"
    }

MustToTomlString

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

  • 格式:

    func (j *Json) MustToTomlString() string
  • 示例:

    func ExampleJson_MustToTomlString() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "John",
    		Age:  18,
    	}
    
    	j := gjson.New(info)
    	TomlStr := j.MustToTomlString()
    	fmt.Println(string(TomlStr))
    
    	// Output:
    	//Age = 18
    	//Name = "John"
    }

ToIni

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

  • 格式:

    func (j *Json) ToIni() ([]byte, error)
  • 示例:

    func ExampleJson_ToIni() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "John",
    		Age:  18,
    	}
    
    	j := gjson.New(info)
    	IniBytes, _ := j.ToIni()
    	fmt.Println(string(IniBytes))
    
    	// May Output:
    	//Name=John
    	//Age=18
    }

ToIniString

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

  • 格式:

    func (j *Json) ToIniString() (string, error)
  • 示例:

    func ExampleJson_ToIniString() {
    	type BaseInfo struct {
    		Name string
    	}
    
    	info := BaseInfo{
    		Name: "John",
    	}
    
    	j := gjson.New(info)
    	IniStr, _ := j.ToIniString()
    	fmt.Println(string(IniStr))
    
    	// Output:
    	//Name=John
    }

MustToIni

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

  • 格式:

    func (j *Json) MustToIni() []byte
  • 示例:

    func ExampleJson_MustToIni() {
    	type BaseInfo struct {
    		Name string
    	}
    
    	info := BaseInfo{
    		Name: "John",
    	}
    
    	j := gjson.New(info)
    	IniBytes := j.MustToIni()
    	fmt.Println(string(IniBytes))
    
    	// Output:
    	//Name=John
    }

MustToIniString

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

  • 格式:

    func (j *Json) MustToIniString() string
  • 示例:

    func ExampleJson_MustToIniString() {
    	type BaseInfo struct {
    		Name string
    	}
    
    	info := BaseInfo{
    		Name: "John",
    	}
    
    	j := gjson.New(info)
    	IniStr := j.MustToIniString()
    	fmt.Println(string(IniStr))
    
    	// Output:
    	//Name=John
    }

MarshalJSON

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

  • 格式:

    func (j Json) MarshalJSON() ([]byte, error)
  • 示例:

    func ExampleJson_MarshalJSON() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "John",
    		Age:  18,
    	}
    
    	j := gjson.New(info)
    	jsonBytes, _ := j.MarshalJSON()
    	fmt.Println(string(jsonBytes))
    
    	// Output:
    	// {"Age":18,"Name":"John"}
    }

UnmarshalJSON

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

  • 格式:

    func (j *Json) UnmarshalJSON(b []byte) error
  • 示例:

    func ExampleJson_UnmarshalJSON() {
    	jsonStr := `{"Age":18,"Name":"John"}`
    
    	j := gjson.New("")
    	j.UnmarshalJSON([]byte(jsonStr))
    	fmt.Println(j.Map())
    
    	// Output:
    	// map[Age:18 Name:John]
    }

UnmarshalValue

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

  • 格式:

    func (j *Json) UnmarshalValue(value interface{}) error
  • 示例:

    func ExampleJson_UnmarshalValue_Yaml() {
    	yamlContent :=
    		`base:
      name: john
      score: 100`
    
    	j := gjson.New("")
    	j.UnmarshalValue([]byte(yamlContent))
    	fmt.Println(j.Var().String())
    
    	// Output:
    	// {"base":{"name":"john","score":100}}
    }
    func ExampleJson_UnmarshalValue_Xml() {
    	xmlStr := `<?xml version="1.0" encoding="UTF-8"?><doc><name>john</name><score>100</score></doc>`
    
    	j := gjson.New("")
    	j.UnmarshalValue([]byte(xmlStr))
    	fmt.Println(j.Var().String())
    
    	// Output:
    	// {"doc":{"name":"john","score":"100"}}
    }

MapStrAny

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

  • 格式:

    func (j *Json) MapStrAny() map[string]interface{}
  • 示例:

    func ExampleJson_MapStrAny() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "John",
    		Age:  18,
    	}
    
    	j := gjson.New(info)
    	fmt.Println(j.MapStrAny())
    
    	// Output:
    	// map[Age:18 Name:John]
    }

Interfaces

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

  • 格式:

    func (j *Json) Interfaces() []interface{}
  • 示例:

    func ExampleJson_Interfaces() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	infoList := []BaseInfo{
    		BaseInfo{
    			Name: "John",
    			Age:  18,
    		},
    		BaseInfo{
    			Name: "Tom",
    			Age:  20,
    		},
    	}
    
    	j := gjson.New(infoList)
    	fmt.Println(j.Interfaces())
    
    	// Output:
    	// [{John 18} {Tom 20}]
    }

Interface

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

  • 格式:

    func (j *Json) Interface() interface{}
  • 示例:

    func ExampleJson_Interface() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "John",
    		Age:  18,
    	}
    
    	j := gjson.New(info)
    	fmt.Println(j.Interface())
    
    	var nilJ *gjson.Json = nil
    	fmt.Println(nilJ.Interface())
    
    	// Output:
    	// map[Age:18 Name:John]
    	// <nil>
    }

Var

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

  • 格式:

    func (j *Json) Var() *gvar.Var
  • 示例:

    func ExampleJson_Var() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "John",
    		Age:  18,
    	}
    
    	j := gjson.New(info)
    	fmt.Println(j.Var().String())
    	fmt.Println(j.Var().Map())
    
    	// Output:
    	// {"Age":18,"Name":"John"}
    	// map[Age:18 Name:John]
    }

IsNil

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

  • 格式:

    func (j *Json) IsNil() bool
  • 示例:

    func ExampleJson_IsNil() {
    	data1 := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
    	data2 := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]`)
    
    	j1, _ := gjson.LoadContent(data1)
    	fmt.Println(j1.IsNil())
    
    	j2, _ := gjson.LoadContent(data2)
    	fmt.Println(j2.IsNil())
    
    	// Output:
    	// false
    	// true
    }

Get

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

  • 格式:

    func (j *Json) Get(pattern string, def ...interface{}) *gvar.Var
  • 示例:

    func ExampleJson_Get() {
    	data :=
    		`{
            "users" : {
                "count" : 1,
                "array" : ["John", "Ming"]
            }
        }`
    
    	j, _ := gjson.LoadContent(data)
    	fmt.Println(j.Get("."))
    	fmt.Println(j.Get("users"))
    	fmt.Println(j.Get("users.count"))
    	fmt.Println(j.Get("users.array"))
    
    	var nilJ *gjson.Json = nil
    	fmt.Println(nilJ.Get("."))
    
    	// Output:
    	// {"users":{"array":["John","Ming"],"count":1}}
    	// {"array":["John","Ming"],"count":1}
    	// 1
    	// ["John","Ming"]
    }

GetJson

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

  • 格式:

    func (j *Json) GetJson(pattern string, def ...interface{}) *Json
  • 示例:

    func ExampleJson_GetJson() {
    	data :=
    		`{
            "users" : {
                "count" : 1,
                "array" : ["John", "Ming"]
            }
        }`
    
    	j, _ := gjson.LoadContent(data)
    
    	fmt.Println(j.GetJson("users.array").Array())
    
    	// Output:
    	// [John Ming]
    }

GetJsons

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

  • 格式:

    func (j *Json) GetJsons(pattern string, def ...interface{}) []*Json
  • 示例:

    func ExampleJson_GetJsons() {
    	data :=
    		`{
            "users" : {
                "count" : 3,
                "array" : [{"Age":18,"Name":"John"}, {"Age":20,"Name":"Tom"}]
            }
        }`
    
    	j, _ := gjson.LoadContent(data)
    
    	jsons := j.GetJsons("users.array")
    	for _, json := range jsons {
    		fmt.Println(json.Interface())
    	}
    
    	// Output:
    	// map[Age:18 Name:John]
    	// map[Age:20 Name:Tom]
    }

GetJsonMap

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

  • 格式:

    func (j *Json) GetJsonMap(pattern string, def ...interface{}) map[string]*Json
  • 示例:

    func ExampleJson_GetJsonMap() {
    	data :=
    		`{
            "users" : {
                "count" : 1,
    			"array" : {
    				"info" : {"Age":18,"Name":"John"},
    				"addr" : {"City":"Chengdu","Company":"Tencent"}
    			}
            }
        }`
    
    	j, _ := gjson.LoadContent(data)
    
    	jsonMap := j.GetJsonMap("users.array")
    
    	for _, json := range jsonMap {
    		fmt.Println(json.Interface())
    	}
    
    	// May Output:
    	// map[City:Chengdu Company:Tencent]
    	// map[Age:18 Name:John]
    }

Set

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

  • 格式:

    func (j *Json) Set(pattern string, value interface{}) error
  • 示例:

    func ExampleJson_Set() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "John",
    		Age:  18,
    	}
    
    	j := gjson.New(info)
    	j.Set("Addr", "ChengDu")
    	j.Set("Friends.0", "Tom")
    	fmt.Println(j.Var().String())
    
    	// Output:
    	// {"Addr":"ChengDu","Age":18,"Friends":["Tom"],"Name":"John"}
    }

MustSet

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

  • 格式:

    func (j *Json) MustSet(pattern string, value interface{})
  • 示例:

    func ExampleJson_MustSet() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "John",
    		Age:  18,
    	}
    
    	j := gjson.New(info)
    	j.MustSet("Addr", "ChengDu")
    	fmt.Println(j.Var().String())
    
    	// Output:
    	// {"Addr":"ChengDu","Age":18,"Name":"John"}
    }

Remove

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

  • 格式:

    func (j *Json) Remove(pattern string) error
  • 示例:

    func ExampleJson_Remove() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "John",
    		Age:  18,
    	}
    
    	j := gjson.New(info)
    	j.Remove("Age")
    	fmt.Println(j.Var().String())
    
    	// Output:
    	// {"Name":"John"}
    }

MustRemove

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

  • 格式:

    func (j *Json) MustRemove(pattern string)
  • 示例:

    func ExampleJson_MustRemove() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "John",
    		Age:  18,
    	}
    
    	j := gjson.New(info)
    	j.MustRemove("Age")
    	fmt.Println(j.Var().String())
    
    	// Output:
    	// {"Name":"John"}
    }

Contains

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

  • 格式:

    func (j *Json) Contains(pattern string) bool
  • 示例:

    func ExampleJson_Contains() {
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{
    		Name: "John",
    		Age:  18,
    	}
    
    	j := gjson.New(info)
    	fmt.Println(j.Contains("Age"))
    	fmt.Println(j.Contains("Addr"))
    
    	// Output:
    	// true
    	// false
    }

Len

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

  • 格式:

    func (j *Json) Len(pattern string) int
  • 示例:

    func ExampleJson_Len() {
    	data :=
    		`{
            "users" : {
                "count" : 1,
    			"nameArray" : ["Join", "Tom"],
    			"infoMap" : {
    				"name" : "Join",
    				"age" : 18,
    				"addr" : "ChengDu"
    			}
            }
        }`
    
    	j, _ := gjson.LoadContent(data)
    
    	fmt.Println(j.Len("users.nameArray"))
    	fmt.Println(j.Len("users.infoMap"))
    
    	// Output:
    	// 2
    	// 3
    }

Append

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

  • 格式:

    func (j *Json) Append(pattern string, value interface{}) error
  • 示例:

    func ExampleJson_Append() {
    	data :=
    		`{
            "users" : {
                "count" : 1,
                "array" : ["John", "Ming"]
            }
        }`
    
    	j, _ := gjson.LoadContent(data)
    
    	j.Append("users.array", "Lily")
    
    	fmt.Println(j.Get("users.array").Array())
    
    	// Output:
    	// [John Ming Lily]
    }

MustAppend

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

  • 格式:

    func (j *Json) MustAppend(pattern string, value interface{})
  • 示例:

    func ExampleJson_MustAppend() {
    	data :=
    		`{
            "users" : {
                "count" : 1,
                "array" : ["John", "Ming"]
            }
        }`
    
    	j, _ := gjson.LoadContent(data)
    
    	j.MustAppend("users.array", "Lily")
    
    	fmt.Println(j.Get("users.array").Array())
    
    	// Output:
    	// [John Ming Lily]
    }

Map

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

  • 格式:

    func (j *Json) Map() map[string]interface{}
  • 示例:

    func ExampleJson_Map() {
    	data :=
    		`{
            "users" : {
                "count" : 1,
                "info" : {
    				"name" : "John",
    				"age" : 18,
    				"addr" : "ChengDu"
    			}
            }
        }`
    
    	j, _ := gjson.LoadContent(data)
    
    	fmt.Println(j.Get("users.info").Map())
    
    	// Output:
    	// map[addr:ChengDu age:18 name:John]
    }

Array

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

  • 格式:

    func (j *Json) Array() []interface{}
  • 示例:

    func ExampleJson_Array() {
    	data :=
    		`{
            "users" : {
                "count" : 1,
                "array" : ["John", "Ming"]
            }
        }`
    
    	j, _ := gjson.LoadContent(data)
    
    	fmt.Println(j.Get("users.array"))
    
    	// Output:
    	// ["John","Ming"]
    }

Scan

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

  • 格式:

    func (j *Json) Scan(pointer interface{}, mapping ...map[string]string) error
  • 示例:

    func ExampleJson_Scan() {
    	data := `{"name":"john","age":"18"}`
    
    	type BaseInfo struct {
    		Name string
    		Age  int
    	}
    
    	info := BaseInfo{}
    
    	j, _ := gjson.LoadContent(data)
    	j.Scan(&info)
    
    	fmt.Println(info)
    
    	// May Output:
    	// {john 18}
    }

Dump

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

  • 格式:

    func (j *Json) Dump()
  • 示例:

    func ExampleJson_Dump() {
    	data := `{"name":"john","age":"18"}`
    
    	j, _ := gjson.LoadContent(data)
    	j.Dump()
    
    	// May Output:
    	//{
    	//	"name": "john",
    	//	"age":  "18",
    	//}
    }
Content Menu

  • No labels

1 Comment

  1. 黄骞 顶部 点击 参考代码文档,跳转到的网址错误