get json values quickly

GJSON is a Go package that provides a  and  way to get values from a json document. It has features such as , , , and .

Also check out  for modifying json, and the  command line tool.

Getting Started

Installing

To start using GJSON, install Go and run go get:

$ go get -u github.com/tidwall/gjson

This will retrieve the library.

Get a value

Get searches json for the specified path. A path is in dot syntax, such as "name.last" or "age". When the value is found it's returned immediately.

package mainimport "github.com/tidwall/gjson"const json = `{"name":{"first":"Janet","last":"Prichard"},"age":47}`func main() {	value := gjson.Get(json, "name.last")	println(value.String())}

This will print:

Prichard

There's also the  function to get multiple values at once, and  for working with JSON byte slices.

Path Syntax

A path is a series of keys separated by a dot. A key may contain special wildcard characters '*' and '?'. To access an array value use the index as the key. To get the number of elements in an array or to access a child path, use the '#' character. The dot and wildcard characters can be escaped with '\'.

{  "name": {"first": "Tom", "last": "Anderson"},  "age":37,  "children": ["Sara","Alex","Jack"],  "fav.movie": "Deer Hunter",  "friends": [    {"first": "Dale", "last": "Murphy", "age": 44},    {"first": "Roger", "last": "Craig", "age": 68},    {"first": "Jane", "last": "Murphy", "age": 47}  ]}

"name.last"          >> "Anderson""age"                >> 37"children"           >> ["Sara","Alex","Jack"]"children.#"         >> 3"children.1"         >> "Alex""child*.2"           >> "Jack""c?ildren.0"         >> "Sara""fav\.movie"         >> "Deer Hunter""friends.#.first"    >> ["Dale","Roger","Jane"]"friends.1.last"     >> "Craig"

You can also query an array for the first match by using #[...], or find all matches with #[...]#. Queries support the ==, !=, <, <=, >, >= comparison operators and the simple pattern matching % operator.

friends.#[last=="Murphy"].first    >> "Dale"friends.#[last=="Murphy"]#.first   >> ["Dale","Jane"]friends.#[age>45]#.last            >> ["Craig","Murphy"]friends.#[first%"D*"].last         >> "Murphy"

JSON Lines

There's support for  using the .. prefix, which treats a multilined document as an array.

For example:

{"name": "Gilbert", "age": 61}{"name": "Alexa", "age": 34}{"name": "May", "age": 57}{"name": "Deloise", "age": 44}

..#                   >> 4..1                   >> {"name": "Alexa", "age": 34}..3                   >> {"name": "Deloise", "age": 44}..#.name              >> ["Gilbert","Alexa","May","Deloise"]..#[name="May"].age   >> 57

The ForEachLines function will iterate through JSON lines.

gjson.ForEachLine(json, func(line gjson.Result) bool{    println(line.String())    return true})

Result Type

GJSON supports the json types string, number, bool, and null. Arrays and Objects are returned as their raw json types.

The Result type holds one of these:

bool, for JSON booleansfloat64, for JSON numbersstring, for JSON string literalsnil, for JSON null

To directly access the value:

result.Type    // can be String, Number, True, False, Null, or JSONresult.Str     // holds the stringresult.Num     // holds the float64 numberresult.Raw     // holds the raw jsonresult.Index   // index of raw value in original json, zero means index unknown

There are a variety of handy functions that work on a result:

result.Exists() boolresult.Value() interface{}result.Int() int64result.Uint() uint64result.Float() float64result.String() stringresult.Bool() boolresult.Time() time.Timeresult.Array() []gjson.Resultresult.Map() map[string]gjson.Resultresult.Get(path string) Resultresult.ForEach(iterator func(key, value Result) bool)result.Less(token Result, caseSensitive bool) bool

The result.Value() function returns an interface{} which requires type assertion and is one of the following Go types:

The result.Array() function returns back an array of values. If the result represents a non-existent value, then an empty array will be returned. If the result is not a JSON array, the return value will be an array containing one result.

boolean >> boolnumber  >> float64string  >> stringnull    >> nilarray   >> []interface{}object  >> map[string]interface{}

64-bit integers

The result.Int() and result.Uint() calls are capable of reading all 64 bits, allowing for large JSON integers.

result.Int() int64    // -9223372036854775808 to 9223372036854775807result.Uint() int64   // 0 to 18446744073709551615

Get nested array values

Suppose you want all the last names from the following json:

{  "programmers": [    {      "firstName": "Janet",       "lastName": "McLaughlin",     }, {      "firstName": "Elliotte",       "lastName": "Hunter",     }, {      "firstName": "Jason",       "lastName": "Harold",     }  ]}

You would use the path "programmers.#.lastName" like such:

result := gjson.Get(json, "programmers.#.lastName")for _, name := range result.Array() {	println(name.String())}

You can also query an object inside an array:

name := gjson.Get(json, `programmers.#[lastName="Hunter"].firstName`)println(name.String())  // prints "Elliotte"

Iterate through an object or array

The ForEach function allows for quickly iterating through an object or array. The key and value are passed to the iterator function for objects. Only the value is passed for arrays. Returning false from an iterator will stop iteration.

result := gjson.Get(json, "programmers")result.ForEach(func(key, value gjson.Result) bool {	println(value.String()) 	return true // keep iterating})

Simple Parse and Get

There's a Parse(json) function that will do a simple parse, and result.Get(path) that will search a result.

For example, all of these will return the same result:

gjson.Parse(json).Get("name").Get("last")gjson.Get(json, "name").Get("last")gjson.Get(json, "name.last")

Check for the existence of a value

Sometimes you just want to know if a value exists.

value := gjson.Get(json, "name.last")if !value.Exists() {	println("no last name")} else {	println(value.String())}// Or as one stepif gjson.Get(json, "name.last").Exists() {	println("has a last name")}

Validate JSON

The Get* and Parse* functions expects that the json is well-formed. Bad json will not panic, but it may return back unexpected results.

If you are consuming JSON from an unpredictable source then you may want to validate prior to using GJSON.

if !gjson.Valid(json) {	return errors.New("invalid json")}value := gjson.Get(json, "name.last")

Unmarshal to a map

To unmarshal to a map[string]interface{}:

m, ok := gjson.Parse(json).Value().(map[string]interface{})if !ok {	// not a map}

Working with Bytes

If your JSON is contained in a []byte slice, there's the  function. This is preferred over Get(string(data), path).

var json []byte = ...result := gjson.GetBytes(json, path)

If you are using the gjson.GetBytes(json, path) function and you want to avoid converting result.Raw to a []byte, then you can use this pattern:

var json []byte = ...result := gjson.GetBytes(json, path)var raw []byteif result.Index > 0 {    raw = json[result.Index:result.Index+len(result.Raw)]} else {    raw = []byte(result.Raw)}

This is a best-effort no allocation sub slice of the original json. This method utilizes the result.Index field, which is the position of the raw data in the original json. It's possible that the value of result.Index equals zero, in which case the result.Raw is converted to a []byte.

Get multiple values at once

The GetMany function can be used to get multiple values at the same time.

results := gjson.GetMany(json, "name.first", "name.last", "age")

The return value is a []Result, which will always contain exactly the same number of items as the input paths.

Performance

Benchmarks of GJSON alongside , , , , and 

BenchmarkGJSONGet-8                  3000000        372 ns/op          0 B/op         0 allocs/opBenchmarkGJSONUnmarshalMap-8          900000       4154 ns/op       1920 B/op        26 allocs/opBenchmarkJSONUnmarshalMap-8           600000       9019 ns/op       3048 B/op        69 allocs/opBenchmarkJSONDecoder-8                300000      14120 ns/op       4224 B/op       184 allocs/opBenchmarkFFJSONLexer-8               1500000       3111 ns/op        896 B/op         8 allocs/opBenchmarkEasyJSONLexer-8             3000000        887 ns/op        613 B/op         6 allocs/opBenchmarkJSONParserGet-8             3000000        499 ns/op         21 B/op         0 allocs/opBenchmarkJSONIterator-8              3000000        812 ns/op        544 B/op         9 allocs/op

JSON document used:

{  "widget": {    "debug": "on",    "window": {      "title": "Sample Konfabulator Widget",      "name": "main_window",      "width": 500,      "height": 500    },    "image": {       "src": "Images/Sun.png",      "hOffset": 250,      "vOffset": 250,      "alignment": "center"    },    "text": {      "data": "Click Here",      "size": 36,      "style": "bold",      "vOffset": 100,      "alignment": "center",      "onMouseUp": "sun1.opacity = (sun1.opacity / 100) * 90;"    }  }}

Each operation was rotated though one of the following search paths:

widget.window.namewidget.image.hOffsetwidget.text.onMouseUp

These benchmarks were run on a MacBook Pro 15" 2.8 GHz Intel Core i7 using Go 1.8 and can be be found .

Contact

Josh Baker 

License

GJSON source code is available under the MIT .