XSLT equivalente para JSON
https://stackoverflow.com/questions/1618038
-
06-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
¿Hay un XSLT equivalente para JSON? Algo que me permita hacer transformaciones en JSON como XSLT lo hace a XML.
Solución
Idea interesante. Algunas búsquedas en Google produjeron algunas páginas de interés, incluyendo:
- un esquema de cómo " jsonT " herramienta podría implementarse, y algunas descargas
- algunos discusión de esa implementación
- una compañía que puede haber implementado algo adecuado
Espero que esto ayude.
Otros consejos
Prueba JOLT . Es una biblioteca de transformación de JSON a JSON escrita en Java.
Se creó específicamente porque no queríamos reproducir " JSON - > XML - > XSLT - > XML - > JSON " juego, y el uso de una plantilla para cualquier transformación suficientemente compleja no se puede mantener.
Equivalentes XSLT para JSON: una lista de candidatos (herramientas y especificaciones)
Herramientas
- XSLT
Puede utilizar XSLT para JSON con el objetivo de fn: json-to-xml .
En esta sección se describen las instalaciones que permiten procesar los datos JSON utilizando XSLT.
- jq
jq es como sed para datos JSON: puede usarlo para dividir, filtrar y mapear y transformar datos estructurados con la misma facilidad que sed, awk, grep y sus amigos le permiten jugar con texto. Hay paquetes de instalación para diferentes sistemas operativos.
- jj
JJ es una utilidad de línea de comandos que proporciona una manera rápida y sencilla de recuperar o actualizar valores de documentos JSON. Es impulsado por GJSON y SJSON bajo el capó.
- fx
Herramienta de procesamiento JSON de línea de comandos
- No es necesario aprender una nueva sintaxis
- JavaScript sencillo
- Formato y resaltado
- binario independiente
- jl
jl (" JSON lambda ") es un pequeño lenguaje funcional para consultar y manipular JSON.
- JOLT
Biblioteca de transformación JSON a JSON escrita en Java donde la especificación " " para la transformación es en sí mismo un documento JSON.
- gron
Haz JSON greppable! gron transforma JSON en asignaciones discretas para que sea más fácil grep para lo que quieres y ver el "camino" absoluto hacia él. Facilita la exploración de API que devuelven grandes manchas de JSON pero tienen una documentación terrible.
- json
json es una herramienta CLI rápida para trabajar con JSON. Es un script de node.js de un solo archivo sin deps externos (que no sea el propio node.js).
- json-e
JSON-e es un sistema de parametrización de estructura de datos para incrustar contexto en objetos JSON. La idea central es tratar una estructura de datos como una " plantilla " y transformarla, utilizando otra estructura de datos como contexto, para producir una estructura de datos de salida.
- JSLT
JSLT es un lenguaje completo de consulta y transformación para JSON. El diseño del lenguaje está inspirado en jq, XPath y XQuery.
- json-transforms Último compromiso 1 de diciembre de 2017
Proporciona un enfoque recursivo y de coincidencia de patrones para transformar datos JSON. Las transformaciones se definen como un conjunto de reglas que coinciden con la estructura de un objeto JSON. Cuando se produce una coincidencia, la regla emite los datos transformados, que se repiten opcionalmente para transformar objetos secundarios.
- jsawk Último compromiso 4 de marzo de 2015
Jsawk es como awk, pero para JSON. Trabaja con una matriz de objetos JSON leídos desde stdin, los filtra con JavaScript para producir una matriz de resultados que se imprime en stdout.
- yate Última confirmación 13 de marzo de 2017
Las pruebas se pueden utilizar como docu https://github.com/pasaran/yate/ árbol / maestro / pruebas
- jsonpath-object-transform Último compromiso 18 de enero , 2017
Extrae datos de un objeto literal usando JSONPath y genera un nuevo objeto basado en una plantilla.
- Grapado Último compromiso 16 de septiembre de 2013
Grapado es una biblioteca de JavaScript que permite el formato XSLT para objetos JSON. En lugar de usar un motor de plantillas JavaScript y plantillas de texto / html, Stapling le da la oportunidad de usar plantillas XSLT, cargadas de forma asíncrona con Ajax y luego almacenadas en el lado del cliente, para analizar sus fuentes de datos JSON.
Especificaciones:
- JsonPointer
El puntero JSON define una sintaxis de cadena para identificar un valor específico dentro de un documento de notación de objetos de JavaScript (JSON).
- JsonPath
Las expresiones JSONPath siempre se refieren a una estructura JSON de la misma manera que las expresiones XPath se usan en combinación con un documento XML
- JSPath
JSPath para JSON es como XPath para XML. "
- JSONiq
La principal fuente de inspiración detrás de JSONiq es XQuery, que hasta ahora ha demostrado ser un lenguaje de consulta exitoso y productivo para datos semiestructurados
XSLT admite JSON como se ve en http://www.w3.org/TR / xslt-30 / # json
XML usa corchetes angulares para tokens delimitadores, JSON usa paréntesis, corchetes, ... I. e. Las menos comparaciones de reconocimiento de token de XML significan que está optimizado para la transformación declarativa, mientras que más comparaciones, al igual que la instrucción switch, por razones de velocidad, suponen una predicción de rama especulativa para la cual es de utilidad el código imperativo en los lenguajes de scripting. Como consecuencia directa, para diferentes mezclas de datos semiestructurados, es posible que desee comparar el rendimiento de los motores XSLT y javascript como parte de las páginas de respuesta. Para una carga útil de datos insignificante, las transformaciones podrían funcionar igual de bien con JSON sin serialización XML. La decisión de W3 debería basarse en un mejor análisis.
Recientemente encontré una herramienta que me encanta para estilizar JSON: https://github.com/twigkit/tempo . Una herramienta muy fácil de usar, en mi opinión, es mucho más fácil trabajar con XSLT, no es necesario realizar consultas XPATH.
jq - procesador JSON de línea de comando ligero y flexible
No está basado en plantillas como XSLT, pero es más conciso. p.ej. para extraer los campos name y address en una matriz: [.name, .address]
El tutorial muestra un ejemplo de cómo transformar la API JSON de Twitter (y la manual tiene muchos ejemplos).
Eche un vistazo a jsonpath-object-transform
Decir que la falta de herramientas sugiere que la falta de necesidad es solo una pregunta. Lo mismo podría aplicarse al soporte para X o Y en Linux (¿por qué molestarse en desarrollar controladores y / o juegos de calidad para un sistema operativo tan minoritario? ¿Y por qué prestar atención a un sistema operativo para el que no se desarrollan las grandes compañías de hardware y juegos?). Probablemente las personas que necesitarían usar XSLT y JSON terminan usando una solución un tanto trivial: Transformar JSON en XML. Pero esa no es la solución óptima, ¿verdad?
Cuando tiene un formato JSON nativo y desea editarlo " wysywyg " en el navegador, XSLT sería una solución más que adecuada para el problema. Hacer eso con la programación javascript tradicional puede convertirse en un problema para el culo.
De hecho, he implementado una " edad de piedra " enfoque de XSLT, utilizando el análisis de subcadenas para interpretar algunos comandos básicos de javascript, como llamar a una plantilla, procesar elementos secundarios, etc. Ciertamente, implementar un motor de transformación con un objeto JSON es mucho más fácil que implementar un analizador XML completo para analizar el XSLT. El problema es que, para usar plantillas XML para transformar un objeto JSON, es necesario analizar el XML de las plantillas.
Para transformar un objeto JSON con XML (o HTML, texto o lo que sea), debe pensar detenidamente sobre la sintaxis y qué caracteres especiales debe usar para identificar los comandos de transformación. De lo contrario, tendrá que diseñar un analizador para su propio lenguaje de plantillas personalizado. Habiendo recorrido ese camino, puedo decirte que no es bonito.
Actualización (12 de noviembre de 2010): después de un par de semanas trabajando en mi analizador, he podido optimizarlo. Las plantillas se analizan de antemano y los comandos se almacenan como objetos JSON. Las reglas de transformación también son objetos JSON, mientras que el código de la plantilla es una mezcla de HTML y una sintaxis homebrew similar al código de shell. He podido transformar un documento JSON complejo en HTML para hacer un editor de documentos. El código es alrededor de 1K líneas para el editor (es para un proyecto privado, así que no puedo compartirlo) y alrededor de 990 líneas para el código de transformación JSON (incluye comandos de iteración, comparaciones simples, llamadas de plantillas, guardado de variables y evaluación). Planeo lanzarlo bajo una licencia MIT. Envíame un correo si quieres involucrarte.
Escribí mi propia pequeña biblioteca alrededor de esta, recientemente, que trata de estar lo más cerca posible
5.1 Modelo de procesamiento (XSLT REC) https://www.w3.org/TR/xslt#section-Processing-Model
como sea posible (como podría de todos modos), en unas pocas líneas de código JavaScript.
Aquí hay algunos ejemplos de uso no completamente triviales ...
1. JSON-to-some-markup:
Fiddle: https://jsfiddle.net/YSharpLanguage/kj9pk8oz/10
(inspirado en D.1 Document Example (XSLT REC) https://www.w3.org/TR/xslt#section-Document-Example )
donde esto:
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));
... da:
<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>
y
2. JSON a JSON:
Fiddle: https://jsfiddle.net/YSharpLanguage/ppfmmu15/10
donde esto:
// (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));
... da:
{
"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 equivalente de JavaScript de ...
XSLT 3.0 REC Sección 14.4 Ejemplo: Agrupación de nodos basados ??en valores comunes
(en: http://jsfiddle.net/YSharpLanguage/8bqcd0ey/1 )
Cf. https://www.w3.org/TR/xslt-30/#grouping -Ejemplos
donde ...
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)
});
})
);
... da:
<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 equivalente de JavaScript de ...
Casos de uso de JSONiq Sección 1.1.2. Agrupación de consultas para JSON
(en: https://jsfiddle.net/YSharpLanguage/hvo24hmk/3 )
Cf. http://jsoniq.org/docs/JSONiq-usecases/html -single / index.html # jsongrouping
donde ...
/*
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()
... da:
[
{
"CA": [
{
"clothes": [
{
"socks": 510
}
]
},
{
"kitchen": [
{
"broiler": 20
},
{
"toaster": 150
}
]
}
]
},
{
"MA": [
{
"clothes": [
{
"shirt": 10
}
]
},
{
"kitchen": [
{
"blender": 250
},
{
"toaster": 50
}
]
}
]
}
]
También es útil para superar las limitaciones de JSONPath wrt. consultar contra el eje del antepasado, como lo plantea esta pregunta SO (y ciertamente otros).
Por ejemplo, cómo obtener el descuento de un artículo de supermercado al conocer su ID de marca, en
{
"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"
}
]
}
?
Una posible solución es:
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);
... lo que da:
Discount of #983: 20
'HTH,
Hay ahora! Recientemente creé una biblioteca, json-transforms , exactamente para este propósito:
https://github.com/ColinEberhardt/json-transforms
Utiliza una combinación de JSPath , un DSL modelado en XPath, y un enfoque de patrón de patrón recursivo, inspirado directamente por XSLT.
Aquí hay un ejemplo rápido. Dado el siguiente objeto JSON:
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 }
]
};
Aquí hay una transformación:
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);
Que da como resultado lo siguiente:
{
"Honda": [
{ "model": "Jazz", "year": 2010 },
{ "model": "Civic", "year": 2007 },
{ "model": "Accord", "year": 2011 }
]
}
Esta transformación se compone de tres reglas. El primero coincide con cualquier automóvil fabricado por Honda, emitiendo un objeto con una propiedad de Honda , y luego coincidiendo de forma recursiva. La segunda regla coincide con cualquier objeto con una propiedad de maker , lo que da como resultado las propiedades de model y year . La final es la transformación de identidad que coincide de manera recursiva.
Como otra nueva respuesta a una pregunta anterior, sugeriría echar un vistazo a DefiantJS . No es un equivalente de XSLT para JSON, is XSLT para JSON. El " Templating " La sección de la documentación incluye este ejemplo:
<!-- 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>
He estado realmente cansado de la enorme cantidad de motores de plantillas de JavaScript que existen, y de todas sus plantillas HTML en línea, diferentes estilos de marcado, etc., y decidí construye una pequeña biblioteca que habilita el formateo XSLT para estructuras de datos JSON. No es ciencia espacial de ninguna manera, es solo JSON analizado a XML y luego formateado con un documento XSLT. También es rápido, no tan rápido como los motores de plantillas JavaScript en Chrome, pero en la mayoría de los otros navegadores es al menos tan rápido como la alternativa del motor JS para estructuras de datos más grandes.
Estoy usando camel route umarshal (xmljson) - > a (xlst) - > mariscal (xmljson). Suficientemente eficiente (aunque no es 100% perfecto), pero simple, si ya está usando Camel.
es muy posible convertir JSON utilizando XSLT: necesita el deserializador JSON2SAX y el serializador SAX2JSON.
Código de muestra en Java: http://www.gerixsoft.com/blog/json/xslt4json
Yate ( https://github.com/pasaran/yate ) está diseñado específicamente después del XSLT , características JPath (un & nbsp; equivalente natural de XPath para JS), se compila a JavaScript y tiene un buen historial de uso de producción. Está prácticamente sin documentar, pero la lectura de muestras y pruebas debería ser suficiente.
JSLT está muy cerca de un equivalente de JSON de XSLT. Es un lenguaje de transformación en el que se escribe la parte fija de la salida en la sintaxis JSON, luego se insertan expresiones para calcular los valores que desea insertar en la plantilla.
Un ejemplo:
{
"time": round(parse-time(.published, "yyyy-MM-dd'T'HH:mm:ssX") * 1000),
"device_manufacturer": .device.manufacturer,
"device_model": .device.model,
"language": .device.acceptLanguage
}
Está implementado en Java sobre Jackson.
No estoy muy seguro de que haya necesidad de esto, y para mí la falta de herramientas sugiere falta de necesidad. JSON se procesa mejor como objetos (como se hace en JS), y normalmente se usa el lenguaje de los objetos para hacer transformaciones (Java para objetos Java creados a partir de JSON, igual para Perl, Python, Perl, c #, PHP y así en). Solo con las asignaciones normales (o establecer, obtener), hacer bucles, etc.
Quiero decir, XSLT es solo otro lenguaje, y una razón por la que se necesita es que XML no es una notación de objeto y, por lo tanto, los objetos de lenguajes de programación no son ajustes exactos (impedancia entre el modelo XML jerárquico y los objetos / estructuras).
¿Por qué no convierte JSON a XML utilizando Sr. Data Coverter , realice la transformación utilizando XSLT y luego vuelva a cambiarlo a JSON utilizando la misma.
Para un garabato en funcionamiento / prueba de concepto de un enfoque para utilizar JavaScript puro junto con el patrón familiar y declarativo detrás de las expresiones coincidentes de XSLT y las plantillas recursivas, consulte https://gist.github.com/brettz9/0e661b3093764f496e36
(Se podría adoptar un enfoque similar para JSON)
Tenga en cuenta que la demostración también se basa en los cierres de expresión de JavaScript 1.8 por conveniencia en la expresión de plantillas en Firefox (al menos hasta que se pueda implementar la forma corta de ES6 para los métodos).
Descargo de responsabilidad: este es mi propio código.
Hace mucho tiempo escribí un adaptador dom para mi framework de procesamiento json basado en jackson. Utiliza la biblioteca nu.xom. El árbol de dominios resultante funciona con java xpath y xslt. Tomé algunas decisiones de implementación que son bastante sencillas. Por ejemplo, el nodo raíz siempre se llama "raíz", las matrices entran en un nodo ol con subelementos li (como en html), y todo lo demás es solo un nodo secundario con un valor primitivo u otro nodo objeto.
Uso:
JsonObject sampleJson = sampleJson ();
org.w3c.dom.Document domNode = JsonXmlConverter.getW3cDocument (sampleJson, " root ");
Un enfoque que aún no se ha dado es utilizar un generador de analizador para crear un analizador en XSLT que analice JSON y produzca una salida XML.
Una opción que se menciona mucho en las conferencias XML es el generador de analizador ReX ( http: // www .bottlecaps.de / rex / ) - aunque sin documentar en el sitio, las recetas están disponibles en la búsqueda.
Puede ser posible usar XSLT con JSON. Verson 3 de XPath (3.1) XSLT (3.0) y XQuery (3.1) admiten JSON de alguna manera. Esto parece estar disponible en la versión comercial de Saxon, y en algún momento podría incluirse en la versión HE. https://www.saxonica.com/html/documentation/ Funciones / fn / parse-json.html
-
Lo que esperaría de una solución alternativa:
Me gustaría poder ingresar JSON para obtener un conjunto de datos coincidentes, y generar JSON o TEXTO.
Acceda a propiedades arbitrarias y evalúe los valores
Soporte para lógica condicional
Me gustaría que las secuencias de comandos de transformación sean externas a la herramienta, basadas en texto y, preferiblemente, un lenguaje de uso común.
¿Alternativa potencial?
Me pregunto si SQL podría ser una alternativa adecuada. https://docs.microsoft. com / en-us / sql / relational-database / json / json-data-sql-server
Sería bueno si la herramienta alternativa pudiera manejar JSON y XML https://docs.microsoft.com/ en-us / sql / relational-database / xml / openxml-sql-server
Todavía no he intentado convertir los scripts XSLT que uso a SQL, o aún no he evaluado completamente esta opción, pero espero verlos más pronto. Solo algunos pensamientos hasta ahora.
JSON-e tiene implementaciones en Node.js, Python y Go.
