bhmj / jsonslice Goto Github PK

/i || @.name =~ /bbb.

$ go get github.com/bhmj/jsonslice

import "github.com/bhmj/jsonslice"
import "fmt"

func main() {
    var data = []byte(`
    { "sku": [ 
        { "id": 1, "name": "Bicycle", "price": 160, "extras": [ "flashlight", "pump" ] },
        { "id": 2, "name": "Scooter", "price": 280, "extras": [ "helmet", "gloves", "spare wheel" ] }
      ]
    } `)

    a, _ := jsonslice.Get(data, "$.sku[0].price")
    b, _ := jsonslice.Get(data, "$.sku[1].extras.count()")
    c, _ := jsonslice.Get(data, "$.sku[?(@.price > 200)].name")
    d, _ := jsonslice.Get(data, "$.sku[?(@.extras.count() < 3)].name")

    fmt.Println(string(a)) // 160
    fmt.Println(string(b)) // 3
    fmt.Println(string(c)) // ["Scooter"]
    fmt.Println(string(d)) // ["Bicycle"]
}
$ echo '[{"name":"abc"}, {"name":"def"}]' | ./build/jsonslice '$[0].name' 
"abc"

$ echo '[{"name":"abc"}, {"name":"def"}]' | .build//jsonslice '$[0:1].name'
["abc"]

$ cat example/sample1.json | ./build/jsonslice '$[0].author'

  $                   -- root node (can be either object or array)
  $.node              -- dot-notated child
  $.node.deeper       -- dot-notated child (chain of them)
  $.'some node'       -- dot-notated child (syntax extension)
  ['node']            -- bracket-notated child
  ['foo','bar']       -- bracket-notated children (aggregation)
  [5]                 -- array index
  [-5]                -- negative index means "from the end"
  [1:9]               -- array slice
  [1:9:2]             -- array slice (+step)
  .*  .[*]  .[:]      -- wildcard
  ..key               -- deepscan
  .'\''               -- escape sequences supported (\", \', \n, \r, \t, \0, \\)
  .'\x0A'            -- escaped hex bytes supported
  .'\u00F6'          -- escaped 16-bit unicode codepoints supported
  .'\U000000F6'      -- escaped 32-bit unicode codepoints supported

  $.obj.length()      -- number of elements in an array or string length, depending on the obj type
  $.obj.count()       -- same as above
  $.val.size()        -- value size in bytes (as is)

  $.arr[start:end:step]
  $.arr[start:end]

  [?(<expression>)]  -- filter expression. Applicable to arrays only
  @                  -- the root of the current element of the array. Used only within a filter.
  @.val              -- a field of the current element of the array.

$ go test -bench=. -benchmem -benchtime=4s
goos: darwin
goarch: amd64
pkg: github.com/bhmj/jsonslice
cpu: Intel(R) Core(TM) i9-9880H CPU @ 2.30GHz
++ usually you need to unmarshal the whole JSON to get an object by jsonpath (for reference):
Benchmark_Unmarshal-16                    398998      11268 ns/op    4272 B/op    130 allocs/op
++ and here's a jsonslice.Get:
Benchmark_Jsonslice_Get_Simple-16        1660604       2885 ns/op      24 B/op      1 allocs/op
++ Get() involves parsing a jsonpath, here it is:
Benchmark_JsonSlice_ParsePath-16        11955015        400 ns/op       0 B/op      0 allocs/op
++ if you aggregate some non-contiguous elements, it may take a bit longer (extra mallocs involved):
Benchmark_Jsonslice_Get_Aggregated-16    1000000       4335 ns/op     313 B/op     10 allocs/op
++ usual unmarshalling a large json:
Benchmark_Unmarshal_10Mb-16                  100   40787414 ns/op     224 B/op      5 allocs/op
++ jsonslicing the same json, target element is near the start:
Benchmark_Jsonslice_Get_10Mb_First-16    3459492       1370 ns/op      24 B/op      1 allocs/op
++ jsonslicing the same json, target element is near the end: still beats Unmarshal
Benchmark_Jsonslice_Get_10Mb_Last-16         133   35731931 ns/op      54 B/op      1 allocs/op
PASS
ok      github.com/bhmj/jsonslice       52.452s
package main 
import "github.com/bhmj/jsonslice"
import "fmt"

func main() {
    var data = []byte(`
    { "sku": [ 
        { "id": 1, "name": "Bicycle", "price": 160, "extras": [ "flashlight", "pump" ] },
        { "id": 2, "name": "Scooter", "price": 280, "extras": [ "helmet", "gloves", "spare wheel" ] }
      ]
    } `)

    a, _ := jsonslice.Get(data, "$*")

    fmt.Println(string(a)) // 160

}
json := `{
  "arr": [
    {
      "name": "jack",
      "create_time": "2020-01-01",
      "age": 10
    },
    {
      "name": "wow",
      "create_time": "2020-02-01",
      "age": 11
    }
  ]
}`
jsonslice.Get([]byte(json), "$.arr[?(@.create_time > format("yyyy-mm-dd", 2019-12-30))].name")

var data = []byte(`
	 [
	    { "runs-on": 1, "name": "Bicycle", "price": 160, "extras": [ "flashlight", "pump" ] },
	    { "runs-on": 2, "name": "Scooter", "price": 280, "extras": [ "helmet", "gloves", "spare wheel" ] }
	  ]
	 `)
a, _ := jsonslice.Get(data, "$[*].runs-on")

jsonpath := "$.a.b[:].['c','d']"
jsonRaw:=[]byte(`{"a":{"b":[{"c":"cc1","d":"dd1"},{"c":"cc2","d":"dd2"}]}}`)
result, err := jsonslice.Get(jsonRaw, jsonpath)

{
    "object": {
        "key": "value",
        "array": [
            {"key": "something"},
            {"key": {"key": "russian dolls"}}
        ]
    },
    "key": "top"
}

[
  "top",
  "value",
  "something",
  {
    "key": "russian dolls"
  },
  "russian dolls"
]

[{"bar": [{"baz": "hello"}]}]

["hello"]

[["hello"]]

{
	"store": {
		"book": [
			{
				"category": "fiction",
				"author": "J. R. R. Tolkien",
				"title": "The Lord of the Rings",
				"isbn": "0-395-19395-8",
				"price": 22.99
			}
		]
	}
}

Operator	Description
math	`+` `-` `` `/` `%` `*`
`===`	Strict equality (mimics JavaScript). Examples: `true===true, 42===42`
`==`	Abstract equality (mimics JavaScript). Examples: `true=="1", 42=="42"`. Use single or double quotes for string expressions. `[?(@.color=='red')]` or `[?(@.color=="red")]`
`!=`	Abstract not equal to `[?(@.author != "Herman Melville")]`
`!==`	Strict not equal to `?(@.tag !== "1")`
`>`	Greater than `[?(@.price > 10)]`
`>=`	Greater than or equal to
`<`	Less than
`<=`	Less than or equal to
`=~`	Match a regexp `[?(@.name =~ /sword.*/i]`
`!~` or `!=~`	Don't match a regexp `[?(@.name !~ /sword.*/i]`
`&&`	Logical AND `[?(@.price < 10 && @isbn)]`
`\|\|`	Logical OR `[?(@.price > 10 \|\| @.category == 'reference')]`
`!`	Logical NOT `[?([email protected]_expensive)]`
`\|`	Bitwise OR `[?(@.bits\|@.pieces > 0)]`
`&`	Bitwise AND `[?(@.bits & 7 == 1)]`
`^`	Bitwise XOR `[?(@.bits ^ 1 > 0)]`
`~`	Bitwise NOT `[?([email protected] == 0xF0)]`
`<<`	Bitwise left shift `[?(@.bits << 1 == 2)]`
`>>`	Bitwise right shift `[?(@.bits >> 1 == 0)]`

Function	Description	Output
min()	Provides the min value of an array of numbers	Double
max()	Provides the max value of an array of numbers	Double
avg()	Provides the average value of an array of numbers	Double

bhmj / jsonslice Goto Github PK

jsonslice's Introduction

JSON Slice

What is it?

Getting started

1. install

2. use it

Package functions

Specs and references

Syntax features

Expressions

Overview

Functions

Slices

Filters

Filter operators

Comparison details

Examples

Benchmarks (Core i9-9880H)

Changelog

Roadmap

Contributing

Licence

Author

jsonslice's People

Contributors

Stargazers

Forkers

jsonslice's Issues

Recommend Projects

Recommend Topics

Recommend Org