XSLT équivalent de JSON

Idée intéressante. Quelques recherches sur Google produit quelques pages d'intérêt, y compris:

• un contour comment une telle "jsonT" outil pourrait être mis en œuvre, et certains téléchargements
• certains analyse de la mise en œuvre
• une société qui peut avoir mis en œuvre quelque chose de convenable

Espère que cette aide.

XSLT équivalents de JSON - une liste de candidats (les outils et les specs)

Outils

1. XSLT

   Vous pouvez utiliser XSLT pour JSON avec l'objectif de fn:json-à-xml.

   Cette section décrit les installations permettant de données JSON à être traitées à l'aide de XSLT.

2. jq
   

   jq est comme sed pour les données JSON - vous pouvez l'utiliser pour couper et le filtre et la carte et de transformer des données structurées avec la même facilité que sed, awk, grep et amis vous permettent de jouer avec le texte.
   Il y a des packages d'installation pour les différents OS.

3. jj
   

   JJ est un utilitaire de ligne de commande qui fournit un moyen rapide et simple de récupérer ou mettre à jour les valeurs de documents JSON. Il est alimenté par GJSON et SJSON sous le capot.

4. fx
   

   De ligne de commande JSON outil de traitement de

   • N'avez pas besoin d'apprendre une nouvelle syntaxe
   • Plaine JavaScript
   • Mise en forme et en mettant en évidence
   • Autonome binaire

5. jl
   

   jl ("JSON lambda") est un petit langage fonctionnel pour l'interrogation et la manipulation JSON.

6. SECOUSSE
   

   JSON JSON transformation de la bibliothèque écrite en Java, où le "cahier des charges" pour le transformer, c'est lui-même un document JSON.

7. gron
   

   Faire JSON greppable!
   gron transforme JSON dans discrètes affectations pour le rendre plus facile à grep pour ce que vous voulez et voir l'absolu "chemin" pour elle. Il facilite l'exploration de l'Api que le retour de grosses gouttes de JSON, mais avoir de terribles documentation.

8. json
   

   json est un fast-CLI outil pour travailler avec JSON. C'est un fichier unique node.js le script avec l'extérieur ni deps (autres que node.js lui-même).

9. json-e
   

   JSON-e est une structure de données de paramétrage du système pour l'intégration du contexte dans objets JSON.
   L'idée centrale est de traiter d'une structure de données comme un "modèle" et de le transformer, à l'aide d'une autre structure de données de contexte, afin de produire une sortie de données de la structure.

10. JSLT
    

    JSLT est une requête complète et la transformation de la langue JSON. Le langage de conception est inspirée par jq, XPath et XQuery.

11. json transforme Dernier Commit Le 1er Décembre 2017
    

    Fournit une récursif, correspondant au modèle d'approche de la transformation de données JSON. Les Transformations sont définies comme un ensemble de règles qui correspondent à la structure d'un objet JSON. Quand un match se produit, la règle émet les données transformées, éventuellement recursing de transformer les objets enfants.

12. jsawk Dernier commit 4 mars 2015
    

    Jsawk est comme awk, mais JSON. Vous travaillez avec un tableau d'objets JSON lire depuis l'entrée standard stdin, de les filtrer à l'aide de JavaScript pour produire les résultats de tableau qui est affichée sur la sortie standard.

13. yate Dernier Commit Mar 13, 2017
    

    Tests peuvent être utilisés comme docu https://github.com/pasaran/yate/tree/master/tests

14. jsonpath-objet de transformation de la Dernier Commit 18 Janvier 2017
    

    Extrait des données à partir d'un objet littéral à l'aide de JSONPath et de générer de nouveaux objets à partir d'un modèle.

15. L'agrafage Dernier Commit Sep 16, 2013
    

    Agrafage est une bibliothèque JavaScript qui permet de XSLT mise en forme des objets JSON.
    Au lieu d'utiliser un JavaScript moteur de template et texte/html templates, Agrafage vous donne la possibilité d'utiliser des modèles XSLT - chargé de manière asynchrone avec l'Ajax et ensuite mise en cache côté client pour analyser vos sources de données JSON.

Spécifications:

• JsonPointer
  

  JSON Pointeur définit une syntaxe de la chaîne pour l'identification d'une valeur spécifique
  dans un JSON (JavaScript Object Notation) document.

• JsonPath
  

  JSONPath expressions se réfèrent toujours à une structure JSON de la même manière que l'expression XPath sont utilisés en combinaison avec un document XML

• JSPath
  

  JSPath pour le JSON, c'est comme XPath pour XML."

• JSONiq
  

  La principale source d'inspiration derrière JSONiq est XQuery, qui a été prouvée jusqu'à présent, une fructueuse et productive langage de requête pour les données semi-structurées

J'ai récemment trouvé un outil que j'aime pour le style de JSON: https://github.com/twigkit/tempo. Outil très simple à utiliser--à mon avis, il est beaucoup plus facile à travailler que XSLT--pas besoin de requêtes XPATH.

Ont un coup d'oeil à jsonpath-objet de transformation de la

J'ai écrit ma propre petite bibliothèque autour de cette, récemment, qui tente de rester le plus près

5.1 Modèle de Traitement XSLT (REC)
https://www.w3.org/TR/xslt#section-Processing-Model

que possible (comme je pouvais de toute façon), en quelques lignes de code JavaScript.

Voici quelques pas complètement trivial exemples d'utilisation...

1. JSON-pour-certains-balisage:

Violon: https://jsfiddle.net/YSharpLanguage/kj9pk8oz/10

(inspiré par D. 1 Exemple de Document XSLT (REC) https://www.w3.org/TR/xslt#section-Document-Example)

où cette:

var D1document = {
    type: "document", title: [ "Document Title" ],
    "": [
      { type: "chapter", title: [ "Chapter Title" ],
        "": [
        { type: "section", title: [ "Section Title" ],
          "": [
            { type: "para", "": [ "This is a test." ] },
            { type: "note", "": [ "This is a note." ] }
        ] },
        { type: "section", title: [ "Another Section Title" ],
          "": [
            { type: "para", "": [ "This is ", { emph: "another" }, " test." ] },
            { type: "note", "": [ "This is another note." ] }
        ] }
      ] }
    ] };

var D1toHTML = { $: [
  [ [ function(node) { return node.type === "document"; } ],
    function(root) {
      return "<html>\r\n\
  <head>\r\n\
    <title>\r\n\
      {title}\r\n".of(root) + "\
    </title>\r\n\
  </head>\r\n\
  <body>\r\n\
{*}".of(root[""].through(this)) + "\
  </body>\r\n\
</html>";
    }
  ],
  [ [ function(node) { return node.type === "chapter"; } ],
    function(chapter) {
      return "    <h2>{title}</h2>\r\n".of(chapter) + "{*}".of(chapter[""].through(this));
    }
  ],
  [ [ function(node) { return node.type === "section"; } ],
    function(section) {
      return "    <h3>{title}</h3>\r\n".of(section) + "{*}".of(section[""].through(this));
    }
  ],
  [ [ function(node) { return node.type === "para"; } ],
    function(para) {
      return "    <p>{*}</p>\r\n".of(para[""].through(this));
    }
  ],
  [ [ function(node) { return node.type === "note"; } ],
    function(note) {
      return '    <p class="note"><b>NOTE: </b>{*}</p>\r\n'.of(note[""].through(this));
    }
  ],
  [ [ function(node) { return node.emph; } ],
    function(emph) {
      return "<em>{emph}</em>".of(emph);
    }
  ]
] };

console.log(D1document.through(D1toHTML));

... donne:

<html>
  <head>
    <title>
      Document Title
    </title>
  </head>
  <body>
    <h2>Chapter Title</h2>
    <h3>Section Title</h3>
    <p>This is a test.</p>
    <p class="note"><b>NOTE: </b>This is a note.</p>
    <h3>Another Section Title</h3>
    <p>This is <em>another</em> test.</p>
    <p class="note"><b>NOTE: </b>This is another note.</p>
  </body>
</html>

et

2. JSON-à-JSON:

Violon: https://jsfiddle.net/YSharpLanguage/ppfmmu15/10

où cette:

//(A "Company" is just an object with a "Team")
function Company(obj) {
  return obj.team && Team(obj.team);
}

//(A "Team" is just a non-empty array that contains at least one "Member")
function Team(obj) {
  return ({ }.toString.call(obj) === "[object Array]") &&
         obj.length &&
         obj.find(function(item) { return Member(item); });
}

//(A "Member" must have first and last names, and a gender)
function Member(obj) {
  return obj.first && obj.last && obj.sex;
}

function Dude(obj) {
  return Member(obj) && (obj.sex === "Male");
}

function Girl(obj) {
  return Member(obj) && (obj.sex === "Female");
}

var data = { team: [
  { first: "John", last: "Smith", sex: "Male" },
  { first: "Vaio", last: "Sony" },
  { first: "Anna", last: "Smith", sex: "Female" },
  { first: "Peter", last: "Olsen", sex: "Male" }
] };

var TO_SOMETHING_ELSE = { $: [

  [ [ Company ],
    function(company) {
      return { some_virtual_dom: {
        the_dudes: { ul: company.team.select(Dude).through(this) },
        the_grrls: { ul: company.team.select(Girl).through(this) }
      } }
    } ],

  [ [ Member ],
    function(member) {
      return { li: "{first} {last} ({sex})".of(member) };
    } ]

] };

console.log(JSON.stringify(data.through(TO_SOMETHING_ELSE), null, 4));

... donne:

{
    "some_virtual_dom": {
        "the_dudes": {
            "ul": [
                {
                    "li": "John Smith (Male)"
                },
                {
                    "li": "Peter Olsen (Male)"
                }
            ]
        },
        "the_grrls": {
            "ul": [
                {
                    "li": "Anna Smith (Female)"
                }
            ]
        }
    }
}

3. XSLT vs JavaScript:

Un JavaScript équivalent de...

XSLT 3.0 REC de la Section 14.4 Exemple: le Regroupement de Nœuds en fonction de Valeurs Communes

(à http://jsfiddle.net/YSharpLanguage/8bqcd0ey/1)

Cf. https://www.w3.org/TR/xslt-30/#grouping-examples

où...

var cities = [
  { name: "Milano",  country: "Italia",      pop: 5 },
  { name: "Paris",   country: "France",      pop: 7 },
  { name: "München", country: "Deutschland", pop: 4 },
  { name: "Lyon",    country: "France",      pop: 2 },
  { name: "Venezia", country: "Italia",      pop: 1 }
];

/*
  Cf.
  XSLT 3.0 REC Section 14.4
  Example: Grouping Nodes based on Common Values

  https://www.w3.org/TR/xslt-30/#grouping-examples
*/
var output = "<table>\r\n\
  <tr>\r\n\
    <th>Position</th>\r\n\
    <th>Country</th>\r\n\
    <th>City List</th>\r\n\
    <th>Population</th>\r\n\
  </tr>{*}\r\n\
</table>".of
  (
    cities.select().groupBy("country")(function(byCountry, index) {
      var country = byCountry[0],
          cities = byCountry[1].select().orderBy("name");
      return "\r\n\
  <tr>\r\n\
    <td>{position}</td>\r\n\
    <td>{country}</td>\r\n\
    <td>{cities}</td>\r\n\
    <td>{population}</td>\r\n\
  </tr>".
        of({ position: index + 1, country: country,
             cities: cities.map(function(city) { return city.name; }).join(", "),
             population: cities.reduce(function(sum, city) { return sum += city.pop; }, 0)
           });
    })
  );

... donne:

<table>
  <tr>
    <th>Position</th>
    <th>Country</th>
    <th>City List</th>
    <th>Population</th>
  </tr>
  <tr>
    <td>1</td>
    <td>Italia</td>
    <td>Milano, Venezia</td>
    <td>6</td>
  </tr>
  <tr>
    <td>2</td>
    <td>France</td>
    <td>Lyon, Paris</td>
    <td>9</td>
  </tr>
  <tr>
    <td>3</td>
    <td>Deutschland</td>
    <td>München</td>
    <td>4</td>
  </tr>
</table>

4. JSONiq vs JavaScript:

Un JavaScript équivalent de...

JSONiq Cas D'Utilisation De La Section 1.1.2. Le groupement des Requêtes JSON

(à https://jsfiddle.net/YSharpLanguage/hvo24hmk/3)

Cf. http://jsoniq.org/docs/JSONiq-usecases/html-single/index.html#jsongrouping

où...

/*
  1.1.2. Grouping Queries for JSON
  http://jsoniq.org/docs/JSONiq-usecases/html-single/index.html#jsongrouping
*/
var sales = [
  { "product" : "broiler", "store number" : 1, "quantity" : 20  },
  { "product" : "toaster", "store number" : 2, "quantity" : 100 },
  { "product" : "toaster", "store number" : 2, "quantity" : 50 },
  { "product" : "toaster", "store number" : 3, "quantity" : 50 },
  { "product" : "blender", "store number" : 3, "quantity" : 100 },
  { "product" : "blender", "store number" : 3, "quantity" : 150 },
  { "product" : "socks", "store number" : 1, "quantity" : 500 },
  { "product" : "socks", "store number" : 2, "quantity" : 10 },
  { "product" : "shirt", "store number" : 3, "quantity" : 10 }
];

var products = [
  { "name" : "broiler", "category" : "kitchen", "price" : 100, "cost" : 70 },
  { "name" : "toaster", "category" : "kitchen", "price" : 30, "cost" : 10 },
  { "name" : "blender", "category" : "kitchen", "price" : 50, "cost" : 25 },
  {  "name" : "socks", "category" : "clothes", "price" : 5, "cost" : 2 },
  { "name" : "shirt", "category" : "clothes", "price" : 10, "cost" : 3 }
];

var stores = [
  { "store number" : 1, "state" : "CA" },
  { "store number" : 2, "state" : "CA" },
  { "store number" : 3, "state" : "MA" },
  { "store number" : 4, "state" : "MA" }
];

var nestedGroupingAndAggregate = stores.select().orderBy("state").groupBy("state")
( function(byState) {
    var state = byState[0],
        stateStores = byState[1];
    byState = { };
    return (
      (
        byState[state] =
        products.select().orderBy("category").groupBy("category")
        ( function(byCategory) {
            var category = byCategory[0],
                categoryProducts = byCategory[1],
                categorySales = sales.filter(function(sale) {
                  return stateStores.find(function(store) { return sale["store number"] === store["store number"]; }) &&
                         categoryProducts.find(function(product) { return sale.product === product.name; });
                });
            byCategory = { };
            return (
              (
                byCategory[category] =
                categorySales.select().orderBy("product").groupBy("product")
                ( function(byProduct) {
                    var soldProduct = byProduct[0],
                        soldQuantities = byProduct[1];
                    byProduct = { };
                    return (
                      (
                        byProduct[soldProduct] =
                        soldQuantities.reduce(function(sum, sale) { return sum += sale.quantity; }, 0)
                      ),
                      byProduct
                    );
                } ) //byProduct()
              ),
              byCategory
            );
        } ) //byCategory()
      ),
      byState
    );
} ); //byState()

... donne:

[
  {
    "CA": [
      {
        "clothes": [
          {
            "socks": 510
          }
        ]
      },
      {
        "kitchen": [
          {
            "broiler": 20
          },
          {
            "toaster": 150
          }
        ]
      }
    ]
  },
  {
    "MA": [
      {
        "clothes": [
          {
            "shirt": 10
          }
        ]
      },
      {
        "kitchen": [
          {
            "blender": 250
          },
          {
            "toaster": 50
          }
        ]
      }
    ]
  }
]

Il est également utile pour surmonter les limitations de JSONPath wrt. d'interroger l'ancêtre de l'axe, comme soulevé par cette SORTE de question (et certainement d'autres).

E. g., comment faire pour obtenir l'escompte d'une épicerie élément de la connaissance de sa marque id, dans

{
 "prods": [
    {
        "info": {
              "rate": 85
                },
        "grocery": [
                 {
                  "brand": "C",
                  "brand_id": "984"
                 },
                 {
                  "brand": "D",
                  "brand_id": "254"
                 }
                 ],
         "discount": "15"
    },
    {
        "info": {
              "rate": 100
                },
        "grocery": [
                 {
                  "brand": "A",
                  "brand_id": "983"
                 },
                 {
                  "brand": "B",
                  "brand_id": "253"
                 }
                 ],
         "discount": "20"
     }
 ]
}

?

Une solution possible est:

var products = {
     "prods": [
        {
            "info": {
                  "rate": 85
                    },
            "grocery": [
                     {
                      "brand": "C",
                      "brand_id": "984"
                     },
                     {
                      "brand": "D",
                      "brand_id": "254"
                     }
                     ],
             "discount": "15"
        },
        {
            "info": {
                  "rate": 100
                    },
            "grocery": [
                     {
                      "brand": "A",
                      "brand_id": "983"
                     },
                     {
                      "brand": "B",
                      "brand_id": "253"
                     }
                     ],
             "discount": "20"
         }
     ]
};

function GroceryItem(obj) {
  return (typeof obj.brand === "string") && (typeof obj.brand_id === "string");
}

    //last parameter set to "true", to grab all the "GroceryItem" instances
    //at any depth:
var itemsAndDiscounts = [ products ].nodeset(GroceryItem, true).
    map(
      function(node) {
        var item = node.value, //node.value: the current "GroceryItem" (aka "$.prods[*].grocery[*]")

            discount = node.parent. //node.parent: the array of "GroceryItem" (aka "$.prods[*].grocery")
                       parent. //node.parent.parent: the product (aka "$.prods[*]")
                       discount; //node.parent.parent.discount: the product discount

        //finally, project into an easy-to-filter form:
        return { id: item.brand_id, discount: discount };
      }
    ),
    discountOfItem983;

discountOfItem983 = itemsAndDiscounts.
  filter
  (
    function(mapped) {
      return mapped.id === "983";
    }
  )
  [0].discount;

console.log("Discount of #983: " + discountOfItem983);

... ce qui donne:

Discount of #983: 20

'HTH,

Encore une nouvelle réponse à une vieille question, je te suggère de regarder DefiantJS. Ce n'est pas une transformation XSLT équivalent de JSON, il est XSLT JSON. Le "Template" de la section de la documentation comprend cet exemple:

<!-- Defiant template -->
<script type="defiant/xsl-template">
    <xsl:template name="books_template">
        <xsl:for-each select="//movie">
            <xsl:value-of select="title"/><br/>
        </xsl:for-each>
    </xsl:template>
</script>

<script type="text/javascript">

var data = {
        "movie": [
            {"title": "The Usual Suspects"},
            {"title": "Pulp Fiction"},
            {"title": "Independence Day"}
        ]
    },
    htm = Defiant.render('books_template', data);

console.log(htm);
//The Usual Suspects<br>
//Pulp Fiction<br>
//Independence Day<br>

JSONiq est d'une telle norme, et Zorba un open-source C++ de mise en œuvre. JSONiq peut aussi être vu comme XQuery avec l'ajout de JSON comme un type de données natif.

il est très possible de la convertir en JSON à l'aide de XSLT: vous avez besoin de JSON2SAX deserializer et SAX2JSON sérialiseur.

Exemple de code en Java:
http://www.gerixsoft.com/blog/json/xslt4json

JSLT est très proche d'un JSON équivalent de XSLT. C'est une transformation de la langue où vous écrivez la partie fixe de la sortie de la syntaxe JSON, puis insérez les expressions permettant de calculer les valeurs que vous souhaitez insérer dans le modèle.

Un exemple:

{
  "time": round(parse-time(.published, "yyyy-MM-dd'T'HH:mm:ssX") * 1000),
  "device_manufacturer": .device.manufacturer,
  "device_model": .device.model,
  "language": .device.acceptLanguage
}

Il est implémenté en Java sur le dessus de Jackson.

Pourquoi ne pas vous convertit JSON en XML en utilisant M. De Données Coverter , transformer à l'aide de XSLT et ensuite le modifier en JSON à l'aide de la même.

J'ai écrit un dom adaptateur pour ma jackson en fonction json framework de traitement il y a longtemps. Il utilise le nu.xom bibliothèque. Le résultant arborescence dom fonctionne avec java xpath et xslt installations. J'ai fait certains choix d'implémentation qui sont assez simple. Par exemple le nœud racine est toujours appelé "racine", les tableaux d'aller dans un noeud ol li sous-éléments (comme en html), et tout le reste est juste un sous-nœud avec une valeur primitive ou d'une autre nœud d'objet.

JsonXmlConverter.java

Utilisation:

JsonObject sampleJson = sampleJson();
org.w3c.dom.Document domNode = JsonXmlConverter.getW3cDocument(sampleJson, "root");


Il peut être possible d'utiliser XSLT avec JSON.
Verson 3 de XPath(3.1) XSLT(3.0) et XQuery(3.1) prend en charge JSON, d'une certaine façon.
Cela semble être disponible dans la version commerciale de Saxon, et pourraient éventuellement être inclus dans le IL version.
https://www.saxonica.com/html/documentation/functions/fn/parse-json.html

-

Ce que je m'attends à partir d'une solution alternative:

Je voudrais être en mesure d'entrée JSON pour extraire un ensemble de données, et la sortie JSON ou du TEXTE.

L'accès des propriétés arbitraires et d'évaluer les valeurs

Soutien à la logique conditionnelle

Je voudrais que la transformation de scripts externes de l'outil, à base de texte, et, de préférence, une langue couramment utilisée.

Alternative potentielle?

Je me demande si SQL pourrait être une alternative appropriée.
https://docs.microsoft.com/en-us/sql/relational-databases/json/json-data-sql-server

Ce serait bien si l'autre outil pourrait manipuler du JSON et XML
https://docs.microsoft.com/en-us/sql/relational-databases/xml/openxml-sql-server

Je n'ai pas encore essayé de convertir les scripts XSLT-je utiliser pour SQL, ou d'évaluer pleinement de cette option, mais j'ai l'espoir d'y regarder de plus bientôt. Juste quelques pensées à ce jour.