Guide de requête JSONPath : Extraire précisément les données imbriquées du JSON

Qu'est-ce que JSONPath

JSONPath est un langage de requête pour JSON, similaire à XPath pour XML, qui extrait précisément les données d'un JSON imbriqué complexe :

{
  "store": {
    "books": [
      {"title": "The Three-Body Problem", "price": 68},
      {"title": "To Live", "price": 45},
      {"title": "One Hundred Years of Solitude", "price": 55}
    ]
  }
}

Utilisez $.store.books[*].title pour extraire tous les titres : ["The Three-Body Problem", "To Live", "One Hundred Years of Solitude"]

Référence de syntaxe de base

Syntaxe	Signification	Exemple
`$`	Nœud racine	`$`
`.`	Nœud enfant	`$.store`
`[]`	Index de tableau ou nœud enfant	`$[0]`, `$['key']`
`*`	Caractère générique, tous les éléments	`$.store.*`
`..`	Descente récursive, tous les niveaux	`$..title`
`[start:end]`	Tranche de tableau	`$[0:2]`
`[?(expr)]`	Expression de filtre	`$[?(@.price > 50)]`

Syntaxe expliquée en détail

Nœud racine $

$ représente la racine JSON. Tous les chemins commencent par $ :

$           → Tout le JSON
$.store     → L'objet store

Accès aux nœuds enfants .

Utilisez . ou [] pour accéder aux nœuds enfants :

$.store.books        → Le tableau books
$.store['books']     → Forme équivalente ; requise lorsque les noms de clés contiennent des caractères spéciaux

Index de tableau []

$.store.books[0]     → Premier livre
$.store.books[-1]    → Dernier livre
$.store.books[0:2]   → Deux premiers livres (tranche)

Caractère générique *

$.store.books[*]           → Tous les livres
$.store.books[*].title     → Tous les titres

Descente récursive ..

.. recherche à tous les niveaux sans avoir besoin du chemin complet :

$..title     → Tous les champs title à n'importe quel niveau
$..price     → Tous les champs price à n'importe quel niveau

.. est particulièrement utile dans les réponses d'API profondément imbriquées.

Expressions de filtre ?()

Le filtrage est la fonctionnalité la plus puissante de JSONPath :

Opérateurs de comparaison

Opérateur	Signification	Exemple
`==`	Égal à	`$[?(@.price == 45)]`
`!=`	Différent de	`$[?(@.price != 45)]`
`>`	Supérieur à	`$[?(@.price > 50)]`
`<`	Inférieur à	`$[?(@.price < 50)]`
`>=`	Supérieur ou égal à	`$[?(@.price >= 55)]`

Opérateurs logiques

$[?(@.price > 50 && @.price < 70)]    → Prix entre 50 et 70
$[?(@.category == 'fiction' || @.price < 40)]    → Fiction ou prix inférieur à 40

Correspondance de chaînes

$[?(@.title =~ /Three.*/)]    → Titre commençant par « Three »

Utilisation de l'outil JSONPath

Étape 1 : Ouvrir l'outil

Visitez l'outil JSONPath pour accéder à l'interface de requête.

Étape 2 : Saisir les données JSON

Collez votre réponse d'API ou vos données JSON dans la zone de saisie. Vous pouvez d'abord les embellir avec le Formateur JSON.

Étape 3 : Écrire une expression JSONPath

Entrez une expression dans la zone de requête, ex. $.data.users[*].name.

Étape 4 : Voir les résultats d'extraction

L'outil affiche les résultats correspondants en temps réel et met en surbrillance les nœuds correspondants dans la source.

Pratique : Extraction de données à partir de réponses d'API

Exemple d'API GitHub

{
  "items": [
    {"full_name": "vuejs/vue", "stargazers_count": 45000, "language": "TypeScript"},
    {"full_name": "facebook/react", "stargazers_count": 42000, "language": "JavaScript"}
  ]
}

$.items[*].full_name              → Tous les noms de dépôts
$.items[?(@.stargazers_count > 43000)].full_name  → Noms de dépôts avec Stars > 43000

Extraction de données paginées

$.data.list[*].id                 → Tous les IDs sur la page actuelle
$.pagination.next_cursor          → Curseur de la page suivante

JSONPath vs JMESPath

Comparaison	JSONPath	JMESPath
Style de syntaxe	Type XPath	Type SQL/pipe
Recherche récursive	`..` supporté nativement	Requiert une traversée explicite
Syntaxe de filtre	`[?(@.x > 1)]`	`[?x >` 1`]`
Projection/transformation	Non supporté	Supporte `[*].{n: name}`
Tri des résultats multiples	Non garanti	Peut trier
Outil	JSONPath	JMESPath

Utilisez JSONPath pour l'extraction simple, JMESPath pour la transformation/projection.

Problèmes courants

Problème	Cause	Solution
La requête renvoie vide	Faute de frappe dans le chemin	Vérifier la casse des noms de clés
Le filtre ne fonctionne pas	Différence de version de syntaxe	Confirmer la version de syntaxe supportée par l'outil
Index de tableau hors limites	L'index dépasse la plage	Utiliser `[*]` ou vérifier la longueur du tableau
Trop de résultats récursifs	`..` a correspondu à tous les niveaux	Réduire la portée ou ajouter des conditions de filtre
Erreur de clé avec caractères spéciaux	La clé contient `.` ou `-`	Utiliser la syntaxe à crochets `['key.name']`

Résumé

JSONPath est un outil puissant pour travailler avec les données JSON. Maîtrisez les six éléments de syntaxe de base — $, ., [], *, .., ?() — et vous pourrez extraire précisément les données de n'importe quel JSON imbriqué. L'outil JSONPath fournit des requêtes en temps réel avec positionnement en surbrillance, tandis que JMESPath et le Formateur JSON complètent votre flux de traitement des données JSON.