github.com/fufuok/utils@v1.0.10/xjson/gjson/DOC.md

<!-- Code generated by gomarkdoc. DO NOT EDIT -->

# gjson

```go
import "github.com/fufuok/utils/xjson/gjson"
```

Package gjson provides searching for json strings.

## Index

- [Variables](<#variables>)
- [func AddModifier(name string, fn func(json, arg string) string)](<#func-addmodifier>)
- [func AppendJSONString(dst []byte, s string) []byte](<#func-appendjsonstring>)
- [func Escape(comp string) string](<#func-escape>)
- [func ForEachLine(json string, iterator func(line Result) bool)](<#func-foreachline>)
- [func ModifierExists(name string, fn func(json, arg string) string) bool](<#func-modifierexists>)
- [func Valid(json string) bool](<#func-valid>)
- [func ValidBytes(json []byte) bool](<#func-validbytes>)
- [type Result](<#type-result>)
  - [func Get(json, path string) Result](<#func-get>)
  - [func GetBytes(json []byte, path string) Result](<#func-getbytes>)
  - [func GetMany(json string, path ...string) []Result](<#func-getmany>)
  - [func GetManyBytes(json []byte, path ...string) []Result](<#func-getmanybytes>)
  - [func Parse(json string) Result](<#func-parse>)
  - [func ParseBytes(json []byte) Result](<#func-parsebytes>)
  - [func (t Result) Array() []Result](<#func-result-array>)
  - [func (t Result) Bool() bool](<#func-result-bool>)
  - [func (t Result) Exists() bool](<#func-result-exists>)
  - [func (t Result) Float() float64](<#func-result-float>)
  - [func (t Result) ForEach(iterator func(key, value Result) bool)](<#func-result-foreach>)
  - [func (t Result) Get(path string) Result](<#func-result-get>)
  - [func (t Result) Int() int64](<#func-result-int>)
  - [func (t Result) IsArray() bool](<#func-result-isarray>)
  - [func (t Result) IsBool() bool](<#func-result-isbool>)
  - [func (t Result) IsObject() bool](<#func-result-isobject>)
  - [func (t Result) Less(token Result, caseSensitive bool) bool](<#func-result-less>)
  - [func (t Result) Map() map[string]Result](<#func-result-map>)
  - [func (t Result) Path(json string) string](<#func-result-path>)
  - [func (t Result) Paths(json string) []string](<#func-result-paths>)
  - [func (t Result) String() string](<#func-result-string>)
  - [func (t Result) Time() time.Time](<#func-result-time>)
  - [func (t Result) Uint() uint64](<#func-result-uint>)
  - [func (t Result) Value() interface{}](<#func-result-value>)
- [type Type](<#type-type>)
  - [func (t Type) String() string](<#func-type-string>)


## Variables

DisableModifiers will disable the modifier syntax

```go
var DisableModifiers = false
```

## func AddModifier

```go
func AddModifier(name string, fn func(json, arg string) string)
```

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 gjson function.

## func AppendJSONString

```go
func AppendJSONString(dst []byte, s string) []byte
```

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

## func Escape

```go
func Escape(comp string) string
```

Escape returns an escaped path component.

```
json := `{
  "user":{
     "first.name": "Janet",
     "last.name": "Prichard"
   }
}`
user := gjson.Get(json, "user")
println(user.Get(gjson.Escape("first.name"))
println(user.Get(gjson.Escape("last.name"))
// Output:
// Janet
// Prichard
```

## func ForEachLine

```go
func ForEachLine(json string, iterator func(line Result) bool)
```

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

## func ModifierExists

```go
func ModifierExists(name string, fn func(json, arg string) string) bool
```

ModifierExists returns true when the specified modifier exists.

## func Valid

```go
func Valid(json string) bool
```

Valid returns true if the input is valid json.

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

## func ValidBytes

```go
func ValidBytes(json []byte) bool
```

ValidBytes returns true if the input is valid json.

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

If working with bytes, this method preferred over ValidBytes\(string\(data\)\)

## type Result

Result represents a json value that is returned from Get\(\).

```go
type Result struct {
    // Type is the json type
    Type Type
    // Raw is the raw json
    Raw string
    // Str is the json string
    Str string
    // Num is the json number
    Num float64
    // Index of raw value in original json, zero means index unknown
    Index int
    // Indexes of all the elements that match on a path containing the '#'
    // query character.
    Indexes []int
}
```

### func Get

```go
func Get(json, path string) Result
```

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 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 character can be escaped with '\\'.

```
{
  "name": {"first": "Tom", "last": "Anderson"},
  "age":37,
  "children": ["Sara","Alex","Jack"],
  "friends": [
    {"first": "James", "last": "Murphy"},
    {"first": "Roger", "last": "Craig"}
  ]
}
"name.last"          >> "Anderson"
"age"                >> 37
"children"           >> ["Sara","Alex","Jack"]
"children.#"         >> 3
"children.1"         >> "Alex"
"child*.2"           >> "Jack"
"c?ildren.0"         >> "Sara"
"friends.#.first"    >> ["James","Roger"]
```

This function expects that the json is well\-formed, and does not validate. Invalid 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 use the Valid function first.

### func GetBytes

```go
func GetBytes(json []byte, path string) Result
```

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

### func GetMany

```go
func GetMany(json string, path ...string) []Result
```

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.

### func GetManyBytes

```go
func GetManyBytes(json []byte, path ...string) []Result
```

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

### func Parse

```go
func Parse(json string) Result
```

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, but it may return back unexpected results. If you are consuming JSON from an unpredictable source then you may want to use the Valid function first.

### func ParseBytes

```go
func ParseBytes(json []byte) Result
```

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

### func \(Result\) Array

```go
func (t Result) Array() []Result
```

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 is not a JSON array, the return value will be an array containing one result.

### func \(Result\) Bool

```go
func (t Result) Bool() bool
```

Bool returns an boolean representation.

### func \(Result\) Exists

```go
func (t Result) Exists() bool
```

Exists returns true if value exists.

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

### func \(Result\) Float

```go
func (t Result) Float() float64
```

Float returns an float64 representation.

### func \(Result\) ForEach

```go
func (t Result) ForEach(iterator func(key, value Result) bool)
```

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 iterator will pass the key and value of each item. If the result is an Array, the iterator will only pass the value of each item. If the result is not a JSON array or object, the iterator will pass back one value equal to the result.

### func \(Result\) Get

```go
func (t Result) Get(path string) Result
```

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

### func \(Result\) Int

```go
func (t Result) Int() int64
```

Int returns an integer representation.

### func \(Result\) IsArray

```go
func (t Result) IsArray() bool
```

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

### func \(Result\) IsBool

```go
func (t Result) IsBool() bool
```

IsBool returns true if the result value is a JSON boolean.

### func \(Result\) IsObject

```go
func (t Result) IsObject() bool
```

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

### func \(Result\) Less

```go
func (t Result) Less(token Result, caseSensitive bool) bool
```

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

```
Null < False < Number < String < True < JSON
```

### func \(Result\) Map

```go
func (t Result) Map() map[string]Result
```

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.

### func \(Result\) Path

```go
func (t Result) Path(json string) string
```

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, "friends.#(last=Murphy)")
```

The returned value will be in the form of a JSON string:

```
"friends.0"
```

The param 'json' must be the original JSON used when calling Get.

Returns an empty string if the paths cannot be determined, which can happen when the Result came from a path that contained a multipath, modifier, or a nested query.

### func \(Result\) Paths

```go
func (t Result) Paths(json string) []string
```

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, "friends.#.first")
```

The returned value will be in the form of a JSON array:

```
["friends.0.first","friends.1.first","friends.2.first"]
```

The param 'json' must be the original JSON used when calling Get.

Returns an empty string if the paths cannot be determined, which can happen when the Result came from a path that contained a multipath, modifier, or a nested query.

### func \(Result\) String

```go
func (t Result) String() string
```

String returns a string representation of the value.

### func \(Result\) Time

```go
func (t Result) Time() time.Time
```

Time returns a time.Time representation.

### func \(Result\) Uint

```go
func (t Result) Uint() uint64
```

Uint returns an unsigned integer representation.

### func \(Result\) Value

```go
func (t Result) Value() interface{}
```

Value returns one of these types:

```
bool, for JSON booleans
float64, for JSON numbers
Number, for JSON numbers
string, for JSON string literals
nil, for JSON null
map[string]interface{}, for JSON objects
[]interface{}, for JSON arrays
```

## type Type

Type is Result type

```go
type Type int
```

```go
const (
    // Null is a null json value
    Null Type = iota
    // False is a json false boolean
    False
    // Number is json number
    Number
    // String is a json string
    String
    // True is a json true boolean
    True
    // JSON is a raw block of JSON
    JSON
)
```

### func \(Type\) String

```go
func (t Type) String() string
```

String returns a string representation of the type.



Generated by [gomarkdoc](<https://github.com/princjef/gomarkdoc>)