Testeur JSONPath

Qu'est-ce que JSONPath ?

JSONPath est un langage de requête permettant d'extraire des valeurs de documents JSON. Proposé à l'origine par Stefan Goessner en 2007 comme équivalent de XPath pour XML, JSONPath vous permet d'écrire des expressions telles que $.store.book[*].author pour sélectionner tous les champs auteur dans un tableau de livres, sans écrire de boucles ni de code de parcours manuel. Le langage a été normalisé en février 2024 sous la forme de la RFC 9535, publiée par l'IETF.

Une expression JSONPath commence toujours par $ qui représente la racine du document. À partir de là, vous enchaînez des sélecteurs : la notation pointée pour les clés d'objet, la notation entre crochets pour les indices de tableau, les jokers pour tous les enfants, et l'opérateur de descente récursive (..) pour parcourir chaque niveau d'imbrication. Les expressions de filtre telles que [?(@.price < 10)] permettent de sélectionner des éléments en fonction de conditions évaluées sur leurs valeurs.

JSONPath est utilisé dans des outils de test d'API comme Postman, des plateformes d'observabilité comme Datadog et Splunk, des moteurs de workflow comme Apache NiFi, et des bibliothèques de programmation en JavaScript, Python, Go, Java et C#. Tester vos expressions sur des données réelles avant de les intégrer dans du code ou des fichiers de configuration évite les erreurs silencieuses lorsque la structure JSON ne correspond pas à vos hypothèses.

Pourquoi utiliser ce testeur JSONPath ?

Écrire des expressions JSONPath à la main est source d'erreurs. Un point manquant, un mauvais type de crochet ou une syntaxe de filtre incorrecte peut retourner des résultats vides sans message d'erreur. Cet outil vous donne un retour visuel immédiat sur ce que votre expression correspond.

Cas d'utilisation de JSONPath

Référence de la syntaxe JSONPath

La RFC 9535 définit la syntaxe JSONPath standard. Le tableau ci-dessous présente les opérateurs que vous utiliserez dans la plupart des requêtes. Toutes les expressions commencent par $ (le nœud racine) et enchaînent un ou plusieurs sélecteurs pour naviguer dans la structure du document.

JSONPath vs jq vs XPath

JSONPath, jq et XPath résolvent le même problème (interroger des données structurées) pour différents formats et cas d'usage. JSONPath cible JSON et est disponible en tant que bibliothèque dans la plupart des langages. jq est un outil CLI autonome avec son propre langage de filtres Turing-complet. XPath opère sur XML et fait partie de la pile de spécifications W3C.

Exemples de code

Comment évaluer des expressions JSONPath dans les langages et outils les plus courants. Chaque exemple utilise la même structure JSON de librairie pour la comparaison.

import { JSONPath } from 'jsonpath-plus';

const data = {
  store: {
    book: [
      { title: 'Moby Dick', price: 8.99 },
      { title: 'The Great Gatsby', price: 12.99 }
    ]
  }
};

// Get all book titles
JSONPath({ path: '$.store.book[*].title', json: data });
// → ['Moby Dick', 'The Great Gatsby']

// Recursive descent — find every price in the document
JSONPath({ path: '$..price', json: data });
// → [8.99, 12.99]

// Filter — books under $10
JSONPath({ path: '$.store.book[?(@.price < 10)]', json: data });
// → [{ title: 'Moby Dick', price: 8.99 }]

from jsonpath_ng.ext import parse
import json

data = {
    "store": {
        "book": [
            {"title": "Moby Dick", "price": 8.99},
            {"title": "The Great Gatsby", "price": 12.99}
        ]
    }
}

# Get all book titles
expr = parse("$.store.book[*].title")
titles = [match.value for match in expr.find(data)]
# → ['Moby Dick', 'The Great Gatsby']

# Recursive descent — all prices
expr = parse("$..price")
prices = [match.value for match in expr.find(data)]
# → [8.99, 12.99]

# Filter — books under $10
expr = parse("$.store.book[?price < 10]")
cheap = [match.value for match in expr.find(data)]
# → [{"title": "Moby Dick", "price": 8.99}]

package main

import (
    "fmt"
    "github.com/ohler55/ojg/jp"
    "github.com/ohler55/ojg/oj"
)

func main() {
    src := `{
        "store": {
            "book": [
                {"title": "Moby Dick", "price": 8.99},
                {"title": "The Great Gatsby", "price": 12.99}
            ]
        }
    }`

    obj, _ := oj.ParseString(src)

    // Get all book titles
    expr, _ := jp.ParseString("$.store.book[*].title")
    results := expr.Get(obj)
    fmt.Println(results)
    // → [Moby Dick The Great Gatsby]

    // Recursive descent — all prices
    expr2, _ := jp.ParseString("$..price")
    fmt.Println(expr2.Get(obj))
    // → [8.99 12.99]
}

# jq uses its own syntax, not JSONPath, but solves the same problem.
# Mapping common JSONPath patterns to jq:

# $.store.book[*].title → get all titles
echo '{"store":{"book":[{"title":"Moby Dick"},{"title":"Gatsby"}]}}' | \
  jq '.store.book[].title'
# → "Moby Dick"
# → "Gatsby"

# $..price → recursive descent for "price" keys
echo '{"a":{"price":1},"b":{"price":2}}' | \
  jq '.. | .price? // empty'
# → 1
# → 2

# Filter: books where price < 10
echo '{"store":{"book":[{"title":"A","price":8},{"title":"B","price":12}]}}' | \
  jq '.store.book[] | select(.price < 10)'
# → {"title":"A","price":8}

Questions fréquentes