JSONPath-syntaxis⚓︎

JSONPath-notatie⚓︎

Een JSONPath-expressie specificeert een pad naar een element (of een reeks elementen) in een JSON-structuur. Paden kunnen de puntnotatie gebruiken:

1	`$.store.book[0].titel`

of de haakjesnotatie:

1	`$['winkel']['boek'][0]['titel']`

of een combinatie van punt- en haakjesnotaties:

1	`$['winkel'].boek[0].titel`

Houd er rekening mee dat punten alleen vóór eigenschapsnamen worden gebruikt en niet tussen haakjes.

De voorloop $ vertegenwoordigt het hoofdobject of de array en kan worden weggelaten. Bijvoorbeeld $.foo.bar en foo.bar zijn hetzelfde, en dat geldt ook voor $[0].status en [0].status.

Andere syntaxiselementen worden hieronder beschreven.

Uitdrukking	Beschrijving
`$`	Het hoofdobject of de array.
`.property`	Selecteert de opgegeven eigenschap in een bovenliggend object.
`['property']`	Selecteert de opgegeven eigenschap in een bovenliggend object. Zorg ervoor dat u enkele aanhalingstekens rond de naam van de eigenschap plaatst. Tip: Gebruik deze notatie als de eigenschapsnaam speciale tekens bevat, zoals spaties, of begint met een ander teken dan `A..Za..z_`.
`[n]`	Selecteert het n-de element uit een array. Indexen zijn op 0 gebaseerd.
`[index1,index2,…]`	Selecteert array-elementen met de opgegeven indexen. Geeft een lijst terug .
`..property`	Recursieve afdaling: zoekt recursief naar de opgegeven eigenschapsnaam en retourneert een array met alle waarden met deze eigenschapsnaam. Geeft altijd een lijst terug, zelfs als er slechts één eigenschap wordt gevonden.
`*`	Wildcard selecteert alle elementen in een object of array, ongeacht hun namen of indexen. Betekent bijvoorbeeld `address.` alle eigenschappen van het addressobject en `book[]` alle items van de bookarray.
`[start:end]` `[start:]`	Selecteert array-elementen vanaf de startindex en tot, maar niet inclusief, de eindindex. Als end wordt weggelaten, worden alle elementen van het begin tot het einde van de array geselecteerd. Geeft een lijst terug.
`[:n]`	Selecteert de eerste n elementen van de array. Geeft een lijst terug.
`[-n:]`	Selecteert de laatste n elementen van de array. Geeft een lijst terug.
`[?(expression)]`	Expressie filteren. Selecteert alle elementen in een object of array die overeenkomen met het opgegeven filter. Geeft een lijst terug.
`[(expression)]`	Scriptexpressies kunnen worden gebruikt in plaats van expliciete eigenschapsnamen of indexen. Een voorbeeld is `[(@.length-1)]` het selecteren van het laatste item in een array. Verwijst hier lengthnaar de lengte van de huidige array in plaats van naar een JSON-veld met de naam length.
`@`	Wordt gebruikt in filterexpressies om te verwijzen naar het huidige knooppunt dat wordt verwerkt.

Opmerkingen:

JSONPath-expressies, inclusief eigenschapsnamen en -waarden, zijn hoofdlettergevoelig.
In tegenstelling tot XPath heeft JSONPath geen bewerkingen voor toegang tot bovenliggende of zusterknooppunten vanaf het gegeven knooppunt.

Filters⚓︎

Filters zijn logische expressies die worden gebruikt om arrays te filteren. Een voorbeeld van een JSONPath-expressie met een filter is

1	`$.store.book[?(@.prijs < 10)]`

waarbij @ staat voor het huidige array-item of object dat wordt verwerkt. Filters kunnen ook worden gebruikt $om naar de eigenschappen buiten het huidige object te verwijzen:

1	`$.store.book[?(@.prijs < $.expensive)]`

Een expressie die alleen een eigenschapsnaam opgeeft, zoals [?(@.isbn)], komt overeen met alle items die deze eigenschap hebben, ongeacht de waarde.

Hieronder staan de operatoren die in filters kunnen worden gebruikt.

Operator	Beschrijving
`==`	Is gelijk aan. Tekenreekswaarden moeten tussen enkele aanhalingstekens staan (geen dubbele aanhalingstekens). `[?(@.color=='red')]`.
`!=`	Niet gelijk aan. Tekenreekswaarden moeten tussen enkele aanhalingstekens staan. `[?(@.color!='red')]`.
`>`	Groter dan.
`>=`	Groter dan of gelijk aan.
`<`	Kleiner dan.
`<=`	Kleiner dan of gelijk aan.
`=~`	Komt overeen met een reguliere JavaScript-expressie. Komt bijvoorbeeld overeen met items waarvan de beschrijving begint met `cat` (niet hoofdlettergevoelig): `[?(@.description =~ /cat.*/i)]`
`!`	Wordt gebruikt om een filter teniet te doen: `[?(!@.isbn)]` komt overeen met items die de eigenschap `isbn` niet hebben.
`&&`	Logische `AND`, gebruikt om meerdere filterexpressies te combineren. `[?(@.category=='fictie' && @.prijs < 10)]`
`\|\|`	Logische OR, gebruikt om meerdere filterexpressies te combineren. `[?(@.category=='fictie' \|\| @.prijs < 10)]`
`in`	Controleert of de waarde aan de linkerkant aanwezig is in de lijst aan de rechterkant. Vergelijkbaar met de SQL IN-operator. Tekenreeksvergelijking is hoofdlettergevoelig. `[?(@.maat in ['M', 'L'])]` `[?('S' in @.maten)]`
`nin`	Tegenovergestelde van in. Controleert of de waarde aan de linkerkant niet aanwezig is in de lijst aan de rechterkant. Tekenreeksvergelijking is hoofdlettergevoelig. `[?(@.maat nin ['M', 'L'])]` `[?('S' nin @.maten)]`
`subsetof`	Controleert of de array aan de linkerkant een subset is van de array aan de rechterkant. De werkelijke volgorde van array-items doet er niet toe. Tekenreeksvergelijking is hoofdlettergevoelig. Een lege array aan de linkerkant komt altijd overeen. Bijvoorbeeld: `[?(@.sizes subsetof ['M', 'L'])]` – komt overeen als `sizes` is `['M']` of `['L']` of `['L', 'M']` maar komt niet overeen als de array nog andere elementen bevat. `[?(['M', 'L'] subsetof @.sizes)]` – komt overeen als sizeshet minstens `'M'` en bevat `'L'`.
`contains`	Controleert of een string de opgegeven substring bevat (hoofdlettergevoelig) of dat een array het opgegeven element bevat. `[?(@.naam bevat 'Alex')]` `[?(@.nummers bevat 7)]` `[?('ABCDEF' bevat @.karakter)]`
`size`	Controleert of een array of string de opgegeven lengte heeft. `[?(@.naam maat 4)]`
`empty true`	Komt overeen met een lege array of string. `[?(@.naam leeg waar)]`
`empty false`	Komt overeen met een niet-lege array of tekenreeks. `[?(@.naam leeg false)]`

Voorbeelden⚓︎

Zie voor voorbeelden JSONPath Syntax

JSONPath Syntax Geraadpleegd op december 2023

2023-12-22