Equivalente XSLT para JSON
Existe umXSLT equivalente para JSON? Algo que me permita fazer transformações em JSON como o XSLT faz em XML.
23 answers
- An outline of how such a "jsonT" tool might be implemented, and some downloads
- alguma discussão sobre essa implementação
- uma empresa que pode ter implementado algo adequado
Tenta JOLT . É uma biblioteca JSON para JSON transformation escrita em Java.
Foi criado especificamente porque não queríamos jogar o jogo "JSON - > XML - > XSLT - > XML - > JSON", e usar um modelo para qualquer transformação suficientemente complexa não é possível.
Equivalentes XSLT para JSON-uma lista de candidatos (ferramentas e especificações)
Ferramentas
-
XSLT
Pode usar XSLT para JSON com o objectivo de fn: json-to-xml .
Esta secção descreve as instalações que permitem que os dados JSON sejam processados usando XSLT.
-
jq Última autorização de 12 de Maio de 2018
O Jq é como o sed para os dados do JSON - pode usá-lo para cortar e filtrar e mapear e transforme dados estruturados com a mesma facilidade que sed, awk, grep e amigos permitem que você jogue com texto. Existem pacotes de instalação para diferentes so.
-
jj último commit Mar 2, 2018
O JJ é um utilitário de linha de comandos que oferece uma forma rápida e simples de obter ou actualizar os valores dos documentos JSON. É alimentado por GJSON e SJSON sob o capô.
-
fx último commit Mar 20, 2018
Ferramenta de processamento de linha de comandos JSON
- não é preciso aprender uma nova sintaxe
- JavaScript Simples
- formatação e realce
- binário autónomo
-
jsawk último compromisso 4 de Março de 2015
O Jsawk é como o awk, mas para o JSON. Você trabalha com um array de objetos JSON lidos a partir de stdin, filtrá-los usando JavaScript para produzir um array de resultados que é impresso para stdout.
-
json último compromisso 3 de Março de 2017
O Json é uma ferramenta de CLI rápida para trabalhar com o JSON. É um nó de arquivo único.script js sem deps externos (exceto nodo.js itself).
-
jl Última persistência 10 de Abril de 2018
JL ("JSON lambda") é uma linguagem funcional para questionar e manipular JSON.
-
yate último compromisso 13 de Março de 2017
Os testes podem ser usados como docu https://github.com/pasaran/yate/tree/master/tests
-
json-transformadas Última Commit 1 de Dezembro de 2017
Fornece uma abordagem recursiva de correspondência de padrões para transformar dados JSON. Transformações são definidas como um conjunto de regras que correspondem à estrutura de um objeto JSON. Quando ocorre uma correspondência, a regra emite os dados transformados, recursando opcionalmente para transformar o filho objecto.
-
JSONPath-object-transform Última Missão 18 de Janeiro de 2017
Puxa dados de um literal de objeto usando JSONPath e gera um novo objeto baseado em um modelo.
-
JOLT Última persistência em 1 de Maio de 2018
JSON to JSON transformation library written in Java where the "specification" for the transform is itself a JSON document.
-
Gron Último Commit Apr 5, 2018
Torna o JSON gregpable! gron transforma JSON em atribuições discretas para tornar mais fácil grep para o que você quer e ver o "caminho" absoluto para ele. Facilita a exploração de APIs que devolvem grandes bolhas de JSON, mas têm uma documentação terrível.
-
Agrafamento Última Persistência 16 De Setembro De 2013
Stapling é uma biblioteca de JavaScript que activa a formatação do XSLT para objectos JSON. Em vez de usar um O motor de templação de JavaScript e os modelos de texto/html, O Stapling dá - lhe a oportunidade de usar os modelos XSLT - carregados assíncronamente com o Ajax e, em seguida, com o cliente cache-para analisar os seus recursos de dados JSON.
-
Json-e Última autorização de 22 de Maio de 2018
JSON-e é um sistema de parametrização de estrutura de dados para incorporar o contexto em objetos JSON. A ideia central é tratar uma estrutura de dados como um "modelo" e transformá - la, usando outro estrutura de dados como contexto, para produzir uma estrutura de dados de saída.
Especificações:
-
JsonPointer
O ponteiro JSON define uma sintaxe de texto para identificar um valor específico dentro de um documento de notação de objeto JavaScript (JSON).
-
JsonPath
As expressões JSONPath referem-se sempre a uma estrutura JSON da mesma forma que a expressão XPath é usada em combinação com um XML Documento
-
JSPath
O JSPath para o JSON é como o XPath para o XML."
-
JSONiq
A principal fonte de inspiração por trás do JSONiq é o XQuery, que tem sido provado até agora uma linguagem de consulta bem sucedida e produtiva para dados semi-estruturados
O XSLT suporta o JSON tal como visto em http://www.w3.org/TR/xslt-30/#json
O XML usa parêntesis angulares para os símbolos delimitadores, o JSON usa Chavetas, parêntesis rectos ... I. E., As comparações de reconhecimento de token menos XML significa que ele é otimizado para transformação declarativa, enquanto que mais comparações, sendo como a declaração switch, por razões de velocidade assumir a previsão especulativa de ramo que o código imperativo em linguagens de script é útil para. Como consequência directa, para diferentes misturas de dados semi-estruturados, você pode querer comparar o desempenho dos motores XSLT e javascript como parte das páginas responsivas. Para uma carga de dados negligenciável, transformações podem funcionar bem com JSON sem serialização XML. A decisão do W3 deve basear-se numa melhor análise.
Processador JQ-leve e flexível de linha de comando JSON
Não é baseado em modelos como o XSLT, mas mais conciso. por exemplo, extrair os camposname
e address
para uma matriz: [.name, .address]
O tutorial passa por um exemplo de transformação da API JSON do Twitter (e o manual tem muitos exemplos).
Olha para JSONPath-object-transform
Quando ter um formato JSON nativo e você quer editá-lo "wysywyg" no navegador, XSLT seria uma solução mais do que adequada para o problema. Fazer isso com programação javascript tradicional pode se tornar um chato.
De facto, implementei uma abordagem "idade da pedra" ao XSLT, usando o processamento em substring para interpretar alguns comandos básicos do javascript, como chamar um modelo, processar crianças, etc. Certamente implementar um motor de transformação com um objeto JSON é muito mais fácil do que implementando um processador XML completo para processar o XSLT. O problema é que para usar modelos XML para transformar um objeto JSON você precisa processar o XML dos modelos.
Para transformar um objecto JSON em XML (ou HTML, ou texto ou o que quer que seja), é necessário pensar cuidadosamente sobre a sintaxe e quais os caracteres especiais que precisa de usar para identificar os comandos de transformação. Caso contrário, você vai acabar tendo que projetar um analisador para a sua própria linguagem de template personalizado. Tendo percorrido esse caminho, Posso dizer-te que não é bonito.
Actualização (12 de Novembro de 2010): depois de algumas semanas a trabalhar no meu analisador, consegui optimizá-lo. Os modelos são processados de antemão e os comandos são armazenados como objetos JSON. As regras de transformação também são objetos JSON, enquanto o código modelo é uma mistura de HTML e uma sintaxe homebrew semelhante ao código shell. Consegui transformar um complexo documento JSON em HTML para fazer um editor de documentos. O código é em torno de linhas 1K para o editor (é para um projeto privado para que eu não possa compartilhá-lo) e em torno de 990 linhas para o código de transformação JSON (inclui comandos de iteração, comparações simples, chamada de template, poupança variável e avaliação). Planeio libertá-lo sob licença do MIT. Deixa-me um e-mail se quiseres envolver-te.
Https://github.com/ColinEberhardt/json-transforms
Ele usa uma combinação de JSPath , um DSL modelado em XPath, e uma abordagem recursiva de correspondência de padrões, inspirada directamente pelo XSLT.
Eis um exemplo rápido. Dado o seguinte objecto 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 }
]
};
Aqui está uma transformação.
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 produz o seguinte:
{
"Honda": [
{ "model": "Jazz", "year": 2010 },
{ "model": "Civic", "year": 2007 },
{ "model": "Accord", "year": 2011 }
]
}
Esta transformação é composta por três regras. O primeiro corresponde a qualquer automóvel que é feito pela Honda, emitindo um objeto com uma propriedade Honda
, em seguida, correspondência recursivamente. A segunda regra corresponde a qualquer objecto com uma propriedade maker
, expondo as propriedades model
e year
. A final é a transformação de identidade que se encaixa recursivamente.
Como mais uma nova resposta a uma pergunta antiga, sugiro que olhem para DefiantJS. Não é um XSLT equivalente para o JSON, é é XSLT para o JSON. A secção" template " da documentação inclui este exemplo:
<!-- 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>
5.1 modelo de processamento (XSLT REC) https://www.w3.org/TR/xslt#section-Processing-Model
O mais possível (como eu poderia de qualquer maneira), em algumas linhas de código JavaScript.
[[12]} Aqui estão alguns exemplos não-completamente-triviais de uso...1. JSON-to-some-markup:
Fiddle: https://jsfiddle.net/YSharpLanguage/kj9pk8oz/10
(inspirado em D. 1 Exemplo de Documento (XSLT REC) https://www.w3.org/TR/xslt#section-Document-Example)
Onde isto:
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));
... dá:
<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>
E
2. JSON-to-JSON:
Violino: https://jsfiddle.net/YSharpLanguage/ppfmmu15/10
Onde isto:
// (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));
... dá:
{
"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:
Um equivalente JavaScript de...
Exemplo: Agrupamento de nós com base em valores comuns
(at: http://jsfiddle.net/YSharpLanguage/8bqcd0ey/1)
Cf. https://www.w3.org/TR/xslt-30/#grouping-examples
Onde?..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)
});
})
);
... dá:
<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:
Um equivalente JavaScript de...
Secção Dos Casos De Utilização JSONiq 1.1.2. Agrupar as consultas para o JSON
(at: https://jsfiddle.net/YSharpLanguage/hvo24hmk/3)
Cf. http://jsoniq.org/docs/JSONiq-usecases/html-single/index.html#jsongrouping
Onde?../*
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()
... dá:
[
{
"CA": [
{
"clothes": [
{
"socks": 510
}
]
},
{
"kitchen": [
{
"broiler": 20
},
{
"toaster": 150
}
]
}
]
},
{
"MA": [
{
"clothes": [
{
"shirt": 10
}
]
},
{
"kitchen": [
{
"blender": 250
},
{
"toaster": 50
}
]
}
]
}
]
Também é útil ultrapassar as limitações do JSONPath wrt. questionando-se contra o eixo ancestral, tal como referido por esta questão (e certamente outros).
Por exemplo, como obter o desconto de um item de mercearia que conhece a sua marca, em{
"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"
}
]
}
?
Uma solução possível é:
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);
... o que dá:
Discount of #983: 20
'HTH,
Tenho estado muito cansado da enorme quantidade de motores de templação JavaScript lá fora, e de todos os seus modelos HTML incorporados, estilos de marcação diferentes, etc., e decidiu construir uma pequena biblioteca que permite a formatação XSLT para estruturas de dados JSON. Não é ciência de foguetes de qualquer forma -- é apenas JSON pared para XML e formatado com um documento XSLT. É rápido demais, não tão rápido quanto os motores de modelo JavaScript no Chrome, mas na maioria dos outros navegadores é pelo menos tão rápido quanto a alternativa do motor JS para maiores estruturas de dados.
Estou a utilizar a via Camelo umarshal (xmljson) -> a(xlst) - > marshal (xmljson). Eficiente o suficiente (embora não 100% perfeito), mas simples, se você já está usando Camelo.
Não tenho a certeza se há necessidade disto, e para mim a falta de ferramentas sugere falta de necessidade. JSON é mais bem processado como objetos (a forma como é feito em JS de qualquer maneira), e você normalmente usa a linguagem dos objetos em si para fazer transformações (Java para objetos Java criados a partir de JSON, o mesmo para Perl, Python, Perl, C#, PHP e assim por diante). Apenas com tarefas normais (ou set, get), looping e assim por diante.
Quero dizer, XSLT é apenas outra linguagem, e uma razão pela qual é necessário é que o XML não é um notação de objeto e, portanto, objetos de linguagens de programação não são fits exatos (impedância entre modelo xml hierarquizado e objetos/estruturas).
É muito possível converter o JSON usando o XSLT: você precisa do deserializador JSON2SAX e do serializador de SAX2JSON.
Código Da Amostra em Java: http://www.gerixsoft.com/blog/json/xslt4json
Yate ( https://github.com/pasaran/yate ) é especificamente projetado após XSLT, apresenta JPath (um equivalente XPath natural para JS), compila para JavaScript e tem um histórico de uso de produção. É praticamente indocumentado, mas ler amostras e testes deve ser suficiente.
Porque não converte o JSON em XML usando o Sr. Data Coverter , transforma-o com o XSLT e depois muda-o de volta para o JSON usando o mesmo.
Para um doodle de trabalho/prova do conceito de uma abordagem para utilizar JavaScript puro, juntamente com o padrão familiar e declarativo por trás das expressões correspondentes do XSLT e dos modelos recursivos, veja https://gist.github.com/brettz9/0e661b3093764f496e36
(pode adoptar-se uma abordagem semelhante para o JSON.)
Note que a demonstração também depende do JavaScript 1.8 expression classs for convenience in expressing templates in Firefox (at least until the ES6 short form form for podem ser aplicados métodos).
Este é o meu próprio código.Utilização:
JsonObject sampleJson = sampleJson();
org.w3c.dom.Document domNode = JsonXmlConverter.getW3cDocument(sampleJson, "root");
Uma abordagem ainda não dada é usar um gerador de analisador para criar um analisador em XSLT que analisa JSON e produz uma saída XML.
Uma opção que é muito mencionada nas conferências XML é o gerador ReX parser ([4]} http://www.bottlecaps.de/rex/ - embora totalmente não documentada no site, as receitas estão disponíveis na pesquisa.Pode ser possível utilizar XSLT com JSON. Verson 3 of XPath(3.1) XSLT(3.0) and XQuery(3.1) supports JSON in some way. Isto parece estar disponível na versão comercial do Saxon, e pode em algum momento ser incluído na versão HE. https://www.saxonica.com/html/documentation/functions/fn/parse-json.html
-
O Que eu esperaria de uma solução alternativa:
Eu gostaria de poder introduzir o JSON para obter um conjunto de dados correspondente, e saída JSON ou texto.
Acesse propriedades arbitrárias e avalie os valores
Apoio à lógica condicional
Eu gostaria que os scripts de transformação fossem externos da ferramenta, baseados em texto, e de preferência uma linguagem comum.
Alternativa potencial?
Pergunto-me se o SQL poderia ser uma alternativa adequada. https://docs.microsoft.com/en-us/sql/relational-databases/json/json-data-sql-server
Seria bom se o ferramenta alternativa poderia lidar com JSON e XML https://docs.microsoft.com/en-us/sql/relational-databases/xml/openxml-sql-server
Ainda não tentei converter os scripts XSLT que uso para SQL, ou ainda avaliei completamente esta opção, mas espero vê-la mais em breve. Só alguns pensamentos até agora.