JSON o Golang | Forget static types, No more complex structure definitions, Focus on code. Go Reflect!
JoGO uses memoization to return results faster. JoGO facilitates handling of large and complex JSON structures by making use of go reflections and type assertions.
Take a look at benchmarks
Type the following in Command Line
go get -u github.com/akshitgrover/jogo
Import JoGO in .go source files as follows
import "github.com/akshitgrover/jogo/jogo"
Note:
JoGO is distributed as a module with one package, To use JoGO package packed within the JoGO module above import path is to be used.
To find more about go modules, Read the wiki
Export method is used to parse underlying json and return ExportedJson, ResultJson and Error objects.
package main
import (
"github.com/akshitgrover/jogo/jogo"
"fmt"
)
func main() {
exp, r, err := jogo.Export(`{"hello":"world"}`)
if err != nil {
fmt.Println(err)
} else {
fmt.Println(r.Type) // OBJECT
_, _ = exp.Get("hello")
}
}Get method is used to fetch value from an ExportedJson object. It returns ResultJson and Error objects.
package main
import (
"github.com/akshitgrover/jogo/jogo"
"fmt"
)
func main() {
exp, r, err := jogo.Export(`{"name":{"firstname":"akshit", "lastname":"grover"}}`)
if err != nil {
fmt.Println(err)
} else {
fmt.Println(r.Type) //OBJECT
r2, _ := exp.Get("name.firstname")
r3, _ := exp.Get("name.lastname")
fmt.Println(r2.Type, r3.Type) //STRING STRING
fmt.Println(r2.String() + r3.String())
}
}R method is used to convert any interface to ResultJson struct.
It accepts interface{} as an argument and returns ResultJson{}.
Note: R method makes it intuitive to iterate over Objects and Slices.
package main
import (
"github.com/akshitgrover/jogo/jogo"
"fmt"
)
func main() {
exp, r, err := jogo.Export(`{"name":{"firstname":"akshit", "lastname":"grover"}}`)
if err != nil {
fmt.Println(err)
} else {
fmt.Println(r.Type) //OBJECT
r2, _ := exp.Get("name")
for k, v := range r2 {
fmt.Println("Key: " + k)
fmt.Println("Value: " + jogo.R(v).String())
}
}
/* Output
OBJECT
Key: firstname
Value: akshit
--------
Key: lastname
Value: grover
--------
*/
}Exported Json object holds parsed JSON, If an underlying json represents an OBJECT (javascript alike),
{ExportedJson Object}.Get("{prop1}.{prop2}.{....}.{propN}")
Is used to access any value in that json.
Any access to the value of a JSON property is to be done using ExportedJson object's Get Method.
Go being statically typed, Value fetched from GET method holds an underlying representation of value in the form of an interface, To convert it into a native type, Type assertion is to be used.
JoGO provides various method to do type assertion.
ResultJson object has Type attribute.
- NUMBER
- STRING
- LIST
- OBJECT
- BOOLEAN
Note: Type attribute holds one of the above.
- {ResultJson Object}.Int() # Returns: int64
- {ResultJson Object}.Float() # Returns: float64
- {ResultJson Object}.String() # Returns: string
- {ResultJson Object}.Bool() # Returns: bool
- {ResultJson Object}.Object() # Returns: map[string]interface {}
- {ResultJson Object}.List() # Returns: []interface {}
Note: If underlying interface value is not the same as the one it is asserted as, go program panics.
To avoid panic state, Following methods are included.
These methods checks for interface type, If it does not match, an error is returned.
- {ResultJson Object}.IntStrict() # Returns: int64, error
- {ResultJson Object}.FloatStrict() # Returns: float64, error
- {ResultJson Object}.StringStrict() # Returns: string, error
- {ResultJson Object}.BoolStrict() # Returns: bool, error
- {ResultJson Object}.ObjectStrict() # Returns: map[string]interface {}, error
- {ResultJson Object}.ListStrict() # Returns: []interface {}, error
Note: These methods are slower than non-strict methods, It is advised to first check type using Type attribute then call non-strict type assert methods.
package main
import (
"github.com/akshitgrover/jogo/jogo"
"fmt"
)
func main() {
exp, _, err := jogo.Export(`{"name":{"firstname":"akshit", "lastname":"grover"}}`)
if err != nil {
fmt.Println(err)
} else {
r2, _ := exp.Get("name.firstname")
if r2.Type == "STRING" {
fmt.Println(r2.String()) //akshit
}
}
}Error object is native error interface provided by go.
BenchmarkJoGOGet-4 15000000 317 ns/op 61 B/op 2 allocs/op
BenchmarkGJSONGet-4 3000000 475 ns/op 0 B/op 0 allocs/op
BenchmarkGJSONGetMany4Paths-4 4000000 470 ns/op 56 B/op 0 allocs/op
BenchmarkGJSONGetMany8Paths-4 8000000 463 ns/op 56 B/op 0 allocs/op
BenchmarkGJSONGetMany16Paths-4 16000000 496 ns/op 56 B/op 0 allocs/op
BenchmarkGJSONGetMany32Paths-4 32000000 480 ns/op 56 B/op 0 allocs/op
BenchmarkGJSONGetMany64Paths-4 64000000 485 ns/op 64 B/op 0 allocs/op
BenchmarkGJSONGetMany128Paths-4 128000000 509 ns/op 64 B/op 0 allocs/op
BenchmarkGJSONUnmarshalMap-4 900000 5060 ns/op 1920 B/op 26 allocs/op
BenchmarkGJSONUnmarshalStruct-4 900000 4984 ns/op 992 B/op 4 allocs/op
BenchmarkJSONUnmarshalMap-4 600000 11394 ns/op 2968 B/op 69 allocs/op
BenchmarkJSONUnmarshalStruct-4 600000 8674 ns/op 784 B/op 9 allocs/op
BenchmarkJSONDecoder-4 300000 17150 ns/op 4133 B/op 179 allocs/op
BenchmarkFFJSONLexer-4 1500000 3821 ns/op 896 B/op 8 allocs/op
BenchmarkEasyJSONLexer-4 3000000 1129 ns/op 501 B/op 5 allocs/op
BenchmarkJSONParserGet-4 3000000 498 ns/op 21 B/op 0 allocs/op
BenchmarkJSONIterator-4 3000000 1136 ns/op 677 B/op 14 allocs/op
BenchmarkConvertNone-4 50000 30790 ns/op 0 B/op 0 allocs/op
BenchmarkConvertGet-4 50000 39405 ns/op 49152 B/op 1 allocs/op
BenchmarkConvertGetBytes-4 50000 30780 ns/op 48 B/op 1 allocs/op
Benchmark testing was done on 2.3 GHz Intel Core i5, BenchMarks funcs were taken from here.
Copyright (c) 2018 Akshit Grover