Gratis JSONPath-tester — evalueer queries online

Wat is een JSONPath-tester?

// The expression you build in this tester maps straight onto the
// RFC 9535 reference library used under the hood.
import { query, paths } from 'jsonpath-rfc9535';

const document = {
  store: {
    book: [
      { title: 'Sayings of the Century', author: 'Nigel Rees', price: 8.95 },
      { title: 'Sword of Honour', author: 'Evelyn Waugh', price: 12.99 },
      { title: 'Moby Dick', author: 'Herman Melville', price: 8.99 },
      { title: 'The Lord of the Rings', author: 'J. R. R. Tolkien', price: 22.99 }
    ]
  }
};

// Values: query(document, path) returns the matched values directly.
const titles = query(document, '$.store.book[*].title');
// → ['Sayings of the Century', 'Sword of Honour', 'Moby Dick', 'The Lord of the Rings']

// Filter: books cheaper than 10.
const cheap = query(document, '$.store.book[?(@.price < 10)].title');
// → ['Sayings of the Century', 'Moby Dick']

// Normalized paths: paths(document, path) returns where each match lives.
const authorPaths = paths(document, '$..author');
// → ["$['store']['book'][0]['author']", "$['store']['book'][1]['author']", ...]

// RFC 9535 functions like length() are used INSIDE filters, not as a segment.
const longTitles = query(document, '$.store.book[?length(@.title) > 15]');
// → the two books whose title is longer than 15 characters

Belangrijkste functies

Uitgewerkte voorbeelden

$.store.book[*].title

["Sayings of the Century", "Sword of Honour", "Moby Dick", "The Lord of the Rings"]

$.store.book[?(@.price < 10)].title

["Sayings of the Century", "Moby Dick"]

$..author

["Nigel Rees", "Evelyn Waugh", "Herman Melville", "J. R. R. Tolkien"]

$.store.book[0:2].title

["Sayings of the Century", "Sword of Honour"]

$.store.book[?length(@.title) > 15]

[{"title": "Sayings of the Century", "author": "Nigel Rees", "price": 8.95}, {"title": "The Lord of the Rings", "author": "J. R. R. Tolkien", "price": 22.99}]

$.store.book[0]['title','author']

["Sayings of the Century", "Nigel Rees"]

Hoe gebruik je de JSONPath-tester

1. 1

   Plak of upload je JSON

   Sleep JSON in het invoervak, plak het, of klik op Uploaden om een .json- / .txt-bestand van schijf te laden. JSON formatteren springt het document opnieuw in. Ongeldige JSON wordt inline gemarkeerd met een parserbericht voordat je een query uitvoert.

2. 2

   Kies een engine

   RFC 9535 (de IETF-standaard uit 2024, geen eval) is de standaard. Schakel naar Klassiek (Goessner) wanneer je een expressie uitvoert die je uit een ouder tool zoals jsonpath.com hebt gekopieerd, zodat de resultaten overeenkomen met wat je daar zag.

3. 3

   Typ je JSONPath-expressie

   De leidende $ wordt voor je getoond. Begin met een kindpad zoals .store.book[*].title, een index zoals [0], een recursieve afdaling zoals ..author, of een filter zoals [?(@.price < 10)]. Resultaten worden live bijgewerkt terwijl je typt.

4. 4

   Schakel de resultaatweergave

   Waarden toont een JSON-array van getroffen waarden. Paden toont het genormaliseerde pad van elke treffer zoals $['store']['book'][0]['title']. Beide toont ze naast elkaar zodat je elke waarde aan zijn exacte locatie in het document kunt koppelen.

5. 5

   Kopieer het resultaat of deel een permalink

   Resultaat kopiëren plaatst de uitvoer op je klembord. Link kopiëren codeert de JSON, expressie, engine en weergave in een URL-hash (geen upload) zodat een collega de exacte query lokaal op zijn eigen machine kan reproduceren.

Veelvoorkomende JSONPath-fouten

store.book[*].title  →  invalid (no root)

$.store.book[*].title  →  selects every title

$.store.book[0:2]  →  first TWO books, not three

$.store.book[0:3]  →  first three books (indices 0,1,2)

Classic filter run under RFC 9535  →  parse error or unexpected nodes

Switch engine to Classic (Goessner)  →  reproduces the original result

$.store.book.length()  →  parse error (not a valid RFC 9535 segment)

$.store.book[?length(@.title) > 15]  →  books with a title over 15 chars

$.store.book[?($.price < 10)]  →  wrong scope

$.store.book[?(@.price < 10)]  →  books under 10

$[store][book]  →  invalid bracket selectors

$['store']['book']  →  same as $.store.book

$..price  →  every price anywhere in the tree

$.store.book[*].price  →  only book prices

Wie gebruikt dit tool

Extraheer velden uit een API-antwoord

Haal request-ID's, geneste resource-attributen of een lijst met namen uit een JSON-payload zonder doorloopcode te schrijven. Bouw het pad hier tegen een voorbeeldantwoord, bevestig dat het precies de knooppunten teruggeeft die je wilt in de weergave Waarden, en plak vervolgens de gevalideerde expressie in je applicatie of test.

Schrijf asserties voor integratietests

Veel testframeworks en contracttesttools (REST Assured, Karate, Postman) gebruiken JSONPath om op responsbodies te asserteren. Stel het assertiepad hier op, verifieer dat het het juiste knooppunt selecteert tegen een echt antwoord, en kopieer het naar je test — zo vang je een verkeerd pad op voordat de suite rood wordt.

Configureer datatransformaties in pijplijnen

Kubernetes, AWS Step Functions, Azure Logic Apps en veel ETL-tools accepteren JSONPath om velden in event-payloads te adresseren. Prototypeer het exacte pad hier tegen een representatief event, bevestig dat het resolveert, en plaats het in je pijplijnconfiguratie met de zekerheid dat het wijst waar je bedoelt.

Reproduceer een jsonpath.com-resultaat privé

Heb je een expressie van een serverafhankelijke evaluator maar kun je je data niet in een externe site plakken? Schakel naar de modus Klassiek (Goessner), laad je JSON en reproduceer hetzelfde resultaat lokaal — geen payload verlaat ooit je browser, dus bedrijfseigen data blijft op je machine.

Migreer verouderde expressies naar RFC 9535

Overstappen naar een systeem dat RFC 9535-conformiteit adverteert? Voer een verouderde expressie uit in de Klassieke modus, schakel dan naar de RFC 9535-engine om te zien of die nog parseert en dezelfde knooppunten matcht. De vergelijking met dubbele engine wijst de filter-, unie- en functieverschillen aan die je anders in productie zou tegenkomen.

Debug waarom een pad de verkeerde knooppunten teruggeeft

Een pad dat te veel of te weinig selecteert, is moeilijk te beredeneren op basis van de waarden alleen. Schakel naar de weergave Paden om de genormaliseerde locatie van elke treffer te zien — de exacte array-index, de exacte ledenketen — en de off-by-one-slice of verdwaalde recursieve afdaling wordt onmiddellijk duidelijk.

Onderwijs of beoordeel JSONPath

Open een werkende expressie tegen voorbeelddata en loop er selector voor selector doorheen, terwijl je wisselt tussen Waarden en Paden zodat de lerende zowel ziet wat wordt geselecteerd als waar het zich bevindt. Het spiekblad en de uitgewerkte voorbeelden bieden een gestructureerde referentie voor codereview of onboarding.

Engine- en algoritmenotities

RFC 9535-engine (jsonpath-rfc9535, zonder afhankelijkheden)

De standaardengine implementeert de IETF RFC 9535-grammatica direct: hij tokeniseert en parseert de expressie tot een abstracte syntaxisboom en interpreteert die tegen het document. Er is nergens in het pad eval of de Function-constructor, dus hij is immuun voor de klasse van eval-injectiebugs en draait onder een strikt Content-Security-Policy.

Klassieke engine (jsonpath-plus, eval uitgeschakeld)

De engine Klassiek (Goessner) is jsonpath-plus, vastgezet op een gepatchte release (>= 10.4.0) en geconstrueerd met de eval-optie expliciet op false. Dat behoudt de compatibiliteit met het Goessner-dialect en sluit tegelijk de vectoren voor externe code-uitvoering af die worden bijgehouden als CVE-2024-21534 en CVE-2025-1302, die het standaard op eval gebaseerde filterpad van de bibliotheek troffen.

Generatie van genormaliseerde paden

Elke treffer wordt gerapporteerd met zijn genormaliseerde RFC 9535-pad — een canonieke vorm met enkele aanhalingstekens in haaknotatie ($['store']['book'][0]['title']) met array-indexen als kale gehele getallen. Genormaliseerde paden zijn stabiel en uniek per knooppunt, dus gelijkwaardige expressies leveren identieke paden op, waarop de weergaven Paden en Beide vertrouwen voor ondubbelzinnige resultaatidentificatie.

Lui geladen engine-chunks

Beide engines worden als afzonderlijke JavaScript-chunks geladen, alleen wanneer ze voor het eerst worden geselecteerd, zodat de initiële pagina licht blijft en de engine die je niet gebruikt nooit wordt gedownload. Van engine wisselen herevalueert de huidige expressie onmiddellijk tegen het huidige document, zonder pagina-herlaad.

Lokaal bestanden lezen en JSON formatteren

De knop Uploaden gebruikt de browser-FileReader-API om een .json- of .txt-bestand volledig aan de clientzijde in de invoer te lezen — het bestand wordt nooit verzonden. JSON formatteren parseert en serialiseert de invoer opnieuw met inspringing van twee spaties en brengt parsefouten inline naar voren zodat misvormde JSON wordt opgevangen vóór evaluatie.

Permalinks via URL-hash (nooit verzonden)

De deelstatus wordt gecodeerd in het location.hash-fragment, dat de JSON, de expressie, de actieve engine en de resultaatweergave draagt. Browsers nemen het fragment nooit op in HTTP-verzoeken, dus de servers van go-tools.org ontvangen nul data wanneer een permalink wordt geopend; hydratatie gebeurt volledig op het apparaat van de ontvanger.

JSONPath best practices

Kies de engine die bij je doel past

Als je downstream-systeem RFC 9535-conformiteit adverteert, schrijf en valideer dan tegen de RFC 9535-engine. Als je een expressie van een ouder tool of bibliotheek reproduceert of onderhoudt, gebruik dan Klassiek (Goessner). Valideren tegen het verkeerde dialect is de meest voorkomende reden dat een pad dat in de tester werkte, in productie faalt.

Verifieer met de weergave Paden, niet alleen Waarden

De weergave Waarden vertelt je wat overeenkwam; de weergave Paden vertelt je waar. Wanneer een query de juist ogende waarden teruggeeft, kan hij ze toch uit de verkeerde locatie selecteren — een verdwaalde recursieve afdaling of een te brede wildcard. Controleer de genormaliseerde paden om te bevestigen dat de expressie precies de knooppunten raakt die je bedoelt.

Let op het exclusieve einde van een slice

[0:2] selecteert indexen 0 en 1, niet 0 tot en met 2 — de eindgrens is exclusief, net als in Python en JavaScript. Off-by-one-slicefouten zijn de meest voorkomende JSONPath-bug. Gebruik de weergave Paden om de exacte index van elk geselecteerd element te lezen en de grens te bevestigen voordat je oplevert.

Verkies een expliciet pad boven recursieve afdaling waar mogelijk

$..price is handig maar matcht elke prijs overal in het document, inclusief die je niet bedoelde. Wanneer je de structuur kent, schrijf het pad dan uit ($.store.book[*].price) zodat de query precies en voorspelbaar blijft naarmate de data groeit. Reserveer .. voor werkelijk onregelmatige of onbekende vormen.

Houd witruimte en aanhalingstekens consistent in filters

RFC 9535 volgt zijn grammatica exact voor filterexpressies, terwijl het klassieke dialect losser is. Schrijf filters netjes — citeer stringliterals met enkele aanhalingstekens ('fiction'), houd operatoren gespatieerd en vermijd te leunen op soepel parsen — zodat dezelfde expressie op dezelfde manier evalueert ongeacht welke engine of bibliotheek uiteindelijk draait.

Veelgestelde vragen