qjson

* qjson
simple and fast json encode/decode lib.

** unmarshal json bytes to JSONTree

#+begin_src
tree,err := Decode([]byte(`{"a":1}`))
// or
tree := JSONTree{}
err := json.Unmarshal([]byte(`{"a":1}`),&tree)
#+end_src

** marshal JSONTree to bytes

#+begin_src
data, err := json.Marshal(tree)
#+end_src

** query

A QJSON Path is a text string syntax that describes a search pattern for quickly retreiving values from a JSON payload.

*** Path structure

A QJSON Path is intended to be easily expressed as a series of components seperated by a `.` character.

**** Example

Given this JSON

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

The following QJSON Paths evaluate to the accompanying values.

**** Basic

In many cases you'll just want to retreive values by object name or array index.

#+begin_src go
name.last              "Anderson"      // tree.Find(`name.last`).AsString()
name.first             "Tom"           // tree.Find(`name.first`).AsString()
age                    37              // tree.Find(`age`).AsInt()
children               ["Sara","Alex","Jack"]          // tree.Find(`children`).AsJSON()
children.0             "Sara"      // tree.Find(`children.0`).AsString()
children.1             "Alex"      // tree.Find(`children.1`).AsString()
friends.1              {"first": "Roger", "last": "Craig", "age": 68}    // tree.Find(`friends.1`).AsJSON()
friends.1.first        "Roger"          // tree.Find(`friends.1.first`).AsString()
friends.#(nets.#(=="fb")).first     ["Dale","Roger","Jane"]  // == means equal
friends.#(nets.#(="f")).first    ["Dale","Roger"]  // = means contains
friends.#(last=Craig).first   ["Roger"]
friends.#(age>47).first     ["Roger"]
friends.#(age>=47).first     ["Roger","Jane"]
friends.#(age<47).first       ["Dale"]
friends.#(age<=47).first      ["Dale","Jane"]
// example json ["a","b","c"]
#(!=c)                       ["a","b"]   // not contains c
#(!==c)                       ["a","b"]  // not equal c
#+end_src

**** Escape character

Special purpose characters, such as ., can be escaped with \.

#+begin_src go
fav\.movie             "Deer Hunter"
#+end_src

You'll also need to make sure that the `\` character is correctly escaped when hardcoding a path in you source code.

#+begin_src go
// Go
tree.Find("fav\\.movie").AsString() // "Deer Hunter" must escape the slash
tree.Find(`fav\.movie`).AsString()  // "Deer Hunter" no need to escape the slash
#+end_src

** modify

#+begin_src go
// rename Tom to Link
tree.Find(`name.first`).SetString("Link")
// change age to 12
tree.Find(`age`).SetInt(12)
#+end_src

** benchmark

#+begin_src 
goos: darwin
goarch: amd64
pkg: github.com/qjpcpu/qjson
cpu: Intel(R) Core(TM) i7-8750H CPU @ 2.20GHz
BenchmarkMarshalQJSON-12          735711              1631 ns/op            1024 B/op          1 allocs/op
BenchmarkUnmarshalQJSON-12         94591             12673 ns/op            1039 B/op         58 allocs/op
BenchmarkMarshalStd-12             50536             23592 ns/op            9979 B/op        215 allocs/op
BenchmarkUnmarshalStd-12           54302             21827 ns/op            9152 B/op        195 allocs/op
PASS
ok      github.com/qjpcpu/qjson 8.084s
#+end_src