Équivalent XSLT pour JSON
Existe-t-il un équivalent XSLT pour JSON? Quelque chose me permet de faire des transformations sur JSON comme XSLT le fait en XML.
Idée intéressante. Certaines recherches sur Google ont produit quelques pages d’intérêt, notamment:
- un contour de la façon dont un tel outil "jsonT" pourrait être implémenté, et quelques téléchargements
- un peu discussion de cette implémentation
- une entreprise qui peut avoir mis en œuvre quelque chose de convenable
J'espère que cela t'aides.
Équivalents XSLT pour JSON - liste des candidats (outils et spécifications)
Outils
- XSLT
Vous pouvez utiliser XSLT pour JSON dans le but de fn: json-to-xml .
Cette section décrit les fonctionnalités permettant de traiter des données JSON à l’aide de XSLT.
- jq
jq est comme sed pour les données JSON - vous pouvez l'utiliser pour découper, filtrer, mapper et transformer des données structurées avec la même facilité que celle que sed, awk, grep et vos amis vous permettent de jouer avec du texte. Il existe des packages d'installation pour différents systèmes d'exploitation.
- jj
JJ est un utilitaire de ligne de commande qui fournit un moyen simple et rapide de récupérer ou de mettre à jour des valeurs à partir de documents JSON. Il est alimenté par GJSON et SJSON sous le capot.
- fx
Outil de traitement JSON en ligne de commande
- Pas besoin d'apprendre une nouvelle syntaxe
- JavaScript simple
- Mise en forme et mise en évidence
- Binaire autonome
- jl
jl ("JSON lambda") est un petit langage fonctionnel permettant d'interroger et de manipuler JSON.
- SECOUSSE
Bibliothèque de transformation JSON à JSON écrite en Java où la "spécification" de la transformation est elle-même un document JSON.
- gron
Rendez JSON greppable! gron transforme JSON en affectations discrètes pour faciliter la recherche de ce que vous voulez et afficher son "chemin" absolu. Cela facilite l'exploration des API qui renvoient de gros blobs de JSON mais qui ont une documentation épouvantable.
- json
jSON est un outil CLI rapide permettant de travailler avec JSON. Il s'agit d'un script node.js à fichier unique ne contenant aucune dép. Externe (autre que node.js lui-même).
- json-e
JSON-e est un système de paramétrage de structure de données pour l'intégration de contexte dans des objets JSON. L'idée centrale est de traiter une structure de données comme un "modèle" et de la transformer, en utilisant une autre structure de données comme contexte, pour produire une structure de données en sortie.
- JSLT
JSLT est un langage complet de requête et de transformation pour JSON. La conception du langage est inspirée de jq, XPath et XQuery.
- json-transforms Dernière validation le 1 déc. 2017
Fournit une approche récursive de correspondance de modèles pour transformer les données JSON. Les transformations sont définies comme un ensemble de règles correspondant à la structure d'un objet JSON. Lorsqu’une correspondance est trouvée, la règle émet les données transformées, éventuellement récursives pour transformer des objets enfants.
- jsawk Dernier commit le 4 mars 2015
Jsawk est comme awk, mais pour JSON. Vous travaillez avec un tableau d'objets JSON lus à partir de stdin, vous les filtrez à l'aide de JavaScript pour générer un tableau de résultats imprimé sur la sortie standard.
- yate Dernier engagement le 13 mars 2017
Les tests peuvent être utilisés comme document https://github.com/pasaran/yate/tree/master/tests
- jsonpath-object-transform Dernière validation le 18 janvier 2017
Extrait les données d'un littéral d'objet à l'aide de JSONPath et génère un nouvel objet basé sur un modèle.
- Agrafage Dernier engagement le 16 septembre 2013
Agrafage est une bibliothèque JavaScript qui active le formatage XSLT pour les objets JSON. Au lieu d'utiliser un moteur de modélisation JavaScript et des modèles text/html, l'agrafage vous permet d'utiliser des modèles XSLT (chargés de manière asynchrone avec Ajax, puis côté client mis en cache) pour analyser vos sources de données JSON.
Spécifications:
- JsonPointer
Le pointeur JSON définit une syntaxe de chaîne pour identifier une valeur spécifique dans un document JSON (JavaScript Object Notation).
- JsonPath
Les expressions JSONPath font toujours référence à une structure JSON de la même manière que les expressions XPath sont utilisées en combinaison avec un document XML.
- JSPath
JSPath for JSON est similaire à XPath for XML. "
- JSONiq
La principale source d’inspiration derrière JSONiq est XQuery, qui s’est avéré jusqu’à présent un langage de requête efficace et productif pour les données semi-structurées.
Essayez JOLT . C'est une bibliothèque de transformation JSON à JSON écrite en Java.
Il a été créé spécifiquement parce que nous ne voulions pas jouer au jeu "JSON -> XML -> XSLT -> XML -> JSON", et l'utilisation d'un modèle pour toute transformation suffisamment complexe est irréversible.
XSLT prend en charge JSON comme indiqué à l’adresse http://www.w3.org/TR/xslt-30/#json
XML utilise angular crochets pour les jetons de délimiteur, JSON utilise des accolades, des crochets, ... I. e. Le nombre réduit de comparaisons de reconnaissance de jetons de XML signifie qu'il est optimisé pour la transformation déclarative, alors que plus de comparaisons, ressemblant à une instruction switch, supposent, pour des raisons de rapidité, une prédiction de branche spéculative pour laquelle le code impératif dans les langages de script est utile. En conséquence directe, pour différents mélanges de données semi-structurées, vous pouvez vouloir comparer les performances des moteurs XSLT et des moteurs javascript dans le cadre de pages réactives. Pour une charge de données négligeable, les transformations peuvent aussi bien fonctionner avec JSON sans sérialisation XML. La décision de W3 devrait reposer sur une meilleure analyse.
J'ai récemment trouvé un outil que j'aime beaucoup pour le style JSON: https://github.com/twigkit/tempo . Outil très facile à utiliser - à mon avis, il est beaucoup plus facile à utiliser que XSLT - pas besoin de requêtes XPATH.
jq - processeur JSON de ligne de commande léger et flexible
Ce n'est pas basé sur des modèles comme XSLT, mais plus concis. par exemple. extraire les champs name et address dans un tableau: [.name, .address]
Le tutoriel présente un exemple de transformation de l'API JSON de Twitter (et le manuel contient de nombreux exemples).
Regardez jsonpath-object-transform
Dire que le manque d'outils suggère le manque de besoin, c'est simplement poser la question. La même chose pourrait être appliquée à la prise en charge de X ou de Y sous Linux (Pourquoi se donner la peine de développer des pilotes et/ou des jeux de qualité pour un système d'exploitation aussi minoritaire? Et pourquoi s'intéresser à un système d'exploitation que les grands fabricants de matériel et de matériel ne développent pas?). Les personnes qui auraient besoin d'utiliser XSLT et JSON finissent probablement par utiliser une solution de contournement quelque peu triviale: Transformer JSON en XML. Mais ce n'est pas la solution optimale, n'est-ce pas?
Lorsque vous avez un format JSON natif et que vous souhaitez le modifier "wysywyg" dans le navigateur, XSLT constitue une solution plus que adéquate pour le problème. Faire cela avec la programmation javascript traditionnelle peut devenir une véritable galère.
En fait, j'ai implémenté une approche "âge de pierre" de XSLT, utilisant l'analyse syntaxique de sous-chaînes pour interpréter certaines commandes de base pour JavaScript, telles que l'appel de modèles, le traitement d'enfants, etc. implémenter un analyseur XML à part entière pour analyser le XSLT. Le problème est que, pour utiliser des modèles XML pour transformer un objet JSON, vous devez analyser le XML des modèles.
Pour transformer un objet JSON avec XML (ou HTML, ou texte ou autre), vous devez bien réfléchir à la syntaxe et aux caractères spéciaux à utiliser pour identifier les commandes de transformation. Sinon, vous devrez concevoir un analyseur syntaxique pour votre propre langage de templates personnalisé. Ayant parcouru ce chemin, je peux vous dire que ce n’est pas beau.
Mise à jour (12 novembre 2010): Après quelques semaines de travail sur mon analyseur, j'ai pu l'optimiser. Les modèles sont préalablement analysés et les commandes sont stockées en tant qu'objets JSON. Les règles de transformation sont également des objets JSON, tandis que le code de modèle est un mélange de HTML et d'une syntaxe homebrew similaire au code Shell. J'ai été en mesure de transformer un document JSON complexe en HTML pour en faire un éditeur de document. Le code est d'environ 1K lignes pour l'éditeur (c'est pour un projet privé donc je ne peux pas le partager) et environ 990 lignes pour le code de transformation JSON (comprend les commandes d'itération, les comparaisons simples, l'appel de modèles, l'enregistrement et l'évaluation de variables). Je prévois de le publier sous une licence MIT. Envoyez-moi un mail si vous souhaitez vous impliquer.
J'ai écrit ma propre petite bibliothèque autour de cela, récemment, qui essaie de rester aussi proche de
5.1 Modèle de traitement (XSLT REC) https://www.w3.org/TR/xslt#section-Processing-Model =
autant que possible (comme je pourrais de toute façon), en quelques lignes de code JavaScript.
Voici quelques exemples d'utilisation non-triviaux ...
1. JSON-to-some-markup:
Violon: https://jsfiddle.net/YSharpLanguage/kj9pk8oz/1
(inspiré de D.1 Exemple de document (XSLT REC) https://www.w3.org/TR/xslt#section- Document-Exemple )
où ce:
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/1
où ce:
// (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 équivalent JavaScript de ...
XSLT 3.0 REC section 14.4 Exemple: regroupement de noeuds basés sur des 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 équivalent JavaScript de ...
Cas d'utilisation JSONiq, Section 1.1.2. Regroupement des requêtes pour JSON
(à: https://jsfiddle.net/YSharpLanguage/hvo24hmk/ )
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 de surmonter les limitations de JSONPath wrt. interroger sur l'axe des ancêtres, tel que soulevé par this SO question (et certainement d'autres).
Par exemple, comment obtenir le rabais d'un article d'épicerie en connaissant son identifiant de marque,
{
"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);
... qui donne:
Discount of #983: 20
'HTH,
Il y a maintenant! J'ai récemment créé une bibliothèque, json-transforms , exactement à cette fin:
https://github.com/ColinEberhardt/json-transforms
Il utilise une combinaison de JSPath , un DSL modelé sur XPath et une approche de correspondance de motif récursive, directement inspirée de XSLT.
Voici un exemple rapide. Étant donné l'objet JSON suivant:
const json = {
"automobiles": [
{ "maker": "Nissan", "model": "Teana", "year": 2011 },
{ "maker": "Honda", "model": "Jazz", "year": 2010 },
{ "maker": "Honda", "model": "Civic", "year": 2007 },
{ "maker": "Toyota", "model": "Yaris", "year": 2008 },
{ "maker": "Honda", "model": "Accord", "year": 2011 }
]
};
Voici une transformation:
const jsont = require('json-transforms');
const rules = [
jsont.pathRule(
'.automobiles{.maker === "Honda"}', d => ({
Honda: d.runner()
})
),
jsont.pathRule(
'.{.maker}', d => ({
model: d.match.model,
year: d.match.year
})
),
jsont.identity
];
const transformed = jsont.transform(json, rules);
Quelle sortie les suivantes:
{
"Honda": [
{ "model": "Jazz", "year": 2010 },
{ "model": "Civic", "year": 2007 },
{ "model": "Accord", "year": 2011 }
]
}
Cette transformation est composée de trois règles. Le premier correspond à n'importe quelle automobile fabriquée par Honda, émettant un objet avec une propriété Honda, puis correspondant de manière récursive. La deuxième règle associe tout objet possédant une propriété maker à la sortie des propriétés model et year. La finale est la transformation d'identité qui correspond de manière récursive.
En tant que nouvelle réponse à une vieille question, je suggérerais de regarder DefiantJS . Ce n'est pas un équivalent XSLT pour JSON, il est XSLT pour JSON. La section "Modèles" de la documentation inclut 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>
J'en ai vraiment marre de l'énorme quantité de moteurs de templates JavaScript, et de tous leurs modèles HTML intégrés, de styles de balisage différents, etc., et j'ai décidé de construire une petite bibliothèque permettant le formatage XSLT. pour les structures de données JSON. Ce n'est pas sorcier, c'est JSON analysé en XML puis formaté avec un document XSLT. Il est également rapide, pas aussi rapide que les moteurs de gabarit JavaScript dans Chrome, mais dans la plupart des autres navigateurs, il est au moins aussi rapide que l’alternative au moteur JS pour les grandes structures de données.
J'utilise Camel route unmarshal (xml json) -> to (xslt) -> marshal (xmljson). Assez efficace (bien que pas parfait à 100%), mais simple si vous utilisez déjà Camel.
Yate ( https://github.com/pasaran/yate ) est spécialement conçu après XSLT, présente JPath (un équivalent naturel de XPath pour JS), compile en JavaScript et possède un historique d'utilisation en production. Il n’est pratiquement pas documenté, mais la lecture d’échantillons et de tests devrait suffire.
JSLT est très proche d'un équivalent JSON de XSLT. C'est un langage de transformation dans lequel vous écrivez la partie fixe de la sortie en syntaxe JSON, puis insérez des expressions pour 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é dans Java au-dessus de Jackson.
il est très possible de convertir JSON avec XSLT: vous avez besoin du désérialiseur JSON2SAX et du sérialiseur SAX2JSON.
Exemple de code en Java: http://www.gerixsoft.com/blog/json/xslt4json
Une approche qui n’a pas encore été donnée consiste à utiliser un générateur d’analyseur pour créer un analyseur dans XSLT qui analyse JSON et génère une sortie XML.
Le générateur d’analyseurs ReX ( http://www.bottlecaps.de/rex/ ) est une option souvent citée dans les conférences XML. Bien que totalement non documentée sur le site, des recettes sont disponibles lors de la recherche. .
Pour un doodle de travail/une preuve de concept d'une approche utilisant du JavaScript pur avec le motif familier et déclaratif derrière les expressions de correspondance et les modèles récursifs de XSLT, voir https://Gist.github.com/brettz9/0e661b3093764f496e36 =
(Une approche similaire pourrait être adoptée pour JSON.)
Notez que la démonstration repose également sur les fermetures d’expression JavaScript 1.8 pour faciliter l’expression des modèles dans Firefox (au moins jusqu’à ce que la forme abrégée des méthodes ES6 puisse être implémentée).
Disclaimer: Ceci est mon propre code.
JSON-e a des implémentations dans Node.js, Python et Go.
Pas vraiment sûr que cela soit nécessaire, et pour moi le manque d'outils suggère un manque de besoin. JSON est mieux traité en tant qu'objets (comme c'est le cas dans JS de toute façon), et vous utilisez généralement le langage des objets lui-même pour effectuer des transformations (objets Java pour Java créés à partir de JSON, idem pour Perl, Python, Perl , c #, PHP et ainsi de suite). Juste avec des assignations normales (ou set, get), en boucle, etc.
Je veux dire, XSLT est juste un autre langage, et l'une des raisons pour laquelle c'est nécessaire est que XML n'est pas une notation d'objet et que les objets des langages de programmation ne sont donc pas parfaitement ajustés (impédance entre le modèle hiérarchique xml et les objets/structures).
Pourquoi ne convertissez-vous pas JSON en XML en utilisant Mr Data Converter , transformez-le en utilisant XSLT, puis redéfinissez-le en JSON en utilisant le même procédé.
J'ai écrit un adaptateur dom pour mon framework de traitement json basé sur jackson il y a longtemps. Il utilise la bibliothèque nu.xom. L’arborescence de domaines résultante fonctionne avec les fonctionnalités Java xpath et xslt. J'ai fait des choix d'implémentation assez simples. Par exemple, le nœud racine est toujours appelé "racine", les tableaux vont dans un nœud ol avec des sous-éléments li (comme en HTML), et tout le reste n'est qu'un sous-nœud avec une valeur primitive ou un autre nœud d'objet.
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) prennent en charge le format JSON. Cela semble être disponible dans la version commerciale de Saxon, et pourrait éventuellement être inclus dans la version HE. https://www.saxonica.com/html/documentation/functions/fn/parse-json.html
-
Ce que j'attendrais d'une solution alternative:
Je voudrais pouvoir entrer en JSON pour récupérer un ensemble de données correspondant, et sortir en JSON ou en TEXT.
Accéder à des propriétés arbitraires et évaluer les valeurs
Prise en charge de la logique conditionnelle
Je voudrais que les scripts de transformation soient externes à l'outil, basés sur du texte et, de préférence, un langage couramment utilisé.
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’outil alternatif pouvait gérer 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 que j'utilise en SQL ni évalué complètement cette option, mais j'espère pouvoir l'examiner plus rapidement. Juste quelques réflexions jusqu'à présent.