Équivalent XSLT pour JSON
23 réponses
idée intéressante. Quelques recherches sur Google ont produit quelques pages d'intérêt, y compris:
- un plan comment une telle "jsonT" outil pourrait être mis en œuvre, et certains téléchargements
- certains analyse de la mise en œuvre
- une entreprise qui peut avoir mis en œuvre quelque chose de convenable
Espérons que cette aide.
Essayer SECOUSSE . 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 impossible à maintenir.
XSLT équivalents de JSON - une liste de candidats (les outils et les specs)
outils
- XSLT
Vous pouvez utiliser XSLT pour JSON avec l'objectif de fn:json-à-xml .
cette section décrit les installations permettant le traitement des données JSON à L'aide de XSLT.
- jq dernier commit 12 mai 2018
jq est comme sed pour les données JSON - vous pouvez l'utiliser pour trancher et filtrer et cartographier et transformer des données structurées avec la même facilité que sed, awk, grep et les amis vous laissent jouer avec le texte. Il existe des paquets d'installation pour différents systèmes D'exploitation.
- jj dernière commission 2 mars, Deux mille dix huit
JJ est un utilitaire de ligne de commande qui fournit un moyen rapide et simple pour récupérer ou mettre à jour des valeurs à partir de documents JSON. C'est alimenté par GJSON et SJSON sous le capot.
- fx dernier commit 20 mars 2018
"151900920 de ligne de Commande" JSON outil de traitement
- N'ont pas besoin d'apprendre une nouvelle syntaxe
- JavaScript Simple
- formatage et mise en évidence
- standalone binaire
- jsawk dernier commit 4 mars 2015
Jsawk est comme awk, mais pour JSON. Vous travaillez avec un tableau d'objets JSON lus à partir de stdin, filtrez-les en utilisant JavaScript pour produire un tableau de résultats qui est imprimé à stdout.
- JSON dernier Commit Mars 3, 2017
json est un outil de CLI rapide pour travailler avec JSON. Il s'agit d'un nœud de fichier.js script sans Dep externe(autre que le noeud.js lui-même).
- jl dernier engagement 10 Avr. 2018
jl ("JSON lambda") est un petit langage fonctionnel pour interroger et manipuler JSON.
- yate dernier engagement 13 mars 2017
les essais peuvent être utilisés comme docu https://github.com/pasaran/yate/tree/master/tests
- json transforme le Dernier Commit le 1er Décembre 2017
fournit une approche récursive, modèle-appariement pour transformer les données JSON. Les Transformations sont définies comme un ensemble de règles qui correspondent à la structure d'un objet JSON. Lorsqu'une correspondance se produit, la règle émet les données transformées, se reproduisant optionnellement pour transformer des objets enfants.
- jsonpath-object-transform dernier Commit 18 janv. 2017
tire des données d'un objet littéral utilisant JSONPath et générer de nouveaux objets basés sur un modèle.
- JOLT dernier Commit mai 1, 2018
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.
-
gron Dernier Commit 5 Avr. 2018
rend JSON greppable! gron transforme JSON en assignations discrètes pour rendre plus facile le grep pour ce que vous voulez et voir le 'chemin' absolu vers lui. Il facilite l'exploration des API qui renvoient de grandes taches de JSON mais ont une documentation terrible.
-
Agrafage Dernier Commit 16 Sept. 2013
Stapling est une bibliothèque JavaScript qui permet le formatage XSLT pour les objets JSON. Au lieu d'utiliser un moteur d'établissement de modèles JavaScript et des modèles texte/html, L'agrafage vous donne la possibilité d'utiliser des modèles XSLT - chargés asynchrones avec Ajax, puis mis en cache côté client - pour analyser vos sources de données JSON.
-
json-e dernier Commit 22 mai 2018
JSON-e est un système de paramétrisation de structure de données pour intégrer le contexte dans les 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 de sortie.
Specs:
- JsonPointer
pointeur JSON définit une syntaxe de chaîne pour identifier une valeur spécifique dans un document JavaScript Object Notation (JSON).
- 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 pour JSON, C'est comme XPath pour XML."
- JSONiq
la principale source d'inspiration derrière JSONiq est XQuery, qui a été prouvé jusqu'à présent un langage d'interrogation réussi et productif pour les données semi-structurées
XSLT supporte JSON comme vu à http://www.w3.org/TR/xslt-30/#json
XML utilise des consoles angulaires pour délimiter les jetons, JSON utilise des accolades, des crochets,... C'est-à-dire: Moins de comparaisons de reconnaissance de jeton de XML signifie qu'il est optimisé pour la transformation déclarative, alors que plus de comparaisons, étant comme l'énoncé de commutation, pour des raisons de vitesse supposent la prédiction spéculative de branche que le code impératif dans les langages de script est utile pour. Direct par conséquent, pour différents mélanges de données semi-structurées, vous voudrez peut-être évaluer les performances des moteurs XSLT et javascript dans le cadre de pages responsive. Pour une charge utile de données négligeable, les transformations pourraient fonctionner aussi bien avec JSON sans sérialisation XML. La décision de W3 devrait être basée sur une meilleure analyse.
j'ai récemment trouvé un outil que j'aime 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 - léger et flexible de ligne de commande JSON processeur
ce n'est pas basé sur un modèle comme XSLT, mais plus concis. par exemple, pour extraire les champs name et address dans un tableau: [.name, .address]
le tutoriel parcourt un exemple de transformation de L'API JSON de Twitter (et le manuel a de nombreux exemples).
pour dire manque d'outils suggèrent manque de besoin est juste la question. La même chose pourrait s'appliquer à la prise en charge de X ou Y sous Linux (pourquoi se donner la peine de développer des drivers et/ou des jeux de qualité pour un OS aussi minoritaire? Et pourquoi faire attention à un OS que les grandes entreprises de jeux et de matériel ne développent pas?). Il est probable que les personnes qui auraient besoin d'utiliser XSLT et JSON finissent par utiliser une solution un peu triviale: transformer JSON en XML. Mais ce n'est pas la solution optimale, est-il?
quand vous avez un format JSON natif et que vous voulez l'éditer" wysywyg " dans le navigateur, XSLT serait une solution plus qu'adéquate pour le problème. Faire cela avec la programmation javascript traditionnelle peut devenir une douleur dans le cul.
en fait, j'ai mis en place une approche" à l'âge de pierre " de XSLT, en utilisant l'analyse par sous-chaîne pour interpréter certaines commandes de base pour javascript, comme appeler un modèle, traiter les enfants, etc. Certainement mettre en œuvre un moteur de transformation avec un objet JSON, il est beaucoup plus facile d'implémenter un analyseur XML complet pour analyser le XSLT. Le problème est que, pour utiliser des gabarits XML pour transformer un objet JSON, vous devez analyser le XML des gabarits.
pour transformer un objet JSON en XML (ou HTML, ou texte ou autre), vous devez réfléchir soigneusement à la syntaxe et aux caractères spéciaux que vous devez utiliser pour identifier les commandes de transformation. Sinon, vous finirez par devoir concevoir un analyseur pour vos propres besoins. création de modèles de langue. Après avoir parcouru ce chemin, je peux vous dire que c'est pas joli.
Mise à jour(12 novembre 2010): après quelques semaines de travail sur mon analyseur, j'ai pu l'optimiser. Les modèles sont analysés à l'avance et les commandes sont stockées sous forme d'objets JSON. Les règles de Transformation sont aussi des objets JSON, tandis que le code template est un mélange de HTML et une syntaxe homebrew similaire au Code shell. J'ai été capable de transformer un document JSON complexe en HTML pour faire Editeur de documents. Le code est d'environ 1K lignes pour l'éditeur (c'est pour un projet privé donc je ne peux pas le partager) et d'environ 990 lignes pour le code de transformation JSON (comprend des commandes d'itération, des comparaisons simples, l'appel de modèle, la sauvegarde de variables et l'évaluation). J'ai l'intention de le publier sous licence MIT. Envoyez-moi un mail si vous désirez vous impliquer.
il y en a maintenant! J'ai récemment créé une bibliothèque, JSON-transforme , exactement dans ce but:
https://github.com/ColinEberhardt/json-transforms
Il utilise une combinaison de JSPath , DSL calqué sur XPath, et récursive de la correspondance de motif approche, inspirée directement par XSLT.
Voici un exemple rapide. Compte tenu de l'JSON suivants objet:
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);
qui produit le suivant:
{
"Honda": [
{ "model": "Jazz", "year": 2010 },
{ "model": "Civic", "year": 2007 },
{ "model": "Accord", "year": 2011 }
]
}
cette transformation est composée de trois règles. La première correspond à n'importe quelle automobile qui est faite par Honda, émettant un objet avec une propriété Honda , puis correspondant récursivement. La deuxième règle consiste à apparier n'importe quel objet avec une propriété maker , en sortant des propriétés model et year . Le finale est la transformation d'identité qui correspond récursivement.
encore une nouvelle réponse à une vieille question, je suggérerais un regard sur DefiantJS . Ce n'est pas un XSLT équivalent pour JSON, il est XSLT pour JSON. La section" Templating "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'ai écrit ma propre petite bibliothèque autour de ce, récemment, qui tente de rester aussi proche de
5.1 Processing Model (XSLT REC) https://www.w3.org/TR/xslt#section-Processing-Model
comme c'est possible (comme je le Pourrais de toute façon), en quelques lignes de code JavaScript.
voici quelques exemples d'utilisation pas-complètement-insignifiants...
1. JSON-pour-certains-balisage:
violon: https://jsfiddle.net/YSharpLanguage/kj9pk8oz/10
(inspiré de D. 1 Document Example (XSLT REC) https://www.w3.org/TR/xslt#section-Document-Example )
où ceci:
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-to - JSON:
violon: https://jsfiddle.net/YSharpLanguage/ppfmmu15/10
où ceci:
// (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é sur des valeurs communes
(at: 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...
JSONiq Cas D'Utilisation De La Section 1.1.2. Regrouper les requêtes pour JSON
(at: 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 limites de JSONPath wrt. questionnement sur l'axe de l'ancêtre, comme soulevé par cette question SO (et certainement d'autres).
par exemple, comment obtenir la réduction d'un article d'épicerie connaître son nom 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:
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,
j'ai été vraiment fatigué de l'énorme quantité de moteurs JavaScript templating là-bas, et tous leurs HTML-gabarits en ligne, différents styles de balisage, etc., et a décidé de construire une petite bibliothèque qui permet le formatage XSLT pour les structures de données JSON. Ce n'est pas de la science-fusée d'aucune façon -- C'est juste JSON qui parle de XML et ensuite formaté avec un document XSLT. C'est rapide aussi, pas aussi vite que les moteurs de modèles JavaScript dans Chrome, mais dans la plupart des autres navigateurs, c'est à moins rapide que le moteur JS pour les structures de données plus grandes.
je suis à l'aide de Chameau route umarshal(xmljson) - > (xlst) -> maréchal(xmljson). Assez efficace (mais pas parfait à 100%), mais simple, si vous utilisez déjà Camel.
pas trop sûr qu'il y ait besoin pour cela, et à moi manque d'outils suggère manque de besoin. JSON est le mieux traité comme des objets (de la façon dont il est fait dans JS de toute façon), et vous utilisez généralement le langage des objets lui-même pour faire des transformations (Java pour les objets Java créés à partir de JSON, idem pour Perl, Python, Perl, c#, PHP et ainsi de suite). Juste avec des missions normales (ou set, get), en boucle et ainsi de suite.
je veux dire, XSLT est juste une autre langue, et une raison pour laquelle il est nécessaire est que XML n'est pas une notation d'objet et donc les objets des langages de programmation ne sont pas des Correspondances exactes (impédance entre le modèle XML hiérarchique et les objets/structures).
il est très possible de convertir JSON en utilisant XSLT: vous avez besoin de json2sax deserializer et sax2json serializer.
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, les caractéristiques JPath (un équivalent XPath naturel pour JS), compiles à JavaScript et a tout un historique d'utilisation de la production. C'est pratiquement sans papiers, mais la lecture des échantillons et des tests devrait suffire.
pourquoi ne convertissez-vous pas JSON en XML en utilisant Mr.data Coverter , tranformez-le en utilisant XSLT et puis changez-le en JSON en utilisant le même.
Pour un travail doodle/preuve de concept d'une approche à utiliser JavaScript avec le familier et le déclaratif motif derrière XSLT de correspondance des expressions et récursive de modèles, voir https://gist.github.com/brettz9/0e661b3093764f496e36
(une approche similaire pourrait être adoptée pour JSON.)
notez que la démo s'appuie également sur JavaScript 1.8 expression closures pour la commodité dans l'expression des modèles dans Firefox (au moins jusqu'à ce que la forme abrégée ES6 pour les méthodes puisse être mise en œuvre).
Avertissement: Ceci est mon propre code.
j'ai écrit un adaptateur dom pour mon framework de traitement JSON basé à jackson il y a longtemps. Il utilise le nu.bibliothèque xom. L'arbre dom résultant fonctionne avec les installations java xpath et xslt. J'ai fait certains choix d'implémentation qui sont assez simple. Par exemple, le noeud racine est toujours appelé "root", les tableaux vont dans un noeud ol avec des éléments li sub (comme en html), et tout le reste est juste un sous-noeud avec une valeur primitive ou un autre noeud objet.
Usage:
JsonObject sampleJson = sampleJson();
org.w3c.dom.Document domNode = JsonXmlConverter.getW3cDocument(sampleJson, "root");
une approche qui n'est pas encore donnée est d'utiliser un générateur d'analyseur pour créer un analyseur dans XSLT qui analyse JSON et produit une sortie XML.
une option qui est souvent mentionnée lors des conférences XML est le générateur ReX parser ( http://www.bottlecaps.de/rex / ) - bien que totalement non documentée sur le site, des recettes sont disponibles sur la recherche.
il peut être possible d'utiliser XSLT avec JSON. Verson 3 de XPath (3.1) XSLT(3.0) et XQuery(3.1) supporte JSON d'une certaine manière. 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 j'attendrais d'une solution alternative:
je voudrais pouvoir entrer JSON pour récupérer un ensemble de données de correspondance, et de sortie JSON ou de texte.
accéder aux propriétés arbitraires et évaluer les valeurs
le Soutien à la logique conditionnelle
je voudrais que les scripts de transformation soient externes de l'outil, basés sur le texte, et de préférence un langage couramment utilisé.
alternative potentielle?
I 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, ou pleinement évalué cette option encore, mais j'espère que à y regarder de plus bientôt. Juste quelques pensées à ce jour.