json - jolt documentation
XSLT equivalente para JSON (24)
¿Por qué no convierte JSON a XML utilizando Mr. Data Coverter , lo realiza mediante XSLT y luego lo cambia de nuevo a JSON utilizando el mismo?
¿Hay un equivalente XSLT para JSON? Algo que me permita hacer transformaciones en JSON como XSLT lo hace a XML.
Como otra nueva respuesta a una vieja pregunta, sugeriría un vistazo a DefiantJS . No es un equivalente XSLT para JSON, es XSLT para JSON. La sección "Plantillas" 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>
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 dolor en el culo.
De hecho, he implementado un enfoque de "edad de piedra" para XSLT, usando el análisis de subcadenas para interpretar algunos comandos básicos para javascript, como llamar una plantilla, procesar niños, etc. Ciertamente, implementar un motor de transformación con un objeto JSON es mucho más fácil que implementando 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 acerca de 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 caminado por ese camino, te puedo decir 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.
Echa un vistazo a jsonpath-object-transform
Equivalentes de XSLT para JSON: una lista de candidatos (herramientas y especificaciones)
Herramientas
- XSLT
Puede utilizar XSLT con el objetivo de fn:json-to-xml .
Esta sección describe las instalaciones que permiten procesar datos JSON utilizando XSLT.
- jq último cometer 12 de mayo de 2018
jq es como sed para datos JSON: puede usarlo para dividir, filtrar, mapear y transformar datos estructurados con la misma facilidad que sed, awk, grep y amigos le permiten jugar con texto. Hay paquetes de instalación para diferentes sistemas operativos.
- jj último cometer mar 2, 2018
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 alimentado por GJSON y SJSON bajo el capó.
- fx Última confirmación 20 de marzo de 2018
Herramienta de procesamiento JSON de línea de comandos
- No necesitas aprender nueva sintaxis.
- JavaScript simple
- Formato y resaltado
- Binario independiente
- jsawk ultimo cometer mar 4, 2015
Jsawk es como awk, pero para JSON. Trabaja con una matriz de objetos JSON leídos desde stdin, filtre con JavaScript para producir una matriz de resultados que se imprima en stdout.
- json Last Commit Mar 3, 2017
json es una herramienta CLI rápida para trabajar con JSON. Es un script de node.js de un solo archivo sin deps externos (aparte de node.js en sí).
- jl Last Commit 10 de abril de 2018
jl ("JSON lambda") es un pequeño lenguaje funcional para consultar y manipular JSON.
- yate Last Commit Mar 13, 2017
Las pruebas se pueden utilizar como docu https://github.com/pasaran/yate/tree/master/tests
- json-transforms Last Commit dic 1, 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.
- jsonpath-object-transform Last Commit Jan 18, 2017
Extrae datos de un objeto literal utilizando JSONPath y genera un nuevo objeto basado en una plantilla.
- JOLT Last Commit May 1, 2018
Biblioteca de transformación JSON a JSON escrita en Java donde la "especificación" para la transformación es en sí misma un documento JSON.
gron Last Commit 05 de abril de 2018
Hacer 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.
Stapling Último Cometer 16 de septiembre 2013
Grapado es una biblioteca de JavaScript que habilita el formateo 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.
json-e Last Commit 22 de mayo de 2018
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.
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.
Escribí mi propia pequeña biblioteca en torno a esto, recientemente, que trata de permanecer lo más cerca posible.
Modelo de procesamiento 5.1 (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: jsfiddle.net/YSharpLanguage/kj9pk8oz/10
(inspirado en el Ejemplo de documento D.1 (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: 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-examples
dónde...
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 ...
jsfiddle.net/YSharpLanguage/hvo24hmk/3 jsfiddle.net/YSharpLanguage/hvo24hmk/3
(en: jsfiddle.net/YSharpLanguage/hvo24hmk/3 )
Cf. http://jsoniq.org/docs/JSONiq-usecases/html-single/index.html#jsongrouping
dónde...
/*
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 otras).
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,
Escribí un adaptador dom para mi framework de procesamiento json basado en jackson hace mucho tiempo. 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"); JsonObject sampleJson = sampleJson(); org.w3c.dom.Document domNode = JsonXmlConverter.getW3cDocument(sampleJson, "root");
Estoy usando camel route umarshal (xmljson) -> to (xlst) -> marshal (xmljson). Suficientemente eficiente (aunque no es 100% perfecto), pero simple, si ya está usando Camel.
Hay ahora Recientemente creé una biblioteca, json-transforms , exactamente para este propósito:
Utiliza una combinación de JSPath , un DSL modelado en XPath, y un enfoque de coincidencia 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 haciendo coincidencias recursivas. La segunda regla hace coincidir cualquier objeto con una propiedad de maker , generando las propiedades del model y del year . La final es la transformación de identidad que coincide recursivamente.
He estado realmente cansado de la enorme cantidad de motores de plantillas de JavaScript que existen, y todas sus plantillas HTML en línea, diferentes estilos de marcado, etc., y decidí Stapling que permita el formato XSLT para las 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 de 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.
Idea interesante. Algunas búsquedas en Google produjeron algunas páginas de interés, incluyendo:
- un outline de cómo se podría implementar dicha herramienta "jsonT", y algunas descargas
- alguna discusión de esa implementación
- Una empresa que puede haber implementado algo adecuado.
Espero que esto ayude.
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 (la forma en que se hace en JS), y normalmente usas 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 y así sucesivamente.
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 objetos 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).
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 tomar 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 al expresar 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.
Prueba con JOLT . Es una biblioteca de transformación de JSON a JSON escrita en Java.
Fue creado específicamente porque no queríamos jugar el juego "JSON -> XML -> XSLT -> XML -> JSON", y no se puede utilizar una plantilla para cualquier transformación lo suficientemente compleja.
Puede ser posible utilizar 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/functions/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 coincidente y generar JSON o TEXTO.
Accede a propiedades arbitrarias y evalúa 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-databases/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-databases/xml/openxml-sql-server
Todavía no he intentado convertir los scripts XSLT que uso a SQL, ni he evaluado completamente esta opción todavía, pero espero verlos más pronto. Sólo algunos pensamientos hasta ahora.
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 ella que con XSLT, sin necesidad de consultas XPATH.
Un enfoque que aún no se ha dado es usar 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.
XSLT admite JSON como se ve en XSLT
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 imprescindible el código imperativo en 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.
Yate ( yate ) está diseñado específicamente después de XSLT, cuenta con JPath (un equivalente natural de XPath para JS), se compila en JavaScript y tiene un gran historial de uso de producción. Es prácticamente indocumentado, pero la lectura de muestras y pruebas debería ser suficiente.
es muy posible convertir JSON utilizando XSLT: necesita deserializador JSON2SAX y serializador SAX2JSON.
Código de muestra en Java: http://www.gerixsoft.com/blog/json/xslt4json
jq - procesador JSON ligero y flexible de línea de comandos
No está basado en plantillas como XSLT, pero es más conciso. por ejemplo, para extraer los campos de name y address en una matriz: [.name, .address]
El tutorial muestra un ejemplo de cómo transformar la API JSON de Twitter (y el manual tiene muchos ejemplos).
JSLT está muy cerca de un equivalente JSON de XSLT. Es un lenguaje de transformación en el que se escribe la parte fija de la salida en la sintaxis JSON y 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
}
Se implementa en Java encima de Jackson.
json-e tiene implementaciones en Node.js, Python y Go.