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. A

String returns a string representation of the type.

Parse parses the json and returns a result. This function expects that the json is well-formed, and does not validate. Invalid json will not panic, b

Int returns an integer representation.

Exists returns true if value exists. if gjson.Get(json, "name.last").Exists(){ println("value exists") }

ForEach iterates through values. If the result represents a non-existent value, then no values will be iterated. If the result is an Object, the itera

Bool returns an boolean representation.

Get searches result for the specified path. The result should be a JSON array or object.

Array returns back an array of values. If the result represents a null value or is non-existent, then an empty array will be returned. If the result i

Float returns an float64 representation.

Less return true if a token is less than another token. The caseSensitive parameter is used when the tokens are Strings. The order when comparing two

IsArray returns true if the result value is a JSON array.

Value returns one of these types: bool, for JSON booleans float64, for JSON numbers Number, for JSON numbers string, for JSON string literals ni

Map returns back a map of values. The result should be a JSON object. If the result is not a JSON object, the return value will be an empty map.

unescape unescapes a string

GetMany searches json for the multiple paths. The return value is a Result array where the number of items will be equal to the number of input paths.

Uint returns an unsigned integer representation.

IsObject returns true if the result value is a JSON object.

Path returns the original GJSON path for a Result where the Result came from a simple path that returns a single value, like: gjson.Get(json, "frien

String returns a string representation of the value.

GetBytes searches json for the specified path. If working with bytes, this method preferred over Get(string(data), path)

splitQuery takes a query and splits it into three parts: path, op, middle, and right. So for this query: #(first_name=="Murphy").last Becomes

AppendJSONString is a convenience function that converts the provided string to a valid JSON string and appends it to dst.

ParseBytes parses the json and returns a result. If working with bytes, this method preferred over Parse(string(data))

Valid returns true if the input is valid json. if !gjson.Valid(json) { return errors.New("invalid json") } value := gjson.Get(json, "name.last")

AddModifier binds a custom modifier command to the GJSON syntax. This operation is not thread safe and should be executed prior to using all other gjs

matchLimit will limit the complexity of the match operation to avoid ReDos attacks from arbitrary inputs. See the github.com/tidwall/match.MatchLimit

Escape returns an escaped path component. json := `{ "user":{ "first.name": "Janet", "last.name": "Prichard" } }` user := gjson

GetManyBytes searches json for the multiple paths. The return value is a Result array where the number of items will be equal to the number of input p

Paths returns the original GJSON paths for a Result where the Result came from a simple query path that returns an array, like: gjson.Get(json, "fri

fillIndex finds the position of Raw data and assigns it to the Index field of the resulting value. If the position cannot be found then Index zero is

peek at the next byte and see if it's a '@', '[', or '{'.

parseAny parses the next value from a json string. A Result is returned when the hit param is set. The return values are (i int, res Result, ok bool)

unwrap removes the '[]' or '{}' characters around json

cleanWS remove any non-whitespace from string

isSafePathKeyChar returns true if the input character is safe for not needing escaping.

runeit returns the rune from the the \uXXXX

safeInt validates a given JSON number ensures it lies within the minimum and maximum representable JSON numbers

All iterates over a json result. This works identically to ForEach, but allows modern Go loops: for key, value := range res.All() { fmt.Printf("%s

ForEachLine iterates through lines of JSON as specified by the JSON Lines format (http://jsonlines.org/). Each line is returned as a GJSON Result.

Keys iterates over a json result. This works identically to ForEach, but allows modern Go loops: for key := range res.Keys() { fmt.Printf("%s\n",

Time returns a time.Time representation.

ValidBytes returns true if the input is valid json. if !gjson.Valid(json) { return errors.New("invalid json") } value := gjson.Get(json, "name.l

Values iterates over a json result. This works identically to ForEach, but allows modern Go loops: for value := range res.Values() { fmt.Printf("%

execModifier parses the path to find a matching modifier function. The input expects that the path already starts with a '@'

execStatic parses the path to find a static value. The input expects that the path already starts with a '!'

getBytes casts the input json bytes to a string and safely returns the results as uniquely allocated data. This operation is intended to minimize copi

nameOfLast returns the name of the last component

parseSubSelectors returns the subselectors belonging to a '[path1,path2]' or '{"field1":path1,"field2":path2}' type subSelection. It's expected that t