jsonpath-plus/jsonpathEin Fork von JSONPath von http://goessner.net/articles/JsonPath/
(siehe auch Lizenzen für dev. Abhängigkeiten)
Analysieren, transformieren und selektiv Daten aus JSON-Dokumenten (und JavaScript-Objekten) extrahieren.
jsonpath-plus erweitert die ursprüngliche Spezifikation um einige
zusätzliche Operatoren und macht einige Verhaltensweisen explizit, die
die ursprüngliche Spezifikation nicht klar definiert hat.
Probieren Sie die Browser-Demo oder Runkit (Node).
Bitte beachten: Dieses Projekt wird derzeit nicht aktiv gepflegt. Wir akzeptieren möglicherweise gut dokumentierte PRs oder einige einfache Updates, beabsichtigen jedoch nicht, selbst Fehlerbehebungen vorzunehmen oder neue Funktionen hinzuzufügen.
^ zum Abrufen des übergeordneten Elements eines übereinstimmenden Objekts~ zum Abrufen von Eigenschaftsnamen übereinstimmender Objekte (als Array)@null(), @boolean(), @number(), @string(), @array(), @object()@integer()@scalar() (akzeptiert auch undefined und
nicht-endliche Zahlen, wenn JavaScript-Objekte abgefragt werden, sowie alle grundlegenden Nicht-Objekt-/Nicht-Funktionstypen)@other(), verwendbar in Verbindung mit einem benutzerdefinierten jsonpath-plus ist bei großen und kleinen Datensätzen im Vergleich zu anderen JSON-Abfragebibliotheken durchweg leistungsfähig, gemäß json-querying-performance-testing. Sie können diese Ergebnisse überprüfen, indem Sie das Projekt selbst ausführen und weitere Leistungstests hinzufügen.
npm install jsonpath-plus
## Einrichtung
### Node.js```js
const {JSONPath} = require('jsonpath-plus');
const result = JSONPath({path: '...', json});
Für die Verwendung im Browser können Sie dist/index-browser-umd.cjs direkt einbinden; keine
Browserify-Magie ist erforderlich:```html
### ESM (Moderne Browser)
Sie können auch ES6-Modulimporte verwenden (für moderne Browser):```html
<script type="module">
import {
JSONPath
} from './node_modules/jsonpath-plus/dist/index-browser-esm.js';
const result = JSONPath({path: '...', json: {}});
</script>
Oder wenn du dein JavaScript bündelst (z. B. mit Rollup), verwende einfach,
wobei zu beachten ist, dass mainFields
für Browser-Builds browser enthalten sollte (für Node sollte die Standardeinstellung, die
module prüft, in Ordnung sein):```js
import {JSONPath} from 'jsonpath-plus';
const result = JSONPath({path: '...', json});
## Verwendung
Die vollständige verfügbare Signatur lautet:```
const result = JSONPath([options,] path, json, callback, otherTypeCallback);
Die Argumente path, json, callback und otherTypeCallback
können alternativ (zusammen mit allen anderen verfügbaren
Eigenschaften) auch auf options angegeben werden.
Beachten Sie, dass result alle gefundenen Elemente enthält (optional
in ein Array gewickelt), während callback verwendet werden kann, wenn
Sie eine Operation ausführen möchten, sobald jedes Element gefunden wird,
wobei die Callback-Funktion 0 bis N Mal ausgeführt wird, abhängig von
der Anzahl der unabhängigen Elemente, die im Ergebnis gefunden werden.
Weitere Informationen zu den verfügbaren Argumenten von JSONPath
finden Sie in der folgenden Dokumentation.
Siehe auch die API-Dokumentation.
Die Eigenschaften, die auf dem Optionsobjekt oder in der
evaluate-Methode (als erstes Argument) angegeben werden können, umfassen:
false angegeben wird,
kann die evaluate-Methode manuell aufgerufen werden.wrap auf false gesetzt ist und
keine Ergebnisse gefunden werden, wird undefined zurückgegeben (im Gegensatz
zu einem leeren Array, wenn wrap auf true gesetzt ist). Wenn auf
gesetzt ist und ein einzelnes nicht-Array-Ergebnis gefunden wird, wird
dieses Ergebnis als einziges Element zurückgegeben (nicht innerhalb eines
Arrays). Wenn mehrere Ergebnisse gefunden werden, wird jedoch weiterhin ein
Array zurückgegeben. Um Mehrdeutigkeiten zu vermeiden (falls es notwendig ist,
zwischen einem Ergebnis, das ein Fehlschlag ist, und einem, das ein leeres Array
ist, zu unterscheiden), wird empfohlen, den Standard auf zu ändern.autostart auf false gesetzt ist. Sie
kann für wiederholte Auswertungen mit derselben Konfiguration verwendet werden.
Neben den aufgeführten Eigenschaften kann das letztere Methodenmuster
jede der anderen zulässigen Instanzeigenschaften akzeptieren (außer
autostart, das hier keine Relevanz hätte).['$', 'aProperty', 'anotherProperty'].$['aProperty']['anotherProperty][0]. Die JSONPath-Endkonstruktionen
~ und ^ sowie Typoperatoren wie @string() werden
stillschweigend entfernt./aProperty/anotherProperty/0
(wobei alle internen ~- und /-Zeichen gemäß der JSON-Pointer-Spezifikation
maskiert werden). Die JSONPath-Endkonstruktionen ~ und ^ und
Typoperatoren wie werden stillschweigend entfernt.Gegeben sei das folgende JSON, entnommen von http://goessner.net/articles/JsonPath/:```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 } } }
und die folgende XML-Darstellung:```xml
<store>
<book>
<category>reference</category>
<author>Nigel Rees</author>
<title>Sayings of the Century</title>
<price>8.95</price>
</book>
<book>
<category>fiction</category>
<author>Evelyn Waugh</author>
<title>Sword of Honour</title>
<price>12.99</price>
</book>
<book>
<category>fiction</category>
<author>Herman Melville</author>
<title>Moby Dick</title>
<isbn>0-553-21311-3</isbn>
<price>8.99</price>
</book>
<book>
<category>fiction</category>
<author>J. R. R. Tolkien</author>
<title>The Lord of the Rings</title>
<isbn>0-395-19395-8</isbn>
<price>22.99</price>
</book>
<bicycle>
<color>red</color>
<price>19.95</price>
</bicycle>
</store>
Bitte beachten Sie, dass die untenstehenden XPath-Beispiele nicht zwischen dem
Abrufen von Elementen und deren Textinhalt unterscheiden (außer wo dies für
Vergleiche nützlich ist oder um Mehrdeutigkeiten zu vermeiden). Hinweis: Zum Testen
der XPath-Beispiele (einschließlich 2.0-Beispiele) kann diese Demo
hilfreich sein (auf xml oder xml-strict eingestellt).| XPath | JSONPath | Ergebnis | Anmerkungen |
|-------------------------------------------------------------------------------------|---------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| /store/book/author | $.store.book[*].author | Die Autoren aller Bücher im Store | Kann auch ohne das als dargestellt werden (auch wenn dies nicht in der ursprünglichen Spezifikation enthalten ist); beachten Sie jedoch, dass einige Zeichenliterale ( und ) ein Escaping erfordern |
| | | Alle Autoren | |
| | | Alle Dinge im Store, nämlich seine Bücher (ein Buch-Array) und ein rotes Fahrrad (ein Fahrrad-Objekt). | |
| | | Der Preis von allem im Store. | |
| | | Das dritte Buch (Buch-Objekt) | |
| | | Das letzte Buch in der Reihenfolge. | Um auf eine Eigenschaft mit einem Sonderzeichen zuzugreifen, verwenden Sie für den Filter (diese spezielle Funktion ist nicht in der ursprünglichen Spezifikation enthalten) |
| | | Die ersten beiden Bücher | |
| oder in XPath 2.0 | | Die Kategorien und Autoren aller Bücher | |
| | | Filtert alle Bücher mit einer ISBN-Nummer | Um auf eine Eigenschaft mit einem Sonderzeichen zuzugreifen, verwenden Sie für den Filter (diese spezielle Funktion ist nicht in der ursprünglichen Spezifikation enthalten) |
| | | Filtert alle Bücher, die günstiger als 10 sind | |
| | | Ermittelt alle Eigenschaftswerte von Objekten, deren Eigenschaft price ist und die nicht 8.95 entsprechen | Da das bloße das Filtern von Objekten nach Eigenschaftswert erlaubt (nicht unbedingt innerhalb von Arrays), können Sie nach dem Ausdruck hinzufügen, um an das Objekt zu gelangen, das die gefilterten Eigenschaften besitzt |
| | | Die Wurzel des JSON-Objekts (d. h. das gesamte Objekt selbst) | Um ein literales zu erhalten (allein oder irgendwo im Pfad), müssen Sie das Backtick-Escape verwenden |
| | | Alle Elemente (und Text) unterhalb der Wurzel in einem XML-Dokument. Alle Mitglieder einer JSON-Struktur unterhalb der Wurzel. | |
| | | Alle Elemente in einem XML-Dokument. Alle übergeordneten Komponenten einer JSON-Struktur einschließlich der Wurzel. | Dieses Verhalten wurde in der ursprünglichen Spezifikation nicht direkt festgelegt |
| | | Übergeordnetes Element derjenigen Elemente mit einem Preis größer als 19 (d. h. der Store-Wert als übergeordnetes Element des Fahrrads und das Buch-Array als übergeordnetes Element eines einzelnen Buchs) | Parent (Caret) ist nicht in der ursprünglichen Spezifikation enthalten |
| (in XPath 2.0) | | Die Eigenschaftsnamen des Store-Unterobjekts ("book" und "bicycle"). Nützlich bei Wildcard-Eigenschaften. | Eigenschaftsname (Tilde) ist nicht in der ursprünglichen Spezifikation enthalten |
| (in XPath 2.0) | | Alle Bücher außer demjenigen an dem Pfad, der auf das erste zeigt | ist nicht in der ursprünglichen Spezifikation enthalten |
| | | Ermittelt alle Kategorien von Büchern, bei denen das übergeordnete Objekt des Buchs ein Fahrrad-Kind hat, dessen Farbe rot ist (d. h. alle Bücher) | ist nicht in der ursprünglichen Spezifikation enthalten |
| | | Ermittelt alle Kinder von "book" außer den "category"-Kindern | ist nicht in der ursprünglichen Spezifikation enthalten |
| | | Ermittelt alle Bücher, deren Eigenschaft (die, da wir in ein Array hineingreifen, der numerische Index ist) nicht 0 ist | ist nicht in der ursprünglichen Spezifikation enthalten |
| | | Ermittelt die Enkelkinder von Store, deren übergeordnete Eigenschaft nicht book ist (d. h. die Kinder des Fahrrads, "color" und "price") | ist nicht in der ursprünglichen Spezifikation enthalten |
| | | Ermittelt die Eigenschaftswerte aller Buch-Instanzen, wobei die übergeordnete Eigenschaft dieser Werte (d. h. der Array-Index, der das übergeordnete Objekt des Buch-Elements enthält) nicht 0 ist | ist nicht in der ursprünglichen Spezifikation enthalten |
| | | Filtert alle Bücher, deren Preis dem Preis des dritten Buchs entspricht | ist nicht in der ursprünglichen Spezifikation enthalten |
| (in XPath 2.0) | | Ermittelt die numerischen Werte innerhalb des Buch-Arrays | , die anderen Basistypen (, ), weitere abgeleitete Typen auf niedriger Ebene (, , ), der von JSONSchema hinzugefügte Typ , der zusammengesetzte Typ (der außerdem und nicht-endliche Zahlen für JavaScript-Objekte sowie alle grundlegenden Nicht-Objekt-/Nicht-Funktionstypen akzeptiert), der Typ , der in Verbindung mit einem benutzerdefinierten Callback verwendet werden soll (siehe ), sowie die folgenden Nicht-JSON-Typen, die dennoch mit JSONPath verwendet werden können, wenn Nicht-JSON-JavaScript-Objekte abgefragt werden (, , ) sind nicht in der ursprünglichen Spezifikation enthalten |
| (XPath 2.0) | | Alle Kategorien von Büchern, die dem regulären Ausdruck entsprechen (enden mit "TION", ohne Beachtung der Groß-/Kleinschreibung) | ist nicht in der ursprünglichen Spezifikation enthalten. |
| (XPath 2.0) | | Alle Bücher, die eine Eigenschaft besitzen, die dem regulären Ausdruck entspricht (enden mit "TION", ohne Beachtung der Groß-/Kleinschreibung) | ist nicht in der ursprünglichen Spezifikation enthalten. Hinweis: Verwendet den Parent-Selektor am Ende des Ausdrucks, um zum übergeordneten Objekt zurückzukehren; ohne den Parent-Selektor werden die beiden -Schlüsselwerte abgeglichen. |
| | (z. B. , um eine Eigenschaft mit dem wörtlichen Namen abzugleichen) | Escaped die gesamte folgende Sequenz (die als Literal behandelt werden soll) | ist nicht in der ursprünglichen Spezifikation enthalten; um ein literales Backtick zu erhalten, verwenden Sie ein zusätzliches Backtick zum Escapen |Any additional variables supplied as properties on the optional "sandbox"
object option are also available to (parenthetical-based)
evaluations.
@, das eine
Referenz auf seine Kinder ist, tatsächlich auch die unmittelbaren Kinder aus,
während in XPath Filterbedingungen nicht die Kinder auswählen, sondern
festlegen, welche seiner Elternknoten im Ergebnis erhalten werden.Eine grundlegende Befehlszeilenschnittstelle (CLI) wird bereitgestellt. Verwenden Sie sie mit npx jsonpath-plus <json-file> <jsonpath-query>.
|) und Gruppierung.Ausführen der Tests auf Node:```shell npm test
Für In-Browser-Tests:
- Stellen Sie die js/html-Dateien bereit:```shell
npm run browser-test
Bitte lesen Sie SECURITY.md für wichtige Sicherheitsaspekte und Anweisungen, wie Sie Schwachstellen melden können.
otherTypeCallback@undefined(), @function(), @nonFinite())@path/@parent/@property/@parentProperty/@root Kurzschreibselektoren innerhalb von Filtern` zum Escapen der restlichen Sequenz@['...']/?@['...']-Syntax zum Escapen von Sonderzeichen innerhalb
von Eigenschaftsnamen in Filtern$.. (Abrufen aller übergeordneten Komponenten)wrapfalsefalsesafe: Im Browser wird eine minimale Skript-Engine verwendet, die weder
eval noch Function nutzt und die Content Security Policy erfüllt. In NodeJS
hat dies keine Auswirkung und entspricht native, da Skripte dort sicher sind.
native: verwendet die nativen Skriptfähigkeiten, d. h. unsicheres eval oder
Function im Browser und vm.Script in Node.js. false: Deaktiviert JavaScript-
Auswertungsausdrücke und wirft Ausnahmen, wenn solche Ausdrücke versucht werden.
callback [ (code, context) => value]: Eine benutzerdefinierte Implementierung,
die mit code und context als Argumenten aufgerufen wird, um den ausgewerteten
Wert zurückzugeben.
class: Eine Klasse, die mit code als Konstruktorargument erstellt wird und
deren Code durch Aufruf von runInNewContext mit context ausgewertet wird.
``parentProperty
dieses Wurzelknotens innerhalb der Ergebnisse zurückzugeben. Dies kann ein
String-Eigenschaftsname oder ein numerischer Array-Index sein.resultType),
der Typ der Nutzlast (ob es sich um einen normalen "value" oder einen
"property"-Namen handelt) und ein vollständiges Nutzlastobjekt (mit allen
resultTypes).@other() am Ende der Abfrage hinzufügt. Wenn ein solcher Pfad
auftritt, wird der otherTypeCallback mit dem Wert des Elements, seinem Pfad,
seinem übergeordneten Element und dem Eigenschaftsnamen seines übergeordneten
Elements aufgerufen. Er sollte einen booleschen Wert zurückgeben, der angibt, ob
der gelieferte Wert zum Typ "other" gehört oder nicht (oder er kann Transformationen
durchführen und false zurückgeben).@string()$.store.book[*].author$@//author$..author/store/*$.store.*/store//price$.store..price//book[3]$..book[2]//book[last()]$..book[(@.length-1)]$..book[-1:][(@['...'])]//book[position()<3]$..book[0,1]$..book[:2]//book/*[self::category\|self::author]//book/(category,author)$..book[0][category,author]//book[isbn]$..book[?(@.isbn)][?@['...']]//book[price<10]$..book[?(@.price<10)]//*[name() = 'price' and . != 8.95]$..*[?(@property === 'price' && @ !== 8.95)]@^/$$//*/*\|//*/*/text()$..*//*$..//*[price>19]/..$..[?(@.price>19)]^/store/*/name()$.store.*~/store/book[not(. is /store/book[1])]$.store.book[?(@path !== "$['store']['book'][0]")]@path//book[parent::*/bicycle/color = "red"]/category$..book[?(@parent.bicycle && @parent.bicycle.color === "red")].category@parent//book/*[name() != 'category']$..book.*[?(@property !== "category")]@property//book[position() != 1]$..book[?(@property !== 0)]@property/store/*/*[name(parent::*) != 'book']$.store.*[?(@parentProperty !== "book")]@parentProperty//book[count(preceding-sibling::*) != 0]/*/text()$..book.*[?(@parentProperty !== 0)]@parentProperty//book[price = /store/book[3]/price]$..book[?(@.price === @root.store.book[2].price)]@root//book/../*[. instance of element(*, xs:decimal)]$..book..*@number()@number()@boolean()@string()@null()@object()@array()@integer()@scalar()undefined@other()otherTypeCallback@undefined()@function()@nonFinite()//book/*[name() = 'category' and matches(., 'tion$')]$..book.*[?(@property === "category" && @.match(/TION$/i))]@property//book/*[matches(name(), 'bn$')]/parent::*$..book.*[?(@property.match(/bn$/i))]^@property^isbn` `$$`