JSONPath -- XPath for JSON - draft-goessner-dispatch-jsonpath-00 (F)

From RFC.Wiki
Jump to: navigation, search
Groupe de travail réseau                                    S. Gössner
Internet-Draft                                              Fachhochschule Dortmund
Statut prévu:                                               Standards Track C. Bormann, Ed.
Expire: 13 janvier 2021                                     Universität Bremen TZI
                                                            12 juillet 2020


                       JSONPath - XPath pour JSON
                  draft-goessner-dispatch-jsonpath-00

Abstrait

   insérer le résumé ici

Contribuant

   Ce document reprend la spécification JSONPath populaire datée
   2007-02-21 et en fournit une définition plus normative. C'est
   comme une soumission au groupe de travail IETF DISPATCH, afin de trouver
   la bonne façon de normaliser complètement cette spécification. Dans
   son état actuel, c'est un document provisoire montrant ce qui doit être
   couvert.

   Les commentaires et les problèmes peuvent être adressés au référentiel github _insert
   repo here_ ainsi que (pour le moment où la maison la plus permanente est
   en cours de décision) sur la liste de diffusion dispatch@ietf.org.

Statut de ce mémo

   Ce projet Internet est soumis en pleine conformité avec le
   dispositions des BCP 78 et BCP 79.

   Internet-Drafts sont des documents de travail de l'Internet Engineering
   Groupe de travail (IETF). Notez que d'autres groupes peuvent également distribuer
   documents de travail sous forme de brouillons Internet. La liste des sites Internet actuels
   Drafts se trouve à https://datatracker.ietf.org/drafts/current/.

   Les projets Internet sont des projets de documents valables pour une durée maximale de six mois
   et peut être mis à jour, remplacé ou obsolète par d'autres documents à tout moment
   temps. Il est inapproprié d'utiliser Internet-Drafts comme référence
   matériel ou de les citer autrement que comme «travaux en cours».

   Ce projet Internet expirera le 13 janvier 2021.

Copyright

   Copyright (c) 2020 IETF Trust et les personnes identifiées comme
   auteurs de documents. Tous les droits sont réservés.


   Ce document est soumis au BCP 78 et aux mentions légales de l'IETF Trust.
   Dispositions relatives aux documents de l'IETF (https://trustee.ietf.org/
   licence-info) en vigueur à la date de publication de ce document.
   Veuillez lire attentivement ces documents, car ils décrivent vos droits
   et restrictions concernant ce document. Composants du code
   extrait de ce document doit inclure le texte de la licence BSD simplifiée
   comme décrit à la section 4.e des dispositions légales du Trust et sont
   fourni sans garantie comme décrit dans la licence BSD simplifiée.

Table des matières

   1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . 2
     1.1. Terminologie . . . . . . . . . . . . . . . . . . . . . . . . 3
     1.2. Inspiré par XPath. . . . . . . . . . . . . . . . . . . . . . 3
     1.3. Présentation des expressions JSONPath. . . . . . . . . . . . 4
   2. Exemples JSONPath. . . . . . . . . . . . . . . . . . . . . . . . 7
   3. Définition détaillée . . . . . . . . . . . . . . . . . . . . . . 9
   4. Discussion . . . . . . . . . . . . . . . . . . . . . . . . . . . dix
   5. Considérations IANA. . . . . . . . . . . . . . . . . . . . . . . dix
   6. Références . . . . . . . . . . . . . . . . . . . . . . . . . . . dix
     6.1. Références normatives  . . . . . . . . . . . . . . . . . . . dix
     6.2. Références informatives. . . . . . . . . . . . . . . . . . . 11
   Annexe A. Premières implémentations de JSONPath . . . . . . . . . . 11
     A.1. La mise en oeuvre. . . . . . . . . . . . . . . . . . . . . . 11
     A.2. Utilisation. . . . . . . . . . . . . . . . . . . . . . . . . 12
     A.3. Paramètres . . . . . . . . . . . . . . . . . . . . . . . . . 12
     A.4. Valeur de retour . . . . . . . . . . . . . . . . . . . . . . 12
     A.5. Exemple JavaScript . . . . . . . . . . . . . . . . . . . . . 12
     A.6. Exemple PHP. . . . . . . . . . . . . . . . . . . . . . . . . 12
     A.7. Résultats. . . . . . . . . . . . . . . . . . . . . . . . . . 13
   Remerciements . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
   Adresses des auteurs. . . . . . . . . . . . . . . . . . . . . . . . 13


1. Introduction

   Ce document reprend la spécification JSONPath populaire datée
   2007-02-21 [JSONPath-orig] et fournit une définition plus normative
   pour ça. Il est destiné à être soumis au groupe de travail IETF DISPATCH, en
   afin de trouver la bonne façon de terminer la normalisation de ce
   spécification. Dans son état actuel, c'est un document de paille
   montrant ce qui doit être couvert.


1.1. Terminologie

   Les mots clés "DOIT", "NE DOIT PAS", "OBLIGATOIRE", "DOIT", "NE DOIT PAS",
   "DEVRAIT", "NE DEVRAIT PAS", "RECOMMANDÉ", "NON RECOMMANDÉ", "MAI", et
   "FACULTATIF" dans ce document doit être interprété comme décrit dans
   BCP 14 [RFC2119] [RFC8174] quand, et seulement quand, ils apparaissent dans tous
   majuscules, comme illustré ici.

   Les règles grammaticales de ce document doivent être interprétées comme
   décrit dans [RFC5234].

   La terminologie de [RFC8259] s'applique.

   Élément de données: une structure conforme au modèle de données générique de JSON,
      c'est-à-dire, composé de conteneurs tels que des tableaux et des cartes (JSON
      objets), et de données atomiques telles que null, true, false, nombres,
      et les chaînes de texte.

   Objet: utilisé dans son sens générique, par exemple pour le langage de programmation
      objets. Lorsqu'un objet JSON tel que défini dans [RFC8259] est utilisé, nous
      dire spécifiquement l'objet JSON.

   Requête: nom court pour l'expression JSONPath.

   Argument: nom court de l'élément de données JSON d'une expression JSONPath
      appliqué à.

   Chemin de sortie: forme simple d'expression JSONPath qui identifie un
      Positionner en fournissant une requête qui aboutit exactement à cela
      position. Similaire à, mais syntaxiquement différent d'un JSON
      Pointeur [RFC6901].

   Position: un élément de données JSON identique ou imbriqué dans le JSON
      élément de données auquel la requête est appliquée, exprimé soit par
      la valeur de cet élément de données ou en fournissant une sortie JSONPath
      Chemin.

1.2. Inspiré par XPath

   Un avantage souvent souligné de XML est la disponibilité de
   de nombreux outils pour analyser, transformer et extraire sélectivement les données
   de documents XML. [XPath] est l'un de ces puissants outils.

   En 2007, le besoin de quelque chose pour résoudre la même classe de problèmes
   pour la communauté JSON émergente est devenue évidente, en particulier pour:

   * Trouver des données de manière interactive et les extraire de [RFC8259]
      éléments de données sans script spécial.

   * Spécification des parties pertinentes des données JSON dans une demande d'un
      client, afin que le serveur puisse réduire les données dans la réponse du serveur,
      minimiser l'utilisation de la bande passante.

   Alors, à quoi ressemble un tel outil lorsqu'il est fait pour JSON? Lors de la définition
   un JSONPath, à quoi devraient ressembler les expressions?

   L'expression XPath

   / magasin / livre [1] / titre

   ressemble à

   x.store.book [0] .title

   ou

   x ['magasin'] ['livre'] [0] ['titre']

   dans les langages de programmation populaires tels que JavaScript, Python et PHP,
   avec une variable x contenant l'élément de données JSON. Ici, nous observons que
   ces langues ont déjà une fonctionnalité fondamentalement similaire à XPath
   dans.

   L'outil JSONPath en question devrait:

   * être naturellement basé sur ces caractéristiques linguistiques.

   * ne couvre que les parties essentielles de XPath 1.0.

   * être léger dans la taille du code et la consommation de mémoire.

   * être efficace lors de l'exécution.

1.3. Présentation des expressions JSONPath

   Les expressions JSONPath s'appliquent toujours à un élément de données JSON de la même manière
   car les expressions XPath sont utilisées en combinaison avec un document XML.
   Puisqu'un élément de données JSON est généralement anonyme et ne le fait pas nécessairement
   avoir un "objet membre racine", JSONPath a utilisé le nom abstrait "$" pour
   reportez-vous à l'objet de niveau supérieur de l'élément de données.

   Les expressions JSONPath peuvent utiliser la notation _dot

   $ .store.book [0] .title

   ou la _bracket-notation_

   $ ['store'] ['book'] [0] ['title']

   pour les chemins d'entrée vers un processeur JSONPath. Où un processeur JSONPath
   utilise des expressions JSONPath à des fins internes ou comme chemins de sortie,
   ceux-ci seront toujours convertis en _bracket- plus général
   notation_.

   JSONPath autorise le symbole générique "*" pour les noms de membres et le tableau
   indices. Il emprunte l'opérateur descendant ".." à [E4X] et le
   proposition de syntaxe de tranche de tableau "[début: fin: étape]" [SLICE] de
   ECMASCRIPT 4.

   JSONPath peut utiliser un _ langage de script sous-jacent_, des expressions
   dont, écrit entre parenthèses: "(<expr>)", peut être utilisé comme
   alternative aux noms ou indices explicites comme dans:

   $ .store.book [(@. length-1)]. title

   Le symbole "@" est utilisé pour l'objet actuel. Filtrer les expressions
   sont pris en charge via la syntaxe "? (<boolean expr>)" comme dans

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

   Voici un aperçu complet et une comparaison côte à côte des
   Éléments de syntaxe JSONPath avec ses homologues XPath.

   + ======= + ================== + ========================================== +
   | XPath   | JSONPath           | Description                                |
   + ======= + ================== + ========================================== +
   | /       | $                  | l'objet / l'élément racine                 |
   + ------- + ------------------ + ------------------------------------------ +
   | .       | @                  | l'objet / l'élément actuel                 |
   + ------- + ------------------ + ------------------------------------------ +
   | /       | "." ou "[]"        | opérateur enfant                           |
   + ------- + ------------------ + ------------------------------------------ +
   | ..      | n / a              | opérateur parent                           |
   + ------- + ------------------ + ------------------------------------------ +
   | //      | ..                 | descendants imbriqués. JSONPath emprunte   |
   |         |                    | cette syntaxe d'E4X.                       |
   + ------- + ------------------ + ------------------------------------------ +
   | *       | *                  | caractère générique. Tous les objets /     |
   |         |                    | éléments quels que soient leurs noms.      |
   + ------- + ------------------ + ------------------------------------------ +
   | @       | n / a              | accès aux attributs. Éléments de données   |
   |         |                    | JSON n'ont pas d'attributs.                |
   + ------- + ------------------ + ------------------------------------------ +
   | []      | []                 | opérateur en indice. XPath l'utilise pour  |
   |         |                    | itérer sur les collections d'éléments      |
   |         |                    | et pour les prédicats. En JavaScript et    |
   |         |                    | JSON c'est l'opérateur de tableau natif.   |
   + ------- + ------------------ + ------------------------------------------ +
   | |       | [,]                | Un opérateur de l'Union dans XPath se      |
   |         |                    | traduit par un combinaison d'ensembles de  |
   |         |                    | nœuds. JSONPathautorise d'autres noms ou   |
   |         |                    | tableau indices comme un ensemble.         |
   + ------- + ------------------ + ------------------------------------------ +
   | n / a   | [début: fin: étape]| opérateur de tranche de tableau emprunté à |
   |         |                    | ES4.                                       |
   + ------- + ------------------ + ------------------------------------------ +
   | []      | ? ()               | applique une expression de filtre (script).|
   + ------- + ------------------ + ------------------------------------------ +
   | n / a   | ()                 | expression de script, à l'aide de la       |
   |         |                    | moteur de script sous-jacent.              |
   + ------- + ------------------ + ------------------------------------------ +
   | ()      | n / a              | regroupement dans Xpath                    |
   + ------- + ------------------ + ------------------------------------------ +

           Tableau 1: vue d'ensemble sur JSONPath, par rapport à XPath

   XPath a beaucoup plus à offrir (chemins de localisation en abrégé
   syntaxe, opérateurs et fonctions) que ceux répertoriés ici. De plus, il y a
   une différence significative sur le fonctionnement de l'opérateur en indice dans Xpath
   et JSONPath:

   * Les crochets dans les expressions XPath fonctionnent toujours sur le _node
      set_ résultant du fragment de chemin précédent. Des indices toujours
      commencer à 1.

   * Avec JSONPath, les crochets opèrent sur _object_ ou _array_
      adressé par le fragment de chemin précédent. Les indices commencent toujours à
      0.

2. Exemples JSONPath

   Cette section fournit d'autres exemples d'expressions JSONPath.
   Les exemples sont basés sur un simple élément de données JSON calqué sur un
   exemple XML typique représentant une librairie (qui a également
   Vélos):

   { "boutique": {
       "livre": [
         {"catégorie": "référence",
           "auteur": "Nigel Rees",
           "title": "Dictons du siècle",
           "prix": 8,95
         },
         {"catégorie": "fiction",
           "auteur": "Evelyn Waugh",
           "title": "Sword of Honor",
           "prix": 12,99
         },
         {"catégorie": "fiction",
           "auteur": "Herman Melville",
           "title": "Moby Dick",
           "isbn": "0-553-21311-3",
           "prix": 8,99
         },
         {"catégorie": "fiction",
           "auteur": "JRR Tolkien",
           "title": "Le Seigneur des Anneaux",
           "isbn": "0-395-19395-8",
           "prix": 22.99
         }
       ],
       "vélo": {
         "La couleur rouge",
         "prix": 19,95
       }
     }
   }

                      Figure 1: Exemple d'élément de données JSON

   Les exemples du tableau 2 supposent un langage de script sous-jacent qui
   permet d'obtenir le nombre d'éléments dans un tableau, de tester la
   présence d'un membre de la carte et effectuer des comparaisons numériques de la carte
   valeurs de membre avec une constante.

   + ====================== + ========================= + ================== +
   | XPath                  | JSONPath                  | Résultat           |
   + ====================== + ========================= + ================== +
   | /magasin /livre /auteur| $ .store.book [*]. auteur | les auteurs de     |
   |                        |                           | tous les livres en |
   |                        |                           | le magasin         |
   + ---------------------- + ------------------------- + ------------------ +
   | // auteur              | $ .. auteur               | tous les auteurs   |
   + ---------------------- + ------------------------- + ------------------ +
   | / magasin / *          | $ .store. *               | toutes choses en   |
   |                        |                           | magasin, qui       |
   |                        |                           | sont des livres    |
   |                        |                           | et un rouge        |
   |                        |                           | vélo.              |
   + ---------------------- + ------------------------- + ------------------ +
   | / magasin // prix      | $ .store..price           | le prix de         |
   |                        |                           | tout dans          |
   |                        |                           | le magasin.        |
   + ---------------------- + ------------------------- + ------------------ +
   | // livre [3]           | $ .. livre [2]            | le troisième livre |
   + ---------------------- + ------------------------- + ------------------ +
   | // book [last ()] | "$ .. livre [(@. longueur-1)]" | le dernier livre   |
   |                        | "$ .. livre [-1:]"        | en ordre.          |
   + ---------------------- + ------------------------- + ------------------ +
   | // book [position () <3] | "$ .. livre [0,1]"      | les deux premiers  |
   |                        | "$ .. livre [: 2]"        | livres             |
   + ---------------------- + ------------------------- + ------------------ +
   | // livre [isbn]        | $ .. livre [? (@. isbn)]  | filtrer tout       |
   |                        |                           | livres avec isbn   |
   |                        |                           | nombre             |
   + ---------------------- + ------------------------- + ------------------ +
   | // livre [prix <10]    | $ .. livre [? (@. prix <10)] | filtrer tout    |
   |                        |                           | livres moins chers |
   |                        |                           | de 10              |
   + ---------------------- + ------------------------- + ------------------ +
   | // *                   | $ .. *                | tous les éléments dans |
   |                        |                           | Document XML.      |
   |                        |                           | Tous les membres de|
   |                        |                     | Élément de données JSON. |
   + ---------------------- + ------------------------- + ------------------ +

     Tableau 2: exemples d'expressions JSONPath appliquées à l'exemple JSON
                                 élément de données

3. Définition détaillée

   [TBD: Cette section doit être étoffée en détail. Le texte donné
   ici est destiné à donner la saveur de ce détail, pas d'être le
   définition réelle qui doit être définie.]

   Les expressions JSONPath, "requêtes" pour faire court dans cette spécification, sont
   chaînes de caractères, représentées en UTF-8, sauf indication contraire
   le contexte dans lequel ils sont utilisés.

   Lorsqu'elle est appliquée à un élément de données JSON, une requête renvoie un (éventuellement vide)
   liste des "positions" dans l'élément de données qui correspondent à JSONPath
   expression.

   JSONPath = root * (étape)
   root = "$"

   step = ".." nom; descendants imbriqués
        / "." Nom ; enfant (notation par points)
        / "[" expression-valeur * ("," expression-valeur) "]"
           ; enfant [ren] (notation entre crochets)
        / "[" expression-valeur * 2 (":" expression-valeur) "]"; (tranche)
   expression-valeur = * CHIFFRE / nom
                    / expression-script / expression-filtre
   name = "'" text "'"
        / "*"; caractère générique
   script-expression = "(" script ")"
   filter-expression = "? (" script ")"
   script = <A définir en cours de normalisation>
   text = <n'importe quel texte, restrictions à définir>
   CHIFFRE =% x30-39

                   Figure 2: définition ABNF pour JSONPath

   Dans un script, @ représente la position considérée.
   [TBD: définir le langage de script sous-jacent, s'il doit y avoir un
   un standard]

   [TBD: définir la gestion des espaces]

   Un JSONPath démarre à la racine de l'argument; la "liste actuelle" des
   positions est initialisée à cette racine. Chaque étape applique la
   la sémantique de cette étape à chacune des positions dans le "courant
   list ", renvoyant une autre liste; la" liste courante "est remplacée par le
   concaténation de toutes ces listes retournées, et l'étape suivante commence.
   Lorsque toutes les étapes ont été effectuées, la "liste actuelle" est renvoyée,
   en fonction des choix du contexte soit sous forme de liste de données
   éléments ou comme une liste de chemins de sortie. [TBD: définir l'ordre de cette
   liste]

   [À déterminer: définir toutes les étapes]

   [À déterminer: définir les détails du chemin de sortie]

4. Discussion

   * Actuellement, seuls les guillemets simples sont autorisés dans JSONPath
      expressions.

   * Les expressions de script à l'intérieur des emplacements JSONPath ne sont actuellement pas
      évalué récursivement par jsonPath. Seuls les "$" globaux et locaux
      Les symboles "@" sont développés par une simple expression régulière.

   * Une alternative pour jsonPath pour retourner false en cas de non correspondance
      peut être de retourner un tableau vide à l'avenir. [C'est déjà fait
      Au dessus.]

5. Considérations IANA

   À déterminer: définir un type de média pour les expressions de chemin JSON.

6. Références

6.1. Références normatives

   [RFC2119] Bradner, S., "Mots clés à utiliser dans les RFC pour indiquer
              Niveaux d'exigence ", BCP 14, RFC 2119,
              DOI 10.17487 / RFC2119, mars 1997,
              <https://www.rfc-editor.org/info/rfc2119>.

   [RFC5234] Crocker, D., Ed. et P. Overell, "BNF augmenté pour la syntaxe
              Spécifications: ABNF ", STD 68, RFC 5234,
              DOI 10.17487 / RFC5234, janvier 2008,
              <https://www.rfc-editor.org/info/rfc5234>.

   [RFC8174] Leiba, B., "Ambiguïté entre majuscules et minuscules dans RFC
              2119 mots clés ", BCP 14, RFC 8174, DOI 10.17487 / RFC8174,
              Mai 2017, <https://www.rfc-editor.org/info/rfc8174>.

   [RFC8259] Bray, T., Ed., "The JavaScript Object Notation (JSON) Data
              Format d'échange ", STD 90, RFC 8259,
              DOI 10.17487 / RFC8259, décembre 2017,
              <https://www.rfc-editor.org/info/rfc8259>.

6.2. Références informatives

   [E4X] ISO, "Technologies de l'information - ECMAScript pour XML (E4X)
              spécification ", ISO / IEC 22537: 2006, 2006.

   [JSON-PHP] "JSON-PHP", janvier 2005,
              <http://mike.teczno.com/json.html>.

   [JSONPath-impl]
              "jsonpath (Téléchargements)", nd,
              <https://code.google.com/archive/p/jsonpath/downloads>.

   [JSONPath-orig]
              Gössner, S., "JSONPath - XPath for JSON", 21 février
              2007, <https://goessner.net/articles/JsonPath/>.

   [RFC6901] Bryan, P., Ed., Zyp, K., et M. Nottingham, Ed.,
              "Pointeur JSON (JavaScript Object Notation)", RFC 6901,
              DOI 10.17487 / RFC6901, avril 2013,
              <https://www.rfc-editor.org/info/rfc6901>.

   [SLICE] "Notation de tranche", nd,
              <https://github.com/tc39/proposal-slice-notation>.

   [XPath] Berglund, A., Boag, S., Chamberlin, D., Fernandez, M.,
              Kay, M., Robie, J. et J. Simeon, "XML Path Language
              (XPath) 2.0 (Second Edition) ", World Wide Web Consortium
              Recommandation REC-xpath20-20101214, 14 décembre 2010,
              <http://www.w3.org/TR/2010/REC-xpath20-20101214>.

Annexe A. Premières implémentations de JSONPath

   Cette annexe a été copiée de la section similaire de
   [JSONPath-orig], avec quelques modifications. Il est informatif, destiné à
   fournir plus d'exemples et donner une impression de ce qui pourrait être un
   API JSONPath typique.

A.1. la mise en oeuvre

   JSONPath est implémenté en JavaScript pour une utilisation côté client et
   porté sur PHP pour une utilisation sur le serveur.

A.2. Usage

   Il vous suffit de télécharger l'un des fichiers

   * "jsonpath.js" [JSONPath-impl]

   * "jsonpath.php" [JSONPath-impl]

   l'inclure dans votre programme et utiliser l'API simple composée d'un
   fonction unique.

   jsonPath (obj, expr [, args])

A.3. Paramètres

   obj (object | array): objet représentant l'élément de données JSON.

   expr (chaîne): chaîne d'expression JSONPath.

   args (objet | non défini): objet contrôlant l'évaluation du chemin et
      production. Actuellement, un seul membre est pris en charge.

   args.resultType ("VALUE" | "PATH"): le résultat est soit
      valeurs correspondantes (par défaut) ou expressions de chemin normalisées.

A.4. Valeur de retour

   (array | false): tableau contenant des valeurs ou un chemin normalisé
      expressions correspondant à l'expression du chemin d'entrée, qui peuvent être utilisées
      pour une évaluation paresseuse. "faux" en cas de non correspondance.

A.5. Exemple JavaScript

   var o = {/*...*/}, // l'objet JSON 'store' d'en haut
       res1 = jsonPath (o, "$ .. author"). toJSONString (),
       res2 = jsonPath (o, "$ .. author",
                       {resultType: "PATH"}). toJSONString ();

A.6. Exemple PHP

   Nous devons d'abord convertir la chaîne JSON en un tableau PHP. je suis
   en utilisant l'analyseur JSON de Michal Migurski [JSON-PHP] pour cela.

   require_once ('json.php'); // Analyseur JSON
   require_once ('jsonpath.php'); // Évaluateur JSONPath

   $ json = '{...}'; // Élément de données JSON d'en haut

   $ parser = new Services_JSON (SERVICES_JSON_LOOSE_TYPE);
   $ o = $ parser-> decode ($ json);
   $ match1 = jsonPath ($ o, "$ .. author");
   $ match2 = jsonPath ($ o, "$ .. author",
                      array ("resultType" => "PATH"));
   $ res1 = $ parser-> encode ($ match1);
   $ res2 = $ parser-> encode ($ match2);

A.7. Résultats

   Les exemples JavaScript et PHP produisent les tableaux JSON suivants
   (sous forme de chaînes):

   res1:
   ["Nigel Rees",
     "Evelyn Waugh",
     "Herman Melville",
     "J. R. R. Tolkien"
   ]
   res2:
   ["$ ['store'] ['book'] [0] ['author']",
     "$ ['store'] ['book'] [1] ['author']",
     "$ ['store'] ['book'] [2] ['author']",
     "$ ['store'] ['book'] [3] ['author']" "
   ]

   Veuillez noter que la valeur de retour de jsonPath est un tableau, qui est
   également un élément de données JSON valide. Vous voudrez donc peut-être appliquer jsonPath à
   l'élément de données résultant à nouveau ou utilisez l'un de votre tableau préféré
   méthodes comme trier avec elle.

Remerciements

   Cette spécification est basée sur l'original en ligne de Stefan Gössner
   article définissant JSONPath [JSONPath-orig].

   L'exemple des livres a été tiré de http: //coli.lili.uni-
   bielefeld.de/~andreas/Seminare/sommer02/books.xml - un lien mort maintenant.

Adresses des auteurs

   Stefan Gössner
   Fachhochschule Dortmund
   Sonnenstraße 96
   D-44139 Dortmund
   Allemagne

   Courriel: stefan.goessner@fh-dortmund.de


   Carsten Bormann (éditeur)
   Universität Bremen TZI
   Postfach 330440
   D-28359 Bremen
   Allemagne

   Tél: + 49-421-218-63921
   Courriel: cabo@tzi.org