import "github.com/gogf/gf/encoding/gjson"
Package gjson provides convenient API for JSON/XML/INI/YAML/TOML data handling.
Code:
data := `{ "users" : { "count" : 1, "array" : ["John", "Ming"] } }` if j, err := gjson.DecodeToJson(data); err != nil { panic(err) } else { type Users struct { Count int Array []string } users := new(Users) if err := j.GetStruct("users", users); err != nil { panic(err) } fmt.Printf(`%+v`, users) }
Output:
&{Count:1 Array:[John Ming]}
Code:
data := `{ "users" : { "count" : 1, "array" : ["John", "Ming"] } }` if j, err := gjson.DecodeToJson(data); err != nil { panic(err) } else { fmt.Println("JSON:") fmt.Println(j.MustToJsonString()) fmt.Println("======================") fmt.Println("XML:") fmt.Println(j.MustToXmlString()) fmt.Println("======================") fmt.Println("YAML:") fmt.Println(j.MustToYamlString()) fmt.Println("======================") fmt.Println("TOML:") fmt.Println(j.MustToTomlString()) }
Output:
JSON: {"users":{"array":["John","Ming"],"count":1}} ====================== XML: <users><array>John</array><array>Ming</array><count>1</count></users> ====================== YAML: users: array: - John - Ming count: 1 ====================== TOML: [users] array = ["John", "Ming"] count = 1.0
Code:
data := ` { "count" : 1, "array" : ["John", "Ming"] }` if j, err := gjson.DecodeToJson(data); err != nil { panic(err) } else { type Users struct { Count int Array []string } users := new(Users) if err := j.ToStruct(users); err != nil { panic(err) } fmt.Printf(`%+v`, users) }
Output:
&{Count:1 Array:[John Ming]}
Code:
j := gjson.New(nil) j.Set("name", "John") j.Set("score", 99.5) fmt.Printf( "Name: %s, Score: %v\n", j.GetString("name"), j.GetFloat32("score"), ) fmt.Println(j.MustToJsonString())
Output:
Name: John, Score: 99.5 {"name":"John","score":99.5}
Code:
j := gjson.New(nil) for i := 0; i < 5; i++ { j.Set(fmt.Sprintf(`%d.id`, i), i) j.Set(fmt.Sprintf(`%d.name`, i), fmt.Sprintf(`student-%d`, i)) } fmt.Println(j.MustToJsonString())
Output:
[{"id":0,"name":"student-0"},{"id":1,"name":"student-1"},{"id":2,"name":"student-2"},{"id":3,"name":"student-3"},{"id":4,"name":"student-4"}]
Code:
data := `{ "users" : { "count" : 2, "list" : [ {"name" : "Ming", "score" : 60}, {"name" : "John", "score" : 59} ] } }` if j, err := gjson.DecodeToJson(data); err != nil { panic(err) } else { j.Set("users.list.1.score", 100) fmt.Println("John Score:", j.GetFloat32("users.list.1.score")) fmt.Println(j.MustToJsonString()) }
Output:
John Score: 100 {"users":{"count":2,"list":[{"name":"Ming","score":60},{"name":"John","score":100}]}}
Code:
jsonContent := `{"name":"john", "score":"100"}` j, _ := gjson.LoadContent(jsonContent) fmt.Println(j.Get("name")) fmt.Println(j.Get("score"))
Output:
john 100
Code:
jsonFilePath := gdebug.TestDataPath("json", "data1.json") j, _ := gjson.Load(jsonFilePath) fmt.Println(j.Get("name")) fmt.Println(j.Get("score"))
Code:
jsonFilePath := gdebug.TestDataPath("xml", "data1.xml") j, _ := gjson.Load(jsonFilePath) fmt.Println(j.Get("doc.name")) fmt.Println(j.Get("doc.score"))
Code:
jsonContent := `{"map":{"key":"value"}, "slice":[59,90]}` j, _ := gjson.LoadJson(jsonContent) m := j.GetMap("map") fmt.Println(m) // Change the key-value pair. m["key"] = "john" // It changes the underlying key-value pair. fmt.Println(j.GetMap("map")) s := j.GetArray("slice") fmt.Println(s) // Change the value of specified index. s[0] = 100 // It changes the underlying slice. fmt.Println(j.GetArray("slice"))
Output:
map[key:value] map[key:john] [59 90] [100 90]
Code:
jsonContent := `{"name":"john", "score":"100"}` j := gjson.New(jsonContent) fmt.Println(j.Get("name")) fmt.Println(j.Get("score"))
Output:
john 100
Code:
type Me struct { Name string `json:"name"` Score int `json:"score"` } me := Me{ Name: "john", Score: 100, } j := gjson.New(me) fmt.Println(j.Get("name")) fmt.Println(j.Get("score"))
Output:
john 100
Code:
type Me struct {
Name string `tag:"name"`
Score int `tag:"score"`
Title string
}
me := Me{
Name: "john",
Score: 100,
Title: "engineer",
}
// The parameter <tags> specifies custom priority tags for struct conversion to map,
// multiple tags joined with char ','.
j := gjson.NewWithTag(me, "tag")
fmt.Println(j.Get("name"))
fmt.Println(j.Get("score"))
fmt.Println(j.Get("Title"))
Output:
john 100 engineer
Code:
jsonContent := `<?xml version="1.0" encoding="UTF-8"?><doc><name>john</name><score>100</score></doc>`
j := gjson.New(jsonContent)
// Note that there's root node in the XML content.
fmt.Println(j.Get("doc.name"))
fmt.Println(j.Get("doc.score"))
Output:
john 100
Code:
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.GetFloat32("users#list#1#score")) }
Output:
John Score: 99.5
Code:
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 { fmt.Println("John Score:", j.GetFloat32("users.list.1.score")) }
Output:
John Score: 99.5
Code:
data := `{ "users" : { "count" : 100 }, "users.count" : 101 }` if j, err := gjson.DecodeToJson(data); err != nil { panic(err) } else { j.SetViolenceCheck(true) fmt.Println("Users Count:", j.GetInt("users.count")) }
Output:
Users Count: 101
gjson.go gjson_api.go gjson_api_config.go gjson_api_encoding.go gjson_api_new_load.go gjson_deprecated.go gjson_implements.go gjson_stdlib_json_util.go
Decode decodes json format <data> to golang variable. The parameter <data> can be either bytes or string type.
Decode decodes json format <data> to specified golang variable <v>. The parameter <data> can be either bytes or string type. The parameter <v> should be a pointer type.
Encode encodes any golang variable <value> to JSON bytes.
IsValidDataType checks and returns whether given <dataType> a valid data type for loading.
Valid checks whether <data> is a valid JSON data type. The parameter <data> specifies the json format data, which can be either bytes or string type.
type Json struct {
// contains filtered or unexported fields
}
The customized JSON struct.
DecodeToJson codes json format <data> to a Json object. The parameter <data> can be either bytes or string type.
Load loads content from specified file <path>, and creates a Json object from its content.
LoadContent creates a Json object from given content, it checks the data type of <content> automatically, supporting data content type as follows: JSON, XML, INI, YAML and TOML.
LoadContentType creates a Json object from given type and content, supporting data content type as follows: JSON, XML, INI, YAML and TOML.
LoadIni creates a Json object from given INI format content.
LoadJson creates a Json object from given JSON format content.
LoadToml creates a Json object from given TOML format content.
LoadXml creates a Json object from given XML format content.
LoadYaml creates a Json object from given YAML format content.
New creates a Json object with any variable type of <data>, but <data> should be a map or slice for data access reason, or it will make no sense.
The parameter <safe> specifies whether using this Json object in concurrent-safe context, which is false in default.
NewWithOption creates a Json object with any variable type of <data>, but <data> should be a map or slice for data access reason, or it will make no sense.
NewWithTag creates a Json object with any variable type of <data>, but <data> should be a map or slice for data access reason, or it will make no sense.
The parameter <tags> specifies priority tags for struct conversion to map, multiple tags joined with char ','.
The parameter <safe> specifies whether using this Json object in concurrent-safe context, which is false in default.
Append appends value to the value by specified <pattern>. The target value by <pattern> should be type of slice.
Array converts current Json object to []interface{}. It returns nil if fails.
Contains checks whether the value by specified <pattern> exist.
Dump prints current Json object with more manually readable.
Export returns <j> as a string with more manually readable.
Get retrieves and returns value by specified <pattern>. It returns all values of current Json object if <pattern> is given empty or string ".". It returns nil if no value found by <pattern>.
We can also access slice item by its index number in <pattern> like: "list.10", "array.0.name", "array.0.1.id".
It returns a default value specified by <def> if value for <pattern> is not found.
GetArray retrieves the value by specified <pattern>, and converts it to a slice of []interface{}.
GetBool retrieves the value by specified <pattern>, converts and returns it as bool. It returns false when value is: "", 0, false, off, nil; or returns true instead.
GetBytes retrieves the value by specified <pattern> and converts it to []byte.
GetDuration retrieves the value by specified <pattern> and converts it to time.Duration.
GetFloat32 retrieves the value by specified <pattern> and converts it to float32.
GetFloat64 retrieves the value by specified <pattern> and converts it to float64.
GetFloats retrieves the value by specified <pattern> and converts it to []float64.
GetGTime retrieves the value by specified <pattern> and converts it to *gtime.Time.
GetInt retrieves the value by specified <pattern> and converts it to int.
GetInt16 retrieves the value by specified <pattern> and converts it to int16.
GetInt32 retrieves the value by specified <pattern> and converts it to int32.
GetInt64 retrieves the value by specified <pattern> and converts it to int64.
GetInt8 retrieves the value by specified <pattern> and converts it to int8.
GetInterfaces is alias of GetArray. See GetArray.
GetInts retrieves the value by specified <pattern> and converts it to []int.
GetJson gets the value by specified <pattern>, and converts it to a un-concurrent-safe Json object.
GetJsonMap gets the value by specified <pattern>, and converts it to a map of un-concurrent-safe Json object.
GetJsons gets the value by specified <pattern>, and converts it to a slice of un-concurrent-safe Json object.
GetMap retrieves and returns the value by specified <pattern> as map[string]interface{}.
GetMapStrStr retrieves and returns the value by specified <pattern> as map[string]string.
func (j *Json) GetMapToMap(pattern string, pointer interface{}, mapping ...map[string]string) error
GetMapToMap retrieves the value by specified <pattern> and converts it to specified map variable. See gconv.MapToMap.
func (j *Json) GetMapToMapDeep(pattern string, pointer interface{}, mapping ...map[string]string) error
GetMapToMapDeep retrieves the value by specified <pattern> and converts it to specified map variable recursively. See gconv.MapToMapDeep.
func (j *Json) GetMapToMaps(pattern string, pointer interface{}, mapping ...map[string]string) error
GetMapToMaps retrieves the value by specified <pattern> and converts it to specified map slice variable. See gconv.MapToMaps.
func (j *Json) GetMapToMapsDeep(pattern string, pointer interface{}, mapping ...map[string]string) error
GetMapToMapsDeep retrieves the value by specified <pattern> and converts it to specified map slice variable recursively. See gconv.MapToMapsDeep.
GetMaps retrieves and returns the value by specified <pattern> as []map[string]interface{}.
GetScan automatically calls Struct or Structs function according to the type of parameter <pointer> to implement the converting..
func (j *Json) GetScanDeep(pattern string, pointer interface{}, mapping ...map[string]string) error
GetScanDeep automatically calls StructDeep or StructsDeep function according to the type of parameter <pointer> to implement the converting..
GetString retrieves the value by specified <pattern> and converts it to string.
GetStrings retrieves the value by specified <pattern> and converts it to []string.
GetStruct retrieves the value by specified <pattern> and converts it to specified object <pointer>. The <pointer> should be the pointer to an object.
func (j *Json) GetStructDeep(pattern string, pointer interface{}, mapping ...map[string]string) error
GetStructDeep does GetStruct recursively. Deprecated, use GetStruct instead.
GetStructs converts any slice to given struct slice.
func (j *Json) GetStructsDeep(pattern string, pointer interface{}, mapping ...map[string]string) error
GetStructsDeep converts any slice to given struct slice recursively. Deprecated, use GetStructs instead.
GetTime retrieves the value by specified <pattern> and converts it to time.Time.
GetUint retrieves the value by specified <pattern> and converts it to uint.
GetUint16 retrieves the value by specified <pattern> and converts it to uint16.
GetUint32 retrieves the value by specified <pattern> and converts it to uint32.
GetUint64 retrieves the value by specified <pattern> and converts it to uint64.
GetUint8 retrieves the value by specified <pattern> and converts it to uint8.
GetVar returns a gvar.Var with value by given <pattern>.
GetVars returns []*gvar.Var with value by given <pattern>.
IsNil checks whether the value pointed by <j> is nil.
Len returns the length/size of the value by specified <pattern>. The target value by <pattern> should be type of slice or map. It returns -1 if the target value is not found, or its type is invalid.
Map converts current Json object to map[string]interface{}. It returns nil if fails.
MapToMap converts current Json object to specified map variable. The parameter of <pointer> should be type of *map.
MapToMaps converts current Json object to specified map variable slice. The parameter of <pointer> should be type of []map/*map.
MarshalJSON implements the interface MarshalJSON for json.Marshal.
Remove deletes value with specified <pattern>. It supports hierarchical data access by char separator, which is '.' in default.
Scan automatically calls Struct or Structs function according to the type of parameter <pointer> to implement the converting..
Set sets value with specified <pattern>. It supports hierarchical data access by char separator, which is '.' in default.
SetSplitChar sets the separator char for hierarchical data access.
SetViolenceCheck enables/disables violence check for hierarchical data access.
Struct converts current Json object to specified object. The <pointer> should be a pointer type of *struct.
Structs converts current Json object to specified object slice. The <pointer> should be a pointer type of []struct/*struct.
ToArray converts current Json object to []interface{}. It returns nil if fails. Deprecated, use Array instead.
ToMap converts current Json object to map[string]interface{}. It returns nil if fails. Deprecated, use Map instead.
ToMapToMap converts current Json object to specified map variable. The parameter of <pointer> should be type of *map. Deprecated, use MapToMap instead.
ToMapToMapDeep converts current Json object to specified map variable recursively. The parameter of <pointer> should be type of *map. Deprecated, use MapToMap instead.
ToMapToMaps converts current Json object to specified map variable slice. The parameter of <pointer> should be type of []map/*map. Deprecated, use MapToMaps instead.
ToMapToMapsDeep converts current Json object to specified map variable slice recursively. The parameter of <pointer> should be type of []map/*map. Deprecated, use MapToMaps instead.
ToScan automatically calls Struct or Structs function according to the type of parameter <pointer> to implement the converting.. Deprecated, use Scan instead.
ToScanDeep automatically calls StructDeep or StructsDeep function according to the type of parameter <pointer> to implement the converting.. Deprecated, use Scan instead.
ToStruct converts current Json object to specified object. The <pointer> should be a pointer type of *struct. Deprecated, use Struct instead.
ToStructDeep converts current Json object to specified object recursively. The <pointer> should be a pointer type of *struct. Deprecated, use Struct instead.
ToStructs converts current Json object to specified object slice. The <pointer> should be a pointer type of []struct/*struct. Deprecated, use Structs instead.
ToStructsDeep converts current Json object to specified object slice recursively. The <pointer> should be a pointer type of []struct/*struct. Deprecated, use Structs instead.
UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
UnmarshalValue is an interface implement which sets any type of value for Json.
Value returns the json value.
Var returns the json value as *gvar.Var.
type Option struct { Safe bool // Mark this object is for in concurrent-safe usage. Tags string // Custom priority tags for decoding. StrNumber bool // StrNumber causes the Decoder to unmarshal a number into an interface{} as a string instead of as a float64. }
Option for Json object creating.
Package gjson imports 20 packages (graph) and is imported by 10 packages. Updated 2021-01-19. Refresh now. Tools for package owners.