Json.Path¶
- Subclasses:
None
Methods¶
- Inherited:
- Structs:
class |
|
class |
|
|
|
|
Virtual Methods¶
- Inherited:
Properties¶
None
Signals¶
- Inherited:
Fields¶
- Inherited:
Class Details¶
- class Json.Path(**kwargs)¶
- Bases:
- Abstract:
No
- Structure:
JsonPathis a simple class implementing the JSONPath syntax for extracting data out of a JSON tree.While the semantics of the JSONPath expressions are heavily borrowed by the XPath specification for XML, the syntax follows the ECMAScript origins of JSON.
Once a
JsonPathinstance has been created, it has to compile a JSONPath expression using [method`Json`.Path.compile] before being able to match it to a JSON tree; the sameJsonPathinstance can be used to match multiple JSON trees. It it also possible to compile a new JSONPath expression using the sameJsonPathinstance; the previous expression will be discarded only if the compilation of the new expression is successful.The simple convenience function [func`Json`.Path.query] can be used for one-off matching.
- Syntax of the JSONPath expressions
A JSONPath expression is composed by path indices and operators. Each path index can either be a member name or an element index inside a JSON tree. A JSONPath expression must start with the
$operator; each path index is separated using either the dot notation or the bracket notation, e.g.:``` // dot notation $.store.book[0].title
// bracket notation $’’store’ [‘book’]’’0 [‘title’]’ ```
The available operators are:
The
$character represents the root node of the JSON tree, and matches the entire document.Child nodes can either be matched using
.or[]. For instance, both$.store.bookand$['store']['book']match the contents of the book member of the store object.Child nodes can be reached without specifying the whole tree structure through the recursive descent operator, or
... For instance,$..authormatches all author member in every object.Child nodes can grouped through the wildcard operator, or
*. For instance,$.store.book[*].authormatches all author members of any object element contained in the book array of the store object.Element nodes can be accessed using their index (starting from zero) in the subscript operator
[]. For instance,$.store.book[0]matches the first element of the book array of the store object.Subsets of element nodes can be accessed using the set notation operator
[i,j,...]. For instance,$.store.book[0,2]matches the elements 0 and 2 (the first and third) of the book array of the store object.Slices of element nodes can be accessed using the slice notation operation
[start:end:step]. If start is omitted, the starting index of the slice is implied to be zero; if end is omitted, the ending index of the slice is implied to be the length of the array; if step is omitted, the step of the slice is implied to be 1. For instance,$.store.book[:2]matches the first two elements of the book array of the store object.
More information about JSONPath is available on Stefan Gössner’s JSONPath website.
- Example of JSONPath matches
The following example shows some of the results of using
JsonPathon a JSON tree. We use the following JSON description of a bookstore:``json { “store”: {
- “book”: [
- { “category”: “reference”, “author”: “Nigel Rees”,
“title”: “Sayings of the Century”, “price”: “8.95” },
- { “category”: “fiction”, “author”: “Evelyn Waugh”,
“title”: “Sword of Honour”, “price”: “12.99” },
- { “category”: “fiction”, “author”: “Herman Melville”,
“title”: “Moby Dick”, “isbn”: “0-553-21311-3”, “price”: “8.99” },
- { “category”: “fiction”, “author”: “J. R. R. Tolkien”,
“title”: “The Lord of the Rings”, “isbn”: “0-395-19395-8”, “price”: “22.99” }
], “bicycle”: { “color”: “red”, “price”: “19.95” }
}
}¶
We can parse the JSON using [class`Json`.Parser]:
``c JsonParser *parser = json_parser_new (); json_parser_load_from_data (parser, json_data, -1, NULL); ``
If we run the following code:
``c JsonNode *result; JsonPath *path = json_path_new (); json_path_compile (path, “$.store..author”, NULL); result = json_path_match (path, json_parser_get_root (parser)); ``
The
resultnode will contain an array with all values of the author member of the objects in the JSON tree. If we use a [class`Json`.Generator] to convert theresultnode to a string and print it:``c JsonGenerator *generator = json_generator_new (); json_generator_set_root (generator, result); char *str = json_generator_to_data (generator, NULL); g_print (“Results: %sn”, str); ``
The output will be:
``json [“Nigel Rees”,”Evelyn Waugh”,”Herman Melville”,”J. R. R. Tolkien”] ``
New in version 0.14.
- classmethod new()¶
- Returns:
the newly created path
- Return type:
Creates a new
JsonPathinstance.Once created, the
JsonPathobject should be used with [method`Json`.Path.compile] and [method`Json`.Path.match].New in version 0.14.
- classmethod query(expression, root)¶
- Parameters:
- Raises:
- Returns:
a newly-created node of type
JSON_NODE_ARRAYcontaining the array of matching nodes- Return type:
Queries a JSON tree using a JSONPath expression.
This function is a simple wrapper around [ctor`Json`.Path.new], [method`Json`.Path.compile], and [method`Json`.Path.match]. It implicitly creates a
JsonPathinstance, compiles the given expression and matches it against the JSON tree pointed byroot.New in version 0.14.
- compile(expression)¶
- Parameters:
expression (
str) – a JSONPath expression- Raises:
- Returns:
TRUEif the compilation was successful, andFALSEotherwise- Return type:
Validates and decomposes the given expression.
A JSONPath expression must be compiled before calling [method`Json`.Path.match].
New in version 0.14.
- match(root)¶
- Parameters:
root (
Json.Node) – the root node of the JSON data to match- Returns:
a newly-created node of type
JSON_NODE_ARRAYcontaining the array of matching nodes- Return type:
Matches the JSON tree pointed by
rootusing the expression compiled into theJsonPath.The nodes matching the expression will be copied into an array.
New in version 0.14.