XSLT equivalente para JSON
https://stackoverflow.com/questions/1618038
-
06-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Existe um XSLT equivalente para JSON? Algo que me permita fazer transformações em JSON como XSLT faz para XML.
Solução
Idéia interessante. Algumas buscas no Google produziu algumas páginas de interesse, incluindo:
- esboço de como essa ferramenta "jsonT" pode ser implementada, e alguns downloads
- discussão de que a implementação
- uma empresa que pode ter implementado algo adequado
Espero que isso ajude.
Outras dicas
Tente JOLT . É uma biblioteca de transformação JSON para JSON escrito em Java.
Foi criado especificamente porque não querem jogar o "JSON -> XML -> XSLT -> XML -> JSON". Jogo, e usando um modelo para transformar qualquer suficientemente complexo é insustentável
equivalentes XSLT para JSON - uma lista de candidatos (ferramentas e especificações)
Ferramentas
- XSLT
Você pode usar XSLT para JSON com o objectivo de fn: json-to-xml .
Esta seção descreve instalações necessárias dados JSON para ser processado usando XSLT.
- jq
jq é como sed para dados JSON - você pode usá-lo para cortar e filtro e mapa e transformar dados estruturados com a mesma facilidade que sed, awk, grep e amigos deixá-lo jogar com o texto. Há pacotes de instalação para sistema operacional diferente.
- jj
JJ é um utilitário de linha de comando que fornece uma maneira rápida e simples para recuperar ou atualizar valores de documentos JSON. É alimentado por GJSON e SJSON sob o capô.
- fx
ferramenta de processamento de JSON de linha de comando
- não precisa de aprender uma nova sintaxe
- Plain JavaScript
- A formatação e destacando
- Standalone binário
- jl
jl ( "JSON lambda") é uma linguagem funcional pequeno para consultar e manipular JSON.
- JOLT
JSON a biblioteca de transformação JSON escrito em Java, onde a "especificação" para a transformação é em si um documento JSON.
- Gron
Faça JSON greppable! Gron transforma JSON em tarefas distintas para torná-lo mais fácil de grep para o que você quer e ver o 'caminho' absoluta a ele. Ele facilita a exploração de APIs que retornam grandes bolhas de JSON, mas têm documentação terrível.
- json
json é uma ferramenta rápida CLI para trabalhar com JSON. É roteiro um único arquivo node.js sem deps externos (exceto node.js si).
- json-e
JSON-e é um sistema de parametrização-estrutura de dados para a incorporação de contexto em objetos JSON. A idéia central é tratar uma estrutura de dados como um "modelo" e transformá-lo, utilizando outra estrutura de dados como contexto, para produzir uma estrutura de dados de saída.
- JSLT
JSLT é uma linguagem de consulta e transformação completa para JSON. O projeto de linguagem é inspirada por jq, XPath e XQuery.
- json-transformadas Última Commit 1 de dezembro de 2017
Fornece uma recursiva, a abordagem de correspondência de padrões para transformar dados JSON. Transformações são definidos como um conjunto de regras que correspondem a estrutura de um objeto JSON. Quando ocorre uma correspondência, a regra emite os dados transformados, opcionalmente recursivo para transformar objetos filho.
- jsawk Última cometer 4 de março de 2015
Jsawk é como awk, mas para JSON. Vocêstrabalho com uma variedade de objetos JSON ler de stdin, filtrá-los usando JavaScript para produzir uma matriz resultados que é impresso na saída padrão.
- yate Última Commit 13 de marco, 2017
Os testes podem ser utilizados como docu https://github.com/pasaran/yate/ árvore / master / testes
- jsonpath-objeto-transformar Última Commit 18 de janeiro de 2017
dados puxa de um objeto literal usando JSONPath e gerar uma nova objetos com base em um modelo.
- Grampeamento Última Commit 16 de setembro de 2013
Grampeamento é uma biblioteca JavaScript que permite XSLT formatação para objetos JSON. Em vez de usar um motor de templates JavaScript e text / html templates, Grampeamento dá-lhe a oportunidade de modelos XSLT uso - carregado de forma assíncrona com o Ajax e depois armazenado em cache do lado do cliente - para analisar as fontes de dados JSON.
especificações:
- JsonPointer
JSON Pointer define uma sintaxe de string para identificar um valor específico dentro de um JavaScript Object Notation (JSON) documento.
- JsonPath
expressões JSONPath sempre se referem a uma estrutura JSON da mesma forma como a expressão XPath são usados ??em combinação com um documento XML
- JSPath
JSPath para JSON é como XPath para XML. "
- JSONiq
A principal fonte de inspiração por trás JSONiq é XQuery, que foi provado até agora uma linguagem de consulta bem sucedida e produtiva para dados semi-estruturados
XSLT suporta JSON como visto em http://www.w3.org/TR / XSLT-30 / # json
XML usa colchetes angulares para tokens delimitador, JSON usa chaves, colchetes, ... I. e. menos meios comparações sinal de reconhecimento do XML é otimizado para a transformação declarativa, enquanto que mais comparações, sendo como switch, por razões de velocidade assumir previsão de desvios especulativa que código imperativo em linguagens de script é útil para. Como consequência direta, para diferentes combinações de dados semi-estruturados, você pode querer XSLT referência e desempenho dos motores de JavaScript como parte de páginas de resposta. Para carga de dados insignificante, transformações pode funcionar tão bem com JSON sem serialização XML. A decisão da W3 deve ser baseada na análise melhor.
Eu encontrei recentemente uma ferramenta que eu amo para denominar JSON: https://github.com/twigkit/tempo . Muito fácil ferramenta para uso - na minha opinião, é muito mais fácil do que trabalhar com XSLT -. Não há necessidade de consultas XPATH
jq - de linha de comando do processador JSON leve e flexível
Não é modelo baseado em como XSLT, mas mais concisa. por exemplo. Para extrair name e address campos em uma matriz: [.name, .address]
O tutorial anda através de um exemplo de transformar JSON API do Twitter (e o manual do tem muitos exemplos).
Tenha um olhar em jsonpath-objeto-transformar
Para dizer falta de ferramentas sugerem falta de necessidade é apenas implorando a pergunta. O mesmo poderia ser aplicado ao suporte para X ou Y no Linux (Por que se preocupar drivers e / ou jogos de qualidade em desenvolvimento para tal OS minoria? E por que pagar a atenção para um sistema operacional que jogo e hardware grandes empresas não desenvolvem para?). Provavelmente as pessoas que precisam usar XSLT e JSON acabar usando uma solução um tanto trivial: Transformando JSON em XML. Mas isso não é a solução ideal, não é?
Quando você tem um formato JSON nativa e você quiser editá-lo "WYSYWYG" no navegador, XSLT seria uma mais de solução adequada para o problema. Fazer isso com programação javascript tradicional pode se tornar uma dor na bunda.
Na verdade, eu implementei uma "idade da pedra" abordagem para XSLT, usando substring análise para interpretar alguns comandos básicos para javascript, como chamar um modelo, crianças de processo, etc. Certamente, a implementação de um mecanismo de transformação com um objeto JSON é muito mais fácil de implementar um parser XML de pleno direito para analisar o XSLT. O problema é, que para modelos de uso de XML para transformar um objeto JSON que você precisa para analisar XML dos modelos.
Para tranform um objeto JSON com XML (ou HTML ou texto ou qualquer outro), você precisa pensar cuidadosamente sobre a sintaxe e quais caracteres especiais que você precisa 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 templates personalizado. Ter andado por esse caminho, eu posso dizer-lhe que não é bonito.
Atualização (Nov 12, 2010): Depois de algumas semanas de trabalho no meu analisador, eu fui capaz de otimizá-lo. Os modelos são analisados ??previamente e os comandos são armazenados como objetos JSON. regras de transformação também são objetos JSON, enquanto o código do modelo é uma mistura de HTML e uma sintaxe homebrew semelhante a desembolsar código. Eu tenho sido capaz de transformar um documento JSON complexa em HTML para fazer um editor de documentos. O código é de cerca de 1K linhas para o editor (que é para um projeto privado, então não posso compartilhá-lo) e cerca de 990 linhas para o código de transformação JSON (inclui iteração comandos, comparações simples, modelo de chamada, de poupança variável e avaliação). I planejar para liberá-lo sob uma licença MIT. Deixe-me cair um email se você quer se envolver.
Eu escrevi minha própria pequena biblioteca de contornar isso, recentemente, que tenta ficar o mais próximo
5.1 Processamento de Modelo (XSLT REC) https://www.w3.org/TR/xslt#section-Processing-Model
como é possível (como eu poderia de qualquer maneira), em poucas linhas de código JavaScript.
Aqui estão alguns exemplos não-completamente-triviais de uso ...
1. JSON-to-some-marcação:
Fiddle: https://jsfiddle.net/YSharpLanguage/kj9pk8oz/10
(inspirado D.1 Exemplo Documento XSLT (REC) https://www.w3.org/TR/xslt#section-Document-Example )
onde esta:
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:
Fiddle: https://jsfiddle.net/YSharpLanguage/ppfmmu15/10
onde esta:
// (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:
A JavaScript equivalente a ...
XSLT 3,0 REC Seção 14.4 Exemplo: Agrupamento de nós com base em valores comuns
(em: http://jsfiddle.net/YSharpLanguage/8bqcd0ey/1 )
Cf. https://www.w3.org/TR/xslt-30/#grouping -exemplos
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:
A JavaScript equivalente a ...
JSONiq Casos de Uso ponto 1.1.2. Agrupando as consultas para JSON
(em: 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 para superar as limitações de JSONPath wrt. consultando contra o eixo antepassado, como levantado por esta questão SO (e certamente outros).
por exemplo., Como obter o desconto de um item de mercearia saber seu ID de 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,
Existe agora! Recentemente, criou uma biblioteca, JSON-transformadas , exatamente para esta finalidade:
https://github.com/ColinEberhardt/json-transforms
Ele usa uma combinação de JSPath , um DSL modelado em XPath, e uma abordagem correspondência recursiva padrão, inspirado diretamente pelo XSLT.
Aqui está um exemplo rápido. Dado o seguinte 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 }
]
};
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 saída o seguinte:
{
"Honda": [
{ "model": "Jazz", "year": 2010 },
{ "model": "Civic", "year": 2007 },
{ "model": "Accord", "year": 2011 }
]
}
Esta transformação é composto de três regras. O primeiro corresponde a qualquer automóvel, que é feita pela Honda, emitindo um objecto com uma propriedade Honda, em seguida, de forma recursiva correspondentes. A segunda regra corresponde a qualquer objeto com uma propriedade maker, saída as propriedades model e year. A final é a identidade transformar que corresponda de forma recursiva.
Como mais uma nova resposta para uma velha questão, sugiro uma olhada DefiantJS . Não é uma XSLT equivalente para JSON, ele é XSLT para JSON. A seção "Templating" 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>
Eu tenho sido muito cansado da enorme quantidade de motores de templates JavaScript lá fora, e toda a sua linha HTML-modelos, estilos diferentes de marcação, etc., e decidiu construir uma pequena biblioteca que permite XSLT formatação de estruturas de dados JSON. Não foguete ciência de qualquer forma - é apenas JSON analisado para XML e, em seguida, formatado com um documento XSLT. É rápido demais, não tão rápido como modelo de motores de JavaScript no Chrome, mas na maioria dos outros navegadores é pelo menos tão rápido como a alternativa motor de JS para estruturas de dados maiores.
Eu estou usando Camel unmarshal rota (xml json) -> a (XSLT) -> marshal (xmljson). bastante eficiente (embora não seja 100% perfeito), mas simples, se você já estiver usando Camel.
é muito possível converter JSON usando XSLT:. Você precisa JSON2SAX desserializador e SAX2JSON serializer
Exemplo de código em Java: http://www.gerixsoft.com/blog/json/xslt4json
Yate ( https://github.com/pasaran/yate ) é especificamente concebido após XSLT , apresenta JPath (a equivalente XPath natural para JS), compila para JavaScript e tem uma história de uso em produção. É praticamente em situação irregular, mas a leitura através de amostras e testes deve ser suficiente.
JSLT está muito perto de um equivalente JSON de XSLT. É uma linguagem transformar onde você escreve a parte fixa da produção na sintaxe JSON, em seguida, insira expressões para calcular os valores que deseja inserir no modelo.
Um exemplo:
{
"time": round(parse-time(.published, "yyyy-MM-dd'T'HH:mm:ssX") * 1000),
"device_manufacturer": .device.manufacturer,
"device_model": .device.model,
"language": .device.acceptLanguage
}
É implementado em Java em cima de Jackson.
Não muito certo há necessidade para isso, e para mim falta de ferramentas sugere a falta de necessidade. JSON é mais processado como objetos (a forma como é feito em JS de qualquer maneira), e você normalmente usa linguagem do próprio objetos para fazer transformações (Java para Java objetos criados a partir JSON, mesmo para Perl, Python, Perl, C #, PHP e assim em). Apenas com as atribuições normais (ou set, get), looping e assim por diante.
Quer dizer, XSLT é apenas uma outra linguagem, e uma razão que é necessário é que XML não é uma notação de objeto e, portanto, objetos de linguagens de programação não são ataques exatas (impedância entre modelo hierárquico XML e objetos / estruturas).
Por que você não converte JSON para XML usando Mr. Dados Coverter , tranform-lo usando XSLT e então alterá-lo de volta para JSON usando o mesmo.
Para um trabalho Doodle / prova de conceito de uma abordagem de utilizar puro JavaScript, juntamente com o padrão familiar e declarativa trás expressões correspondentes de XSLT e modelos recursivas, consulte https://gist.github.com/brettz9/0e661b3093764f496e36
(A abordagem semelhante pode ser tomada para JSON.)
Note que a demo também depende de JavaScript 1.8 fechamentos de expressão para a conveniência em expressar modelos no Firefox (pelo menos até que a forma curta ES6 para métodos podem ser implementados).
Disclaimer:. Este é o meu próprio código
Eu escrevi um adaptador dom para a minha estrutura de processamento de json com base jackson há muito tempo. Ele usa a biblioteca nu.xom. A árvore dom resultando trabalha com o xpath java e instalações XSLT. Fiz algumas escolhas de implementação que são bastante simples. Por exemplo, o nó raiz é sempre chamado "root", matrizes entrar em um nó de ol com li sub elementos (como em html), e tudo o resto é apenas um nó sub com um valor primitivo ou outro nó objeto.
Uso:
JsonObject sampleJson = sampleJson();
org.w3c.dom.Document domNode = JsonXmlConverter.getW3cDocument(sampleJson, "root");
Uma abordagem ainda não dado é usar um gerador de analisador para criar um analisador em XSLT que analisa JSON e produz uma saída XML.
Uma opção que é mencionado muito nas conferências XML é o gerador de analisador ReX ( http: // www .bottlecaps.de / rex / ) -. embora totalmente indocumentados no site, receitas estão disponíveis na busca
Pode ser possível usar XSLT com JSON. Verson 3 do XPath (3.1) XSLT (3.0) e Xquery (3.1) suporta JSON de alguma forma. Este parece ser disponível na versão comercial de Saxon, e pode em algum momento ser incluído na versão HE. https://www.saxonica.com/html/documentation/ funções / fn / parse-json.html
-
O que eu esperaria de uma solução alternativa:
Eu gostaria de ser capaz JSON de entrada para buscar um conjunto combinado de dados e saída de JSON ou texto.
propriedades arbitrárias de acesso e avaliar os valores
O suporte para lógica condicional
Eu gostaria que os scripts de transformação para ser externa a partir da ferramenta, baseado em texto, e de preferência uma linguagem comumente usado.
alternativa potencial?
Gostaria de saber se SQL poderia ser uma alternativa adequada. https://docs.microsoft. com / en-us / sql / relacional de bases de dados / json / json-data-sql-server
Seria bom se a ferramenta alternativa poderia lidar com JSON e XML https://docs.microsoft.com/ en-us / sql / relacional de bases de dados / xml / OpenXML-sql-server
Eu ainda não tentou converter os scripts XSLT que eu uso para SQL, ou totalmente avaliada esta opção ainda, mas espero pensar mais sobre isso em breve. Apenas alguns pensamentos até agora.
JSON-e tem implementações em Node.js, Python and Go.
