Équivalent XSLT pour JSON
https://stackoverflow.com/questions/1618038
-
06-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Existe-t-il un équivalent XSLT pour JSON? Quelque chose me permettant de faire des transformations sur JSON comme XSLT le fait en XML.
La solution
Idée intéressante. Certaines recherches sur Google ont produit quelques pages intéressantes, notamment:
- un exposé sur la manière dont un "jsonT" " Cet outil peut être implémenté et certains téléchargements
- des discussion sur cette implémentation
- une entreprise qui a peut-être implémenté quelque chose approprié
J'espère que cela vous aidera.
Autres conseils
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 lire le fichier "JSON - > XML - > XSLT - > XML - > JSON " jeu, et utiliser un modèle pour toute transformation suffisamment complexe est impossible à maintenir.
É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
- Inutile d'apprendre une nouvelle syntaxe
- JavaScript simple
- Mise en forme et mise en surbrillance
- binaire autonome
- jl
jl ("JSON lambda") est un petit langage fonctionnel permettant d'interroger et de manipuler JSON.
- JOLT
Bibliothèque de transformation JSON à JSON écrite en Java où la "spécification" pour la transformation est lui-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’incorporation de contexte dans des objets JSON. L’idée centrale est de traiter une structure de données comme un "modèle". et le 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-transforme Dernier engagement le 1 déc. 2017
Fournit une approche récursive de filtrage des données JSON par correspondance de modèle. 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 de manière récurrente pour transformer les 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/ arbre / maître / tests
- jsonpath-object-transform Dernier engagement le 18 janv. 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 sept. 2013
Agrafage est une bibliothèque JavaScript qui permet 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
JSON Pointer définit une syntaxe de chaîne pour identifier une valeur spécifique au sein d'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 performant et productif pour les données semi-structurées
XSLT prend en charge JSON tel qu’il est visualisé à l'adresse http://www.w3.org/TR / xslt-30 / # json
XML utilise des crochets angulaires 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 davantage 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érentes combinaisons de données semi-structurées, il peut être utile de 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 nom et adresse dans un tableau: [.nom, .adresse]
Le tutoriel décrit un exemple de transformation de l'API JSON de Twitter (et le manual contient de nombreux exemples).
Découvrez jsonpath-object-transform
Dire que le manque d’outils suggère le manque de besoins, c’est simplement poser la question. La même chose pourrait s’appliquer à 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 faire attention au système d’exploitation que les fabricants de gros jeux et de matériels 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 l'éditer "wysywyg "" dans le navigateur, XSLT constituerait une solution plus que adéquate au problème. Faire cela avec la programmation javascript traditionnelle peut devenir une véritable galère.
En fait, j'ai mis en place un "âge de pierre". approche XSLT, en utilisant l'analyse de sous-chaîne pour interpréter certaines commandes de base pour JavaScript, telles que l'appel d'un modèle, le traitement des enfants, etc. Il est certainement plus simple d'implémenter un moteur de transformation avec un objet JSON que d'analyser le XSLT à l'aide d'un analyseur syntaxique complet. 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 en 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é. Après avoir 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 représente environ 1K lignes pour l'éditeur (c'est pour un projet privé, je ne peux donc pas le partager) et environ 990 lignes pour le code de transformation JSON (commandes d'itération, comparaisons simples, appel de modèle, sauvegarde et évaluation de variables). Je prévois de le publier sous une licence MIT. Envoyez-moi un mail si vous souhaitez vous impliquer.
J'ai récemment écrit ma propre petite bibliothèque à ce sujet, qui essaie de rester aussi proche de
Modèle de traitement 5.1 (XSLT REC) https://www.w3.org/TR/xslt#section-Processing-Model
autant que possible (comme je le pourrais de toute façon), en quelques lignes de code JavaScript.
Voici quelques exemples d'utilisation pas tout à fait triviaux ...
1. JSON-to-some-markup:
Fiddle: https://jsfiddle.net/YSharpLanguage/kj9pk8oz/10
(inspiré de Exemple de document D.1 (XSLT REC) https://www.w3.org/TR/xslt#section-Document-Example )
où cela:
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:
Fiddle: https://jsfiddle.net/YSharpLanguage/ppfmmu15/10
où cela:
// (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 ...
Section 14.4 de XSLT 3.0 REC, exemple: regroupement de noeuds basés sur des valeurs communes
(sur: http://jsfiddle.net/YSharpLanguage/8bqcd0ey/1 )
Cf. https://www.w3.org/TR/xslt-30/#grouping -exemples
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 contre JavaScript:
Un équivalent JavaScript de ...
Cas d'utilisation JSONiq Section 1.1.2. Regroupement des requêtes pour JSON
(sur: 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 de surmonter les limitations de JSONPath wrt. interroger par rapport à l'axe des ancêtres, tel que soulevé par cette question SO (et certainement d'autres).
Exemple: comment obtenir le rabais d'un article d'épicerie en connaissant son identifiant de marque, 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 la suivante:
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,
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 inspiré de XPath et une approche de correspondance de modèle récursive, inspiré directement par 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 est la sortie suivante:
{
"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 à toute 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 correspond à tout objet possédant une propriété maker , générant les propriétés modèle et année . La dernière est la transformation d’identité qui correspond de manière récursive.
Comme nouvelle réponse à une vieille question, je vous suggère de consulter DefiantJS . Ce n'est pas un équivalent XSLT pour JSON, il est XSLT pour JSON. Le " Templating " 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>
J'en ai vraiment marre de l'énorme quantité de moteurs de templates JavaScript, 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 templates 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 Camels route umarshal (xmljson) - > à (xlst) - > marshal (xmljson). Assez efficace (mais pas à 100% parfait), mais simple si vous utilisez déjà Camel.
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
Yate ( https://github.com/pasaran/yate ) est spécifiquement conçu après XSLT. , présente JPath (un équivalent naturel de XPath pour JS), compile en JavaScript et dispose d’un historique historique d’utilisation de la 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.
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, identiques pour Perl, Python, Perl, c #, PHP, etc.). sur). Juste avec des assignations normales (ou set, get), en boucle et ainsi de suite.
Je veux dire, XSLT n’est qu’un autre langage, et l’une des raisons qui l’a amenée est que XML n’est pas une notation d’objet et que les objets des langages de programmation ne sont donc pas des ajustements exacts (impédance entre le modèle hiérarchique xml et les objets / structures).
Pourquoi ne convertissez-vous pas JSON en XML avec M. Data Coverter , transformez-le à l'aide de XSLT, puis remplacez-le par JSON.
Pour un doodle / preuve de concept fonctionnel 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).
Avertissement: Ceci est mon propre code.
J'ai écrit un adaptateur de dom pour mon framework de traitement json basé sur jackson il y a longtemps. Il utilise la bibliothèque nu.xom. L’arborescence résultante fonctionne avec les installations 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 objet.
Utilisation:
JsonObject sampleJson = sampleJson ();
org.w3c.dom.Document domNode = JsonXmlConverter.getW3cDocument (sampleJson, "root");
Une approche qui n’a pas encore été donnée consiste à utiliser un générateur d’analyseur pour créer un analyseur syntaxique dans XSLT qui analyse JSON et génère une sortie XML.
Le générateur d’analyseur ReX ( http: // www) est une option souvent citée dans les conférences XML. .bottlecaps.de / rex / ) - bien que totalement non documentées sur le site, les recettes sont disponibles lors de la recherche.
Il est 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 saisir du JSON en entrée pour récupérer un ensemble de données correspondant, ainsi que du JSON ou du TEXT en sortie.
Accéder aux 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 / fr-fr / sql / relations-relationnelles / json / json-data-sql-server
Il serait bien que l’outil alternatif puisse gérer JSON et XML. https://docs.microsoft.com/ en-us / sql / relations-relationnelles / xml / openxml-sql-server
Je n’ai pas encore essayé de convertir les scripts XSLT que j’utilise en SQL, ni d’évaluer pleinement cette option, mais j’espère approfondir cette question plus rapidement. Quelques réflexions jusqu'à présent.
JSON-e a des implémentations dans Node.js, Python et Go.
