mirror of https://github.com/tidwall/tile38.git
updated gjson
This commit is contained in:
Josh Baker
parent
d9ed059887
commit
d6936636c2
|
|
@ -3,17 +3,17 @@
|
|||
src="logo.png"
|
||||
width="240" height="78" border="0" alt="GJSON">
|
||||
<br>
|
||||
<a href="https://travis-ci.org/tidwall/gjson"><img src="https://img.shields.io/travis/tidwall/gjson.svg?style=flat-square" alt="Build Status"></a><!--
|
||||
<a href="http://gocover.io/github.com/tidwall/gjson"><img src="https://img.shields.io/badge/coverage-97%25-brightgreen.svg?style=flat-square" alt="Code Coverage"></a>
|
||||
-->
|
||||
<a href="https://travis-ci.org/tidwall/gjson"><img src="https://img.shields.io/travis/tidwall/gjson.svg?style=flat-square" alt="Build Status"></a>
|
||||
<a href="https://godoc.org/github.com/tidwall/gjson"><img src="https://img.shields.io/badge/api-reference-blue.svg?style=flat-square" alt="GoDoc"></a>
|
||||
<a href="http://tidwall.com/gjson-play"><img src="https://img.shields.io/badge/play-ground-orange.svg?style=flat-square" alt="GJSON Playground"></a>
|
||||
</p>
|
||||
|
||||
|
||||
|
||||
<p align="center">get a json value quickly</a></p>
|
||||
|
||||
GJSON is a Go package that provides a [very fast](#performance) and simple way to get a value from a json document. The purpose for this library it to give efficient json indexing for the [BuntDB](https://github.com/tidwall/buntdb) project.
|
||||
|
||||
For a command line interface check out [JSONed](https://github.com/tidwall/jsoned).
|
||||
GJSON is a Go package that provides a [fast](#performance) and [simple](#get-a-value) way to get values from a json document.
|
||||
It has features such as [one line retrieval](#get-a-value), [dot notation paths](#path-syntax), [iteration](#iterate-through-an-object-or-array).
|
||||
|
||||
Getting Started
|
||||
===============
|
||||
|
|
@ -29,7 +29,7 @@ $ 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". This function expects that the json is well-formed and validates. Invalid json will not panic, but it may return back unexpected results. When the value is found it's returned immediately.
|
||||
Get searches json for the specified path. A path is in dot syntax, such as "name.last" or "age". This function expects that the json is well-formed. Bad json will not panic, but it may return back unexpected results. When the value is found it's returned immediately.
|
||||
|
||||
```go
|
||||
package main
|
||||
|
|
@ -57,7 +57,7 @@ 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 '\'.
|
||||
The dot and wildcard characters can be escaped with '\\'.
|
||||
|
||||
```json
|
||||
{
|
||||
|
|
@ -122,12 +122,14 @@ result.Index // index of raw value in original json, zero means index unknown
|
|||
There are a variety of handy functions that work on a result:
|
||||
|
||||
```go
|
||||
result.Exists() bool
|
||||
result.Value() interface{}
|
||||
result.Int() int64
|
||||
result.Uint() uint64
|
||||
result.Float() float64
|
||||
result.String() string
|
||||
result.Bool() bool
|
||||
result.Time() time.Time
|
||||
result.Array() []gjson.Result
|
||||
result.Map() map[string]gjson.Result
|
||||
result.Get(path string) Result
|
||||
|
|
@ -137,8 +139,6 @@ 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.
|
||||
|
|
@ -170,14 +170,14 @@ Suppose you want all the last names from the following json:
|
|||
"lastName": "Harold",
|
||||
}
|
||||
]
|
||||
}`
|
||||
}
|
||||
```
|
||||
|
||||
You would use the path "programmers.#.lastName" like such:
|
||||
|
||||
```go
|
||||
result := gjson.Get(json, "programmers.#.lastName")
|
||||
for _,name := range result.Array() {
|
||||
for _, name := range result.Array() {
|
||||
println(name.String())
|
||||
}
|
||||
```
|
||||
|
|
@ -198,7 +198,7 @@ Returning `false` from an iterator will stop iteration.
|
|||
|
||||
```go
|
||||
result := gjson.Get(json, "programmers")
|
||||
result.ForEach(func(key, value Result) bool{
|
||||
result.ForEach(func(key, value gjson.Result) bool {
|
||||
println(value.String())
|
||||
return true // keep iterating
|
||||
})
|
||||
|
|
@ -229,18 +229,65 @@ if !value.Exists() {
|
|||
}
|
||||
|
||||
// Or as one step
|
||||
if gjson.Get(json, "name.last").Exists(){
|
||||
if gjson.Get(json, "name.last").Exists() {
|
||||
println("has a last name")
|
||||
}
|
||||
```
|
||||
|
||||
## Unmarshalling
|
||||
|
||||
There's a `gjson.Unmarshal` function which loads json data into a value.
|
||||
It's a general replacement for `json.Unmarshal` and you can typically
|
||||
see a 2-3x boost in performance without the need for external generators.
|
||||
|
||||
This function works almost identically to `json.Unmarshal` except that
|
||||
`gjson.Unmarshal` will automatically attempt to convert JSON values to any
|
||||
Go type. For example, the JSON string "100" or the JSON number 100 can be
|
||||
equally assigned to Go string, int, byte, uint64, etc. This rule applies to
|
||||
all types.
|
||||
|
||||
|
||||
```go
|
||||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"github.com/tidwall/gjson"
|
||||
)
|
||||
|
||||
type Animal struct {
|
||||
Type string `json:"type"`
|
||||
Sound string `json:"sound"`
|
||||
Age int `json:"age"`
|
||||
}
|
||||
|
||||
var json = `{
|
||||
"type": "Dog",
|
||||
"Sound": "Bark",
|
||||
"Age": "11"
|
||||
}`
|
||||
|
||||
func main() {
|
||||
var dog Animal
|
||||
gjson.Unmarshal([]byte(json), &dog)
|
||||
fmt.Printf("type: %s, sound: %s, age: %d\n", dog.Type, dog.Sound, dog.Age)
|
||||
}
|
||||
```
|
||||
|
||||
This will print:
|
||||
|
||||
```
|
||||
type: Dog, sound: Bark, age: 11
|
||||
```
|
||||
|
||||
## Unmarshal to a map
|
||||
|
||||
To unmarshal to a `map[string]interface{}`:
|
||||
|
||||
```go
|
||||
m, ok := gjson.Parse(json).Value().(map[string]interface{})
|
||||
if !ok{
|
||||
if !ok {
|
||||
// not a map
|
||||
}
|
||||
```
|
||||
|
|
@ -284,28 +331,30 @@ The return value is a `[]Result`, which will always contain exactly the same num
|
|||
Benchmarks of GJSON alongside [encoding/json](https://golang.org/pkg/encoding/json/),
|
||||
[ffjson](https://github.com/pquerna/ffjson),
|
||||
[EasyJSON](https://github.com/mailru/easyjson),
|
||||
and [jsonparser](https://github.com/buger/jsonparser)
|
||||
[jsonparser](https://github.com/buger/jsonparser),
|
||||
and [json-iterator](https://github.com/json-iterator/go)
|
||||
|
||||
```
|
||||
BenchmarkGJSONGet-8 15000000 333 ns/op 0 B/op 0 allocs/op
|
||||
BenchmarkGJSONUnmarshalMap-8 900000 4188 ns/op 1920 B/op 26 allocs/op
|
||||
BenchmarkJSONUnmarshalMap-8 600000 8908 ns/op 3048 B/op 69 allocs/op
|
||||
BenchmarkJSONUnmarshalStruct-8 600000 9026 ns/op 1832 B/op 69 allocs/op
|
||||
BenchmarkJSONDecoder-8 300000 14339 ns/op 4224 B/op 184 allocs/op
|
||||
BenchmarkFFJSONLexer-8 1500000 3156 ns/op 896 B/op 8 allocs/op
|
||||
BenchmarkEasyJSONLexer-8 3000000 938 ns/op 613 B/op 6 allocs/op
|
||||
BenchmarkJSONParserGet-8 3000000 442 ns/op 21 B/op 0 allocs/op
|
||||
BenchmarkGJSONGet-8 3000000 372 ns/op 0 B/op 0 allocs/op
|
||||
BenchmarkGJSONUnmarshalMap-8 900000 4154 ns/op 1920 B/op 26 allocs/op
|
||||
BenchmarkJSONUnmarshalMap-8 600000 9019 ns/op 3048 B/op 69 allocs/op
|
||||
BenchmarkJSONUnmarshalStruct-8 600000 9268 ns/op 1832 B/op 69 allocs/op
|
||||
BenchmarkJSONDecoder-8 300000 14120 ns/op 4224 B/op 184 allocs/op
|
||||
BenchmarkFFJSONLexer-8 1500000 3111 ns/op 896 B/op 8 allocs/op
|
||||
BenchmarkEasyJSONLexer-8 3000000 887 ns/op 613 B/op 6 allocs/op
|
||||
BenchmarkJSONParserGet-8 3000000 499 ns/op 21 B/op 0 allocs/op
|
||||
BenchmarkJSONIterator-8 3000000 812 ns/op 544 B/op 9 allocs/op
|
||||
```
|
||||
|
||||
Benchmarks for the `GetMany` function:
|
||||
|
||||
```
|
||||
BenchmarkGJSONGetMany4Paths-8 4000000 319 ns/op 112 B/op 0 allocs/op
|
||||
BenchmarkGJSONGetMany8Paths-8 8000000 218 ns/op 56 B/op 0 allocs/op
|
||||
BenchmarkGJSONGetMany16Paths-8 16000000 160 ns/op 56 B/op 0 allocs/op
|
||||
BenchmarkGJSONGetMany32Paths-8 32000000 130 ns/op 64 B/op 0 allocs/op
|
||||
BenchmarkGJSONGetMany64Paths-8 64000000 117 ns/op 64 B/op 0 allocs/op
|
||||
BenchmarkGJSONGetMany128Paths-8 128000000 109 ns/op 64 B/op 0 allocs/op
|
||||
BenchmarkGJSONGetMany4Paths-8 4000000 303 ns/op 112 B/op 0 allocs/op
|
||||
BenchmarkGJSONGetMany8Paths-8 8000000 208 ns/op 56 B/op 0 allocs/op
|
||||
BenchmarkGJSONGetMany16Paths-8 16000000 156 ns/op 56 B/op 0 allocs/op
|
||||
BenchmarkGJSONGetMany32Paths-8 32000000 127 ns/op 64 B/op 0 allocs/op
|
||||
BenchmarkGJSONGetMany64Paths-8 64000000 117 ns/op 64 B/op 0 allocs/op
|
||||
BenchmarkGJSONGetMany128Paths-8 128000000 109 ns/op 64 B/op 0 allocs/op
|
||||
```
|
||||
|
||||
JSON document used:
|
||||
|
|
@ -361,7 +410,8 @@ widget.text.data
|
|||
widget.text.size
|
||||
```
|
||||
|
||||
*These benchmarks were run on a MacBook Pro 15" 2.8 GHz Intel Core i7 using Go 1.7.*
|
||||
*These benchmarks were run on a MacBook Pro 15" 2.8 GHz Intel Core i7 using Go 1.8 and can be be found [here](https://github.com/tidwall/gjson-benchmarks).*
|
||||
|
||||
|
||||
## Contact
|
||||
Josh Baker [@tidwall](http://twitter.com/tidwall)
|
||||
|
|
|
|||
|
|
@ -2,8 +2,17 @@
|
|||
package gjson
|
||||
|
||||
import (
|
||||
"encoding/base64"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"reflect"
|
||||
"strconv"
|
||||
"strings"
|
||||
"sync"
|
||||
"sync/atomic"
|
||||
"time"
|
||||
"unicode/utf16"
|
||||
"unicode/utf8"
|
||||
"unsafe"
|
||||
|
||||
"github.com/tidwall/match"
|
||||
|
|
@ -65,7 +74,7 @@ type Result struct {
|
|||
func (t Result) String() string {
|
||||
switch t.Type {
|
||||
default:
|
||||
return "null"
|
||||
return ""
|
||||
case False:
|
||||
return "false"
|
||||
case Number:
|
||||
|
|
@ -101,10 +110,20 @@ func (t Result) Int() int64 {
|
|||
case True:
|
||||
return 1
|
||||
case String:
|
||||
n, _ := strconv.ParseInt(t.Str, 10, 64)
|
||||
n, _ := parseInt(t.Str)
|
||||
return n
|
||||
case Number:
|
||||
return int64(t.Num)
|
||||
// try to directly convert the float64 to int64
|
||||
n, ok := floatToInt(t.Num)
|
||||
if !ok {
|
||||
// now try to parse the raw string
|
||||
n, ok = parseInt(t.Raw)
|
||||
if !ok {
|
||||
// fallback to a standard conversion
|
||||
return int64(t.Num)
|
||||
}
|
||||
}
|
||||
return n
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -116,10 +135,20 @@ func (t Result) Uint() uint64 {
|
|||
case True:
|
||||
return 1
|
||||
case String:
|
||||
n, _ := strconv.ParseUint(t.Str, 10, 64)
|
||||
n, _ := parseUint(t.Str)
|
||||
return n
|
||||
case Number:
|
||||
return uint64(t.Num)
|
||||
// try to directly convert the float64 to uint64
|
||||
n, ok := floatToUint(t.Num)
|
||||
if !ok {
|
||||
// now try to parse the raw string
|
||||
n, ok = parseUint(t.Raw)
|
||||
if !ok {
|
||||
// fallback to a standard conversion
|
||||
return uint64(t.Num)
|
||||
}
|
||||
}
|
||||
return n
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -138,6 +167,12 @@ func (t Result) Float() float64 {
|
|||
}
|
||||
}
|
||||
|
||||
// Time returns a time.Time representation.
|
||||
func (t Result) Time() time.Time {
|
||||
res, _ := time.Parse(time.RFC3339, t.String())
|
||||
return res
|
||||
}
|
||||
|
||||
// Array 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.
|
||||
|
|
@ -152,6 +187,16 @@ func (t Result) Array() []Result {
|
|||
return r.a
|
||||
}
|
||||
|
||||
// IsObject returns true if the result value is a JSON object.
|
||||
func (t Result) IsObject() bool {
|
||||
return t.Type == JSON && len(t.Raw) > 0 && t.Raw[0] == '{'
|
||||
}
|
||||
|
||||
// IsObject returns true if the result value is a JSON array.
|
||||
func (t Result) IsArray() bool {
|
||||
return t.Type == JSON && len(t.Raw) > 0 && t.Raw[0] == '['
|
||||
}
|
||||
|
||||
// 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.
|
||||
|
|
@ -903,7 +948,7 @@ func parseObject(c *parseContext, i int, path string) (int, bool) {
|
|||
break
|
||||
}
|
||||
}
|
||||
i, key, kesc, ok = i, c.json[s:], false, false
|
||||
key, kesc, ok = c.json[s:], false, false
|
||||
parse_key_string_done:
|
||||
break
|
||||
}
|
||||
|
|
@ -1076,8 +1121,8 @@ func parseArray(c *parseContext, i int, path string) (int, bool) {
|
|||
var multires []byte
|
||||
rp := parseArrayPath(path)
|
||||
if !rp.arrch {
|
||||
n, err := strconv.ParseUint(rp.part, 10, 64)
|
||||
if err != nil {
|
||||
n, ok := parseUint(rp.part)
|
||||
if !ok {
|
||||
partidx = -1
|
||||
} else {
|
||||
partidx = int(n)
|
||||
|
|
@ -1221,16 +1266,15 @@ func parseArray(c *parseContext, i int, path string) (int, bool) {
|
|||
c.value.Type = JSON
|
||||
c.value.Raw = string(jsons)
|
||||
return i + 1, true
|
||||
} else {
|
||||
if rp.alogok {
|
||||
break
|
||||
}
|
||||
c.value.Raw = val
|
||||
c.value.Type = Number
|
||||
c.value.Num = float64(h - 1)
|
||||
c.calcd = true
|
||||
return i + 1, true
|
||||
}
|
||||
if rp.alogok {
|
||||
break
|
||||
}
|
||||
c.value.Raw = val
|
||||
c.value.Type = Number
|
||||
c.value.Num = float64(h - 1)
|
||||
c.calcd = true
|
||||
return i + 1, true
|
||||
}
|
||||
if len(multires) > 0 && !c.value.Exists() {
|
||||
c.value = Result{
|
||||
|
|
@ -1357,6 +1401,12 @@ func GetBytes(json []byte, path string) Result {
|
|||
return result
|
||||
}
|
||||
|
||||
// runeit returns the rune from the the \uXXXX
|
||||
func runeit(json string) rune {
|
||||
n, _ := strconv.ParseUint(json[:4], 16, 64)
|
||||
return rune(n)
|
||||
}
|
||||
|
||||
// unescape unescapes a string
|
||||
func unescape(json string) string { //, error) {
|
||||
var str = make([]byte, 0, len(json))
|
||||
|
|
@ -1365,15 +1415,15 @@ func unescape(json string) string { //, error) {
|
|||
default:
|
||||
str = append(str, json[i])
|
||||
case json[i] < ' ':
|
||||
return "" //, errors.New("invalid character in string")
|
||||
return string(str)
|
||||
case json[i] == '\\':
|
||||
i++
|
||||
if i >= len(json) {
|
||||
return "" //, errors.New("invalid escape sequence")
|
||||
return string(str)
|
||||
}
|
||||
switch json[i] {
|
||||
default:
|
||||
return "" //, errors.New("invalid escape sequence")
|
||||
return string(str)
|
||||
case '\\':
|
||||
str = append(str, '\\')
|
||||
case '/':
|
||||
|
|
@ -1392,29 +1442,27 @@ func unescape(json string) string { //, error) {
|
|||
str = append(str, '"')
|
||||
case 'u':
|
||||
if i+5 > len(json) {
|
||||
return "" //, errors.New("invalid escape sequence")
|
||||
return string(str)
|
||||
}
|
||||
i++
|
||||
// extract the codepoint
|
||||
var code int
|
||||
for j := i; j < i+4; j++ {
|
||||
switch {
|
||||
default:
|
||||
return "" //, errors.New("invalid escape sequence")
|
||||
case json[j] >= '0' && json[j] <= '9':
|
||||
code += (int(json[j]) - '0') << uint(12-(j-i)*4)
|
||||
case json[j] >= 'a' && json[j] <= 'f':
|
||||
code += (int(json[j]) - 'a' + 10) << uint(12-(j-i)*4)
|
||||
case json[j] >= 'a' && json[j] <= 'f':
|
||||
code += (int(json[j]) - 'a' + 10) << uint(12-(j-i)*4)
|
||||
r := runeit(json[i+1:])
|
||||
i += 5
|
||||
if utf16.IsSurrogate(r) {
|
||||
// need another code
|
||||
if len(json[i:]) >= 6 && json[i] == '\\' && json[i+1] == 'u' {
|
||||
// we expect it to be correct so just consume it
|
||||
r = utf16.DecodeRune(r, runeit(json[i+2:]))
|
||||
i += 6
|
||||
}
|
||||
}
|
||||
str = append(str, []byte(string(code))...)
|
||||
i += 3 // only 3 because we will increment on the for-loop
|
||||
// provide enough space to encode the largest utf8 possible
|
||||
str = append(str, 0, 0, 0, 0, 0, 0, 0, 0)
|
||||
n := utf8.EncodeRune(str[len(str)-8:], r)
|
||||
str = str[:len(str)-8+n]
|
||||
i-- // backtrack index by one
|
||||
}
|
||||
}
|
||||
}
|
||||
return string(str) //, nil
|
||||
return string(str)
|
||||
}
|
||||
|
||||
// Less return true if a token is less than another token.
|
||||
|
|
@ -1742,7 +1790,6 @@ next_key:
|
|||
usedPaths++
|
||||
continue
|
||||
}
|
||||
|
||||
// try to match the key to the path
|
||||
// this is spaghetti code but the idea is to minimize
|
||||
// calls and variable assignments when comparing the
|
||||
|
|
@ -1757,12 +1804,17 @@ next_key:
|
|||
}
|
||||
if i < len(paths[j]) {
|
||||
if paths[j][i] == '.' {
|
||||
// matched, but there still more keys in the path
|
||||
// matched, but there are still more keys in path
|
||||
goto match_not_atend
|
||||
}
|
||||
}
|
||||
// matched and at the end of the path
|
||||
goto match_atend
|
||||
if len(paths[j]) <= len(key) || kplen != 0 {
|
||||
if len(paths[j]) != i {
|
||||
goto nomatch
|
||||
}
|
||||
// matched and at the end of the path
|
||||
goto match_atend
|
||||
}
|
||||
}
|
||||
// no match, jump to the nomatch label
|
||||
goto nomatch
|
||||
|
|
@ -1798,6 +1850,9 @@ next_key:
|
|||
nomatch: // noop label
|
||||
}
|
||||
|
||||
if !hasMatch && i < len(json) && json[i] == '}' {
|
||||
return i + 1, true
|
||||
}
|
||||
if !parsedVal {
|
||||
if hasMatch {
|
||||
// we found a match and the value has not been parsed yet.
|
||||
|
|
@ -1940,3 +1995,453 @@ func getMany512(json string, i int, paths []string) ([]Result, bool) {
|
|||
_, ok := parseGetMany(json, i, 0, 0, paths, completed, matches, results)
|
||||
return results, ok
|
||||
}
|
||||
|
||||
var fieldsmu sync.RWMutex
|
||||
var fields = make(map[string]map[string]int)
|
||||
|
||||
func assign(jsval Result, goval reflect.Value) {
|
||||
if jsval.Type == Null {
|
||||
return
|
||||
}
|
||||
switch goval.Kind() {
|
||||
default:
|
||||
case reflect.Ptr:
|
||||
if !goval.IsNil() {
|
||||
newval := reflect.New(goval.Elem().Type())
|
||||
assign(jsval, newval.Elem())
|
||||
goval.Elem().Set(newval.Elem())
|
||||
} else {
|
||||
newval := reflect.New(goval.Type().Elem())
|
||||
assign(jsval, newval.Elem())
|
||||
goval.Set(newval)
|
||||
}
|
||||
case reflect.Struct:
|
||||
fieldsmu.RLock()
|
||||
sf := fields[goval.Type().String()]
|
||||
fieldsmu.RUnlock()
|
||||
if sf == nil {
|
||||
fieldsmu.Lock()
|
||||
sf = make(map[string]int)
|
||||
for i := 0; i < goval.Type().NumField(); i++ {
|
||||
f := goval.Type().Field(i)
|
||||
tag := strings.Split(f.Tag.Get("json"), ",")[0]
|
||||
if tag != "-" {
|
||||
if tag != "" {
|
||||
sf[tag] = i
|
||||
sf[f.Name] = i
|
||||
} else {
|
||||
sf[f.Name] = i
|
||||
}
|
||||
}
|
||||
}
|
||||
fields[goval.Type().String()] = sf
|
||||
fieldsmu.Unlock()
|
||||
}
|
||||
jsval.ForEach(func(key, value Result) bool {
|
||||
if idx, ok := sf[key.Str]; ok {
|
||||
f := goval.Field(idx)
|
||||
if f.CanSet() {
|
||||
assign(value, f)
|
||||
}
|
||||
}
|
||||
return true
|
||||
})
|
||||
case reflect.Slice:
|
||||
if goval.Type().Elem().Kind() == reflect.Uint8 && jsval.Type == String {
|
||||
data, _ := base64.StdEncoding.DecodeString(jsval.String())
|
||||
goval.Set(reflect.ValueOf(data))
|
||||
} else {
|
||||
jsvals := jsval.Array()
|
||||
slice := reflect.MakeSlice(goval.Type(), len(jsvals), len(jsvals))
|
||||
for i := 0; i < len(jsvals); i++ {
|
||||
assign(jsvals[i], slice.Index(i))
|
||||
}
|
||||
goval.Set(slice)
|
||||
}
|
||||
case reflect.Array:
|
||||
i, n := 0, goval.Len()
|
||||
jsval.ForEach(func(_, value Result) bool {
|
||||
if i == n {
|
||||
return false
|
||||
}
|
||||
assign(value, goval.Index(i))
|
||||
i++
|
||||
return true
|
||||
})
|
||||
case reflect.Map:
|
||||
if goval.Type().Key().Kind() == reflect.String && goval.Type().Elem().Kind() == reflect.Interface {
|
||||
goval.Set(reflect.ValueOf(jsval.Value()))
|
||||
}
|
||||
case reflect.Interface:
|
||||
goval.Set(reflect.ValueOf(jsval.Value()))
|
||||
case reflect.Bool:
|
||||
goval.SetBool(jsval.Bool())
|
||||
case reflect.Float32, reflect.Float64:
|
||||
goval.SetFloat(jsval.Float())
|
||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
||||
goval.SetInt(jsval.Int())
|
||||
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
|
||||
goval.SetUint(jsval.Uint())
|
||||
case reflect.String:
|
||||
goval.SetString(jsval.String())
|
||||
}
|
||||
if len(goval.Type().PkgPath()) > 0 {
|
||||
v := goval.Addr()
|
||||
if v.Type().NumMethod() > 0 {
|
||||
if u, ok := v.Interface().(json.Unmarshaler); ok {
|
||||
u.UnmarshalJSON([]byte(jsval.Raw))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var validate uintptr = 1
|
||||
|
||||
// UnmarshalValidationEnabled provides the option to disable JSON validation
|
||||
// during the Unmarshal routine. Validation is enabled by default.
|
||||
func UnmarshalValidationEnabled(enabled bool) {
|
||||
if enabled {
|
||||
atomic.StoreUintptr(&validate, 1)
|
||||
} else {
|
||||
atomic.StoreUintptr(&validate, 0)
|
||||
}
|
||||
}
|
||||
|
||||
// Unmarshal loads the JSON data into the value pointed to by v.
|
||||
//
|
||||
// This function works almost identically to json.Unmarshal except that
|
||||
// gjson.Unmarshal will automatically attempt to convert JSON values to any Go
|
||||
// type. For example, the JSON string "100" or the JSON number 100 can be equally
|
||||
// assigned to Go string, int, byte, uint64, etc. This rule applies to all types.
|
||||
func Unmarshal(data []byte, v interface{}) error {
|
||||
if atomic.LoadUintptr(&validate) == 1 {
|
||||
_, ok := validpayload(data, 0)
|
||||
if !ok {
|
||||
return errors.New("invalid json")
|
||||
}
|
||||
}
|
||||
if v := reflect.ValueOf(v); v.Kind() == reflect.Ptr {
|
||||
assign(ParseBytes(data), v)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func validpayload(data []byte, i int) (outi int, ok bool) {
|
||||
for ; i < len(data); i++ {
|
||||
switch data[i] {
|
||||
default:
|
||||
i, ok = validany(data, i)
|
||||
if !ok {
|
||||
return i, false
|
||||
}
|
||||
for ; i < len(data); i++ {
|
||||
switch data[i] {
|
||||
default:
|
||||
return i, false
|
||||
case ' ', '\t', '\n', '\r':
|
||||
continue
|
||||
}
|
||||
}
|
||||
return i, true
|
||||
case ' ', '\t', '\n', '\r':
|
||||
continue
|
||||
}
|
||||
}
|
||||
return i, false
|
||||
}
|
||||
func validany(data []byte, i int) (outi int, ok bool) {
|
||||
for ; i < len(data); i++ {
|
||||
switch data[i] {
|
||||
default:
|
||||
return i, false
|
||||
case ' ', '\t', '\n', '\r':
|
||||
continue
|
||||
case '{':
|
||||
return validobject(data, i+1)
|
||||
case '[':
|
||||
return validarray(data, i+1)
|
||||
case '"':
|
||||
return validstring(data, i+1)
|
||||
case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
|
||||
return validnumber(data, i+1)
|
||||
case 't':
|
||||
return validtrue(data, i+1)
|
||||
case 'f':
|
||||
return validfalse(data, i+1)
|
||||
case 'n':
|
||||
return validnull(data, i+1)
|
||||
}
|
||||
}
|
||||
return i, false
|
||||
}
|
||||
func validobject(data []byte, i int) (outi int, ok bool) {
|
||||
for ; i < len(data); i++ {
|
||||
switch data[i] {
|
||||
default:
|
||||
return i, false
|
||||
case ' ', '\t', '\n', '\r':
|
||||
continue
|
||||
case '}':
|
||||
return i + 1, true
|
||||
case '"':
|
||||
key:
|
||||
if i, ok = validstring(data, i+1); !ok {
|
||||
return i, false
|
||||
}
|
||||
if i, ok = validcolon(data, i); !ok {
|
||||
return i, false
|
||||
}
|
||||
if i, ok = validany(data, i); !ok {
|
||||
return i, false
|
||||
}
|
||||
if i, ok = validcomma(data, i, '}'); !ok {
|
||||
return i, false
|
||||
}
|
||||
if data[i] == '}' {
|
||||
return i + 1, true
|
||||
}
|
||||
for ; i < len(data); i++ {
|
||||
if data[i] == '"' {
|
||||
goto key
|
||||
}
|
||||
}
|
||||
return i, false
|
||||
}
|
||||
}
|
||||
return i, false
|
||||
}
|
||||
func validcolon(data []byte, i int) (outi int, ok bool) {
|
||||
for ; i < len(data); i++ {
|
||||
switch data[i] {
|
||||
default:
|
||||
return i, false
|
||||
case ' ', '\t', '\n', '\r':
|
||||
continue
|
||||
case ':':
|
||||
return i + 1, true
|
||||
}
|
||||
}
|
||||
return i, false
|
||||
}
|
||||
func validcomma(data []byte, i int, end byte) (outi int, ok bool) {
|
||||
for ; i < len(data); i++ {
|
||||
switch data[i] {
|
||||
default:
|
||||
return i, false
|
||||
case ' ', '\t', '\n', '\r':
|
||||
continue
|
||||
case ',':
|
||||
return i, true
|
||||
case end:
|
||||
return i, true
|
||||
}
|
||||
}
|
||||
return i, false
|
||||
}
|
||||
func validarray(data []byte, i int) (outi int, ok bool) {
|
||||
for ; i < len(data); i++ {
|
||||
switch data[i] {
|
||||
default:
|
||||
for ; i < len(data); i++ {
|
||||
if i, ok = validany(data, i); !ok {
|
||||
return i, false
|
||||
}
|
||||
if i, ok = validcomma(data, i, ']'); !ok {
|
||||
return i, false
|
||||
}
|
||||
if data[i] == ']' {
|
||||
return i + 1, true
|
||||
}
|
||||
}
|
||||
case ' ', '\t', '\n', '\r':
|
||||
continue
|
||||
case ']':
|
||||
return i + 1, true
|
||||
}
|
||||
}
|
||||
return i, false
|
||||
}
|
||||
func validstring(data []byte, i int) (outi int, ok bool) {
|
||||
for ; i < len(data); i++ {
|
||||
if data[i] < ' ' {
|
||||
return i, false
|
||||
} else if data[i] == '\\' {
|
||||
i++
|
||||
if i == len(data) {
|
||||
return i, false
|
||||
}
|
||||
switch data[i] {
|
||||
default:
|
||||
return i, false
|
||||
case '"', '\\', '/', 'b', 'f', 'n', 'r', 't':
|
||||
case 'u':
|
||||
for j := 0; j < 4; j++ {
|
||||
i++
|
||||
if i >= len(data) {
|
||||
return i, false
|
||||
}
|
||||
if !((data[i] >= '0' && data[i] <= '9') ||
|
||||
(data[i] >= 'a' && data[i] <= 'f') ||
|
||||
(data[i] >= 'A' && data[i] <= 'F')) {
|
||||
return i, false
|
||||
}
|
||||
}
|
||||
}
|
||||
} else if data[i] == '"' {
|
||||
return i + 1, true
|
||||
}
|
||||
}
|
||||
return i, false
|
||||
}
|
||||
func validnumber(data []byte, i int) (outi int, ok bool) {
|
||||
i--
|
||||
// sign
|
||||
if data[i] == '-' {
|
||||
i++
|
||||
}
|
||||
// int
|
||||
if i == len(data) {
|
||||
return i, false
|
||||
}
|
||||
if data[i] == '0' {
|
||||
i++
|
||||
} else {
|
||||
for ; i < len(data); i++ {
|
||||
if data[i] >= '0' && data[i] <= '9' {
|
||||
continue
|
||||
}
|
||||
break
|
||||
}
|
||||
}
|
||||
// frac
|
||||
if i == len(data) {
|
||||
return i, true
|
||||
}
|
||||
if data[i] == '.' {
|
||||
i++
|
||||
if i == len(data) {
|
||||
return i, false
|
||||
}
|
||||
if data[i] < '0' || data[i] > '9' {
|
||||
return i, false
|
||||
}
|
||||
i++
|
||||
for ; i < len(data); i++ {
|
||||
if data[i] >= '0' && data[i] <= '9' {
|
||||
continue
|
||||
}
|
||||
break
|
||||
}
|
||||
}
|
||||
// exp
|
||||
if i == len(data) {
|
||||
return i, true
|
||||
}
|
||||
if data[i] == 'e' || data[i] == 'E' {
|
||||
i++
|
||||
if i == len(data) {
|
||||
return i, false
|
||||
}
|
||||
if data[i] == '+' || data[i] == '-' {
|
||||
i++
|
||||
}
|
||||
if i == len(data) {
|
||||
return i, false
|
||||
}
|
||||
if data[i] < '0' || data[i] > '9' {
|
||||
return i, false
|
||||
}
|
||||
i++
|
||||
for ; i < len(data); i++ {
|
||||
if data[i] >= '0' && data[i] <= '9' {
|
||||
continue
|
||||
}
|
||||
break
|
||||
}
|
||||
}
|
||||
return i, true
|
||||
}
|
||||
|
||||
func validtrue(data []byte, i int) (outi int, ok bool) {
|
||||
if i+3 <= len(data) && data[i] == 'r' && data[i+1] == 'u' && data[i+2] == 'e' {
|
||||
return i + 3, true
|
||||
}
|
||||
return i, false
|
||||
}
|
||||
func validfalse(data []byte, i int) (outi int, ok bool) {
|
||||
if i+4 <= len(data) && data[i] == 'a' && data[i+1] == 'l' && data[i+2] == 's' && data[i+3] == 'e' {
|
||||
return i + 4, true
|
||||
}
|
||||
return i, false
|
||||
}
|
||||
func validnull(data []byte, i int) (outi int, ok bool) {
|
||||
if i+3 <= len(data) && data[i] == 'u' && data[i+1] == 'l' && data[i+2] == 'l' {
|
||||
return i + 3, true
|
||||
}
|
||||
return i, false
|
||||
}
|
||||
|
||||
// Valid returns true if the input is valid json.
|
||||
func Valid(json string) bool {
|
||||
_, ok := validpayload([]byte(json), 0)
|
||||
return ok
|
||||
}
|
||||
|
||||
func parseUint(s string) (n uint64, ok bool) {
|
||||
var i int
|
||||
if i == len(s) {
|
||||
return 0, false
|
||||
}
|
||||
for ; i < len(s); i++ {
|
||||
if s[i] >= '0' && s[i] <= '9' {
|
||||
n = n*10 + uint64(s[i]-'0')
|
||||
} else {
|
||||
return 0, false
|
||||
}
|
||||
}
|
||||
return n, true
|
||||
}
|
||||
|
||||
func parseInt(s string) (n int64, ok bool) {
|
||||
var i int
|
||||
var sign bool
|
||||
if len(s) > 0 && s[0] == '-' {
|
||||
sign = true
|
||||
i++
|
||||
}
|
||||
if i == len(s) {
|
||||
return 0, false
|
||||
}
|
||||
for ; i < len(s); i++ {
|
||||
if s[i] >= '0' && s[i] <= '9' {
|
||||
n = n*10 + int64(s[i]-'0')
|
||||
} else {
|
||||
return 0, false
|
||||
}
|
||||
}
|
||||
if sign {
|
||||
return n * -1, true
|
||||
}
|
||||
return n, true
|
||||
}
|
||||
|
||||
const minUint53 = 0
|
||||
const maxUint53 = 4503599627370495
|
||||
const minInt53 = -2251799813685248
|
||||
const maxInt53 = 2251799813685247
|
||||
|
||||
func floatToUint(f float64) (n uint64, ok bool) {
|
||||
n = uint64(f)
|
||||
if float64(n) == f && n >= minUint53 && n <= maxUint53 {
|
||||
return n, true
|
||||
}
|
||||
return 0, false
|
||||
}
|
||||
|
||||
func floatToInt(f float64) (n int64, ok bool) {
|
||||
n = int64(f)
|
||||
if float64(n) == f && n >= minInt53 && n <= maxInt53 {
|
||||
return n, true
|
||||
}
|
||||
return 0, false
|
||||
}
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue