Equivalente XSLT per JSON

Esiste un equivalente XSLT per JSON? Qualcosa che mi permetta di fare trasformazioni su JSON come XSLT a XML.

Idea interessante Alcune ricerche su Google hanno prodotto alcune pagine di interesse, tra cui:

  • una descrizione di come un tale strumento “jsonT” potrebbe essere implementato e alcuni download
  • qualche discussione su questa implementazione
  • una società che può aver implementato qualcosa di adatto

Spero che questo ti aiuti.

Prova JOLT . È una libreria di trasformazione JSON to JSON scritta in Java.

È stato creato appositamente perché non volevamo riprodurre il gioco “JSON -> XML -> XSLT -> XML -> JSON” e l’utilizzo di un modello per qualsiasi trasformazione sufficientemente complessa non è ansible.

Recentemente ho trovato uno strumento che adoro per lo styling JSON: https://github.com/twigkit/tempo . Strumento molto semplice da utilizzare: secondo me, è molto più semplice lavorare con XSLT, senza bisogno di interrogazioni XPATH.

jq – processore JSON da riga di comando leggero e flessibile

Non è basato su modelli come XSLT, ma è più conciso. ad esempio per estrarre i campi name e address in un array: [.name, .address]

Il tutorial illustra un esempio di trasformazione dell’API JSON di Twitter (e il manuale ha molti esempi).

XSLT supporta JSON come visto su http://www.w3.org/TR/xslt-30/#json

XML usa parentesi angolari per i token delimitatore, JSON usa parentesi graffe, parentesi quadre … I. e. Il minor numero di confronti di riconoscimento token di XML significa che è ottimizzato per la trasformazione dichiarativa, mentre più confronti, essendo come un’istruzione switch, per ragioni di velocità presuppongono la previsione di branche speculative che il codice imperativo nei linguaggi di scripting è utile. Come conseguenza diretta, per diversi mix di dati semi-strutturati, potresti voler confrontare le prestazioni dei motori XSLT e javascript come parte delle pagine reattive. Per un payload di dati trascurabile, le trasformazioni potrebbero funzionare altrettanto bene con JSON senza serializzazione XML. La decisione di W3 dovrebbe essere basata su una migliore analisi.

Equivalenti XSLT per JSON – una lista di candidati (strumenti e specifiche)

Utensili

  1. XSLT

    È ansible utilizzare XSLT per JSON con l’objective di fn: json-to-xml .

    Questa sezione descrive le strutture che consentono di elaborare i dati JSON utilizzando XSLT.

  2. jq Ultimo impegno il 12 maggio 2018

    jq è come sed per i dati JSON – puoi usarlo per suddividere e filtrare e mappare e trasformare i dati strutturati con la stessa facilità con cui sed, awk, grep e amici ti permettono di giocare con il testo. Esistono pacchetti di installazione per diversi sistemi operativi.

  3. jj Last commit 2 marzo 2018

    JJ è un’utilità della riga di comando che fornisce un modo rapido e semplice per recuperare o aggiornare valori dai documenti JSON. È alimentato da GJSON e SJSON sotto il cofano.

  4. fx Last commit, 20 marzo 2018

    Strumento di elaborazione JSON della riga di comando

    • Non c’è bisogno di imparare nuova syntax
    • Semplice JavaScript
    • Formattazione e evidenziazione
    • Binario autonomo
  5. jsawk Last commit 4 mar 2015

    Jsawk è come awk, ma per JSON. Si lavora con una serie di oggetti JSON letti da stdin, li si filtra usando JavaScript per produrre una matrice di risultati stampata su stdout.

  6. json Last Commit 3 marzo 2017

    json è uno strumento CLI veloce per lavorare con JSON. È uno script node.js a file singolo senza deps esterni (diverso da node.js stesso).

  7. jl Last Commit Apr 10, 2018

    jl (“JSON lambda”) è un linguaggio funzionale minuscolo per interrogare e manipolare JSON.

  8. Ultimo impegno 13 marzo 2017

    I test possono essere utilizzati come docu https://github.com/pasaran/yate/tree/master/tests

  9. json-transforms Last Commit 1 dicembre 2017

    Fornisce un approccio ricorsivo e basato sulla corrispondenza dei modelli per la trasformazione dei dati JSON. Le trasformazioni sono definite come un insieme di regole che corrispondono alla struttura di un object JSON. Quando si verifica una corrispondenza, la regola emette i dati trasformati, opzionalmente ricorsivi per trasformare oggetti figlio.

  10. jsonpath-object-transform Last Commit, 18 gennaio 2017

    Estrae i dati da un object letterale utilizzando JSONPath e genera un nuovo object basato su un modello.

  11. JOLT Last Commit 1 maggio 2018

    Libreria di trasformazione da JSON a JSON scritta in Java dove la “specifica” per la trasformazione è di per sé un documento JSON.

  12. gron Last Commit Apr 5, 2018

    Rendi JSON inguardabile! gron trasforma JSON in assegnazioni discrete per rendere più facile il grep per quello che vuoi e vedere il ‘percorso’ assoluto ad esso. Facilita l’esplorazione delle API che restituiscono grossi blob di JSON ma hanno una documentazione terribile.

  13. Stapling Last Commit 16 settembre 2013

    La pinzatura è una libreria JavaScript che abilita la formattazione XSLT per oggetti JSON. Invece di usare un motore di template JavaScript e modelli text / html, Stapling ti dà l’opportunità di usare i template XSLT – caricati in modo asincrono con Ajax e poi lato client in cache – per analizzare le origini dati JSON.

  14. json-e Last Commit il 22 maggio 2018

    JSON-e è un sistema di parametrizzazione della struttura dei dati per l’incorporamento del contesto negli oggetti JSON. L’idea centrale è di trattare una struttura dati come un “modello” e trasformarla, usando un’altra struttura dati come contesto, per produrre una struttura dati di output.

Specifiche:

  • JsonPointer

    JSON Pointer definisce una syntax della stringa per l’identificazione di un valore specifico all’interno di un documento JSON (JavaScript Object Notation).

  • JsonPath

    Le espressioni JSONPath fanno sempre riferimento a una struttura JSON nello stesso modo in cui le espressioni XPath vengono utilizzate in combinazione con un documento XML

  • JSPath

    JSPath per JSON è come XPath per XML. ”

  • JSONiq

    La principale fonte di ispirazione di JSONiq è XQuery, che finora è stato dimostrato un linguaggio di query produttivo e di successo per dati semi-strutturati

Dai un’occhiata a jsonpath-object-transform

Dire che la mancanza di strumenti suggerisce che la mancanza di bisogno è solo l’elemosina. Lo stesso potrebbe essere applicato al supporto per X o Y in Linux (perché preoccuparsi di sviluppare driver di qualità e / o giochi per un SO di minoranza? E perché prestare attenzione a un sistema operativo per cui non si sviluppano grandi società di giochi e hardware?). Probabilmente le persone che avrebbero bisogno di usare XSLT e JSON finiscono per usare una soluzione alquanto banale: Trasformare JSON in XML. Ma questa non è la soluzione ottimale, vero?

Quando si dispone di un formato JSON nativo e si desidera modificarlo “wysywyg” nel browser, XSLT sarebbe una soluzione più che adeguata per il problema. Farlo con la tradizionale programmazione javascript può diventare un rompicoglioni.

In effetti, ho implementato un approccio “stone-age” a XSLT, usando l’analisi della sottostringa per interpretare alcuni comandi di base per javascript, come chiamare un modello, elaborare figli, ecc. Certamente implementare un motore di trasformazione con un object JSON è molto più facile di implementando un parser XML completo per analizzare XSLT. Il problema è che per utilizzare i modelli XML per trasformare un object JSON è necessario analizzare l’XML dei modelli.

Per trasformare un object JSON con XML (o HTML, o testo o altro) è necessario riflettere attentamente sulla syntax e su quali caratteri speciali è necessario utilizzare per identificare i comandi di trasformazione. Altrimenti finirai per dover progettare un parser per la tua lingua di template personalizzata. Avendo camminato su quella strada, posso dirti che non è carina.

Aggiornamento (12 novembre 2010): Dopo un paio di settimane di lavoro sul mio parser, sono stato in grado di ottimizzarlo. I modelli vengono analizzati in anticipo e i comandi vengono archiviati come oggetti JSON. Le regole di trasformazione sono anche oggetti JSON, mentre il codice template è un mix di HTML e una syntax homebrew simile al codice shell. Sono stato in grado di trasformare un documento JSON complesso in HTML per creare un editor di documenti. Il codice è di circa 1K linee per l’editor (è per un progetto privato quindi non posso condividerlo) e circa 990 linee per il codice di trasformazione JSON (include comandi di iterazione, confronti semplici, chiamate di template, salvataggio e valutazione variabili). Ho intenzione di rilasciarlo con una licenza MIT. Mandami una mail se vuoi essere coinvolto.

C’è ora! Recentemente ho creato una libreria, json-transforms , esattamente per questo scopo:

https://github.com/ColinEberhardt/json-transforms

Utilizza una combinazione di JSPath , una DSL modellata su XPath e un approccio di pattern matching ricorsivo, ispirato direttamente da XSLT.

Ecco un rapido esempio. Dato il seguente object 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 } ] }; 

Ecco una trasformazione:

 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 transformsd = jsont.transform(json, rules); 

Quale uscita il seguente:

 { "Honda": [ { "model": "Jazz", "year": 2010 }, { "model": "Civic", "year": 2007 }, { "model": "Accord", "year": 2011 } ] } 

Questa trasformazione è composta da tre regole. Il primo corrisponde a qualsiasi automobile prodotta da Honda, che emette un object con una proprietà Honda , quindi corrisponde ricorsivamente. La seconda regola corrisponde a qualsiasi object con una proprietà maker , emettendo le proprietà del model e year . La finale è la trasformazione dell’identity framework che corrisponde ricorsivamente.

Come ancora una nuova risposta a una vecchia domanda, suggerirei uno sguardo a DefiantJS . Non è un equivalente XSLT per JSON, è XSLT per JSON. La sezione “Templating” della documentazione include questo esempio:

    

Ho scritto la mia piccola biblioteca attorno a questo, di recente, che cerca di rimanere il più vicino ansible

Modello di elaborazione 5.1 (XSLT REC) https://www.w3.org/TR/xslt#section-Processing-Model

come è ansible (come potrei comunque), in poche righe di codice JavaScript.

Ecco alcuni esempi non banali di utilizzo …

1. JSON-to-some-markup:

Fiddle: https://jsfiddle.net/YSharpLanguage/kj9pk8oz/10

(ispirato a D.1 Document Example (XSLT REC) https://www.w3.org/TR/xslt#section-Document-Example )

dove questo:

 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 "\r\n\ \r\n\ \r\n\ {title}\r\n".of(root) + "\ \r\n\ \r\n\ \r\n\ {*}".of(root[""].through(this)) + "\ \r\n\ "; } ], [ [ function(node) { return node.type === "chapter"; } ], function(chapter) { return " 

{title}

\r\n".of(chapter) + "{*}".of(chapter[""].through(this)); } ], [ [ function(node) { return node.type === "section"; } ], function(section) { return "

{title}

\r\n".of(section) + "{*}".of(section[""].through(this)); } ], [ [ function(node) { return node.type === "para"; } ], function(para) { return "

{*}

\r\n".of(para[""].through(this)); } ], [ [ function(node) { return node.type === "note"; } ], function(note) { return '

NOTE: {*}

\r\n'.of(note[""].through(this)); } ], [ [ function(node) { return node.emph; } ], function(emph) { return "{emph}".of(emph); } ] ] }; console.log(D1document.through(D1toHTML));

… dà:

    Document Title    

Chapter Title

Section Title

This is a test.

NOTE: This is a note.

Another Section Title

This is another test.

NOTE: This is another note.

e

2. JSON-to-JSON:

Fiddle: https://jsfiddle.net/YSharpLanguage/ppfmmu15/10

dove questo:

 // (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:

Un equivalente JavaScript di …

XSLT 3.0 REC Sezione 14.4 Esempio: raggruppamento di nodes in base a valori comuni

(a: http://jsfiddle.net/YSharpLanguage/8bqcd0ey/1 )

Cf. https://www.w3.org/TR/xslt-30/#grouping-examples

dove…

 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 = "\r\n\ \r\n\ \r\n\ \r\n\ \r\n\ \r\n\ {*}\r\n\ 
PositionCountryCity ListPopulation
".of ( cities.select().groupBy("country")(function(byCountry, index) { var country = byCountry[0], cities = byCountry[1].select().orderBy("name"); return "\r\n\ \r\n\ {position}\r\n\ {country}\r\n\ {cities}\r\n\ {population}\r\n\ ". 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à:

 
Position Country City List Population
1 Italia Milano, Venezia 6
2 France Lyon, Paris 9
3 Deutschland München 4

4. JSONiq vs. JavaScript:

Un equivalente JavaScript di …

Casi di utilizzo di JSONiq Sezione 1.1.2. Raggruppamento di query per JSON

(a: https://jsfiddle.net/YSharpLanguage/hvo24hmk/3 )

Cf. http://jsoniq.org/docs/JSONiq-usecases/html-single/index.html#jsongrouping

dove…

 /* 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 } ] } ] } ] 

È anche utile superare i limiti di JSONPath wrt. interrogare l’asse dell’antenato, come sollevato da questa domanda SO (e certamente da altri).

Ad esempio, come ottenere lo sconto di un prodotto alimentare conoscendo il suo marchio, in

 { "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 ansible soluzione è:

 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); 

… che dà:

 Discount of #983: 20 

‘HTH,

Sono stato davvero stanco dell’enorme quantità di motori di template JavaScript in circolazione, e di tutti i loro modelli HTML incorporati, stili di markup differenti, ecc. E ho deciso di creare una piccola libreria che abilitasse la formattazione XSLT per le strutture di dati JSON. Non è una scienza missilistica in alcun modo: è solo JSON analizzato in XML e quindi formattato con un documento XSLT. È anche veloce, non veloce come i motori di template JavaScript in Chrome, ma nella maggior parte degli altri browser è almeno veloce quanto l’alternativa del motore JS per strutture di dati più grandi.

JSONiq è un tale standard e Zorba è un’implementazione C ++ open source. JSONiq può anche essere visto come XQuery con l’aggiunta di JSON come tipo di dati nativi.

Sto usando Camel route umarshal (xmljson) -> a (xlst) -> marshal (xmljson). Abbastanza efficiente (anche se non perfetto al 100%), ma semplice, se stai già utilizzando Camel.

Non sono troppo sicuro che ci sia bisogno di questo, e per me la mancanza di strumenti suggerisce la mancanza di necessità. JSON è meglio elaborato come oggetti (come è fatto in JS comunque), e tipicamente usi il linguaggio degli oggetti stessi per fare trasformazioni (Java per oggetti Java creati da JSON, lo stesso per Perl, Python, Perl, c #, PHP e così sopra). Solo con compiti normali (o set, get), loop e così via.

Voglio dire, XSLT è solo un’altra lingua, e una ragione è che l’XML non è una notazione di oggetti e quindi gli oggetti dei linguaggi di programmazione non sono esatti (impedenza tra il modello xml gerarchico e oggetti / strutture).

è molto ansible convertire JSON utilizzando XSLT: è necessario il deserializzatore JSON2SAX e il serializzatore SAX2JSON.

Esempio di codice in Java: http://www.gerixsoft.com/blog/json/xslt4json

Yate ( https://github.com/pasaran/yate ) è progettato in modo specifico dopo XSLT, include JPath (un equivalente XPath naturale per JS), compila JavaScript e ha una lunga storia di utilizzo della produzione. È praticamente non documentato, ma leggere i campioni e i test dovrebbe essere sufficiente.

Perché non converti JSON in XML usando Mr. Data Coverter , lo trasformi usando XSLT e poi lo cambi in JSON usando lo stesso.

Per un doodle di lavoro / prova di concetto di un approccio per utilizzare JavaScript puro insieme al modello familiare e dichiarativo dietro le espressioni di corrispondenza e i modelli ricorsivi di XSLT, vedere https://gist.github.com/brettz9/0e661b3093764f496e36

(Un approccio simile potrebbe essere preso per JSON.)

Si noti che la demo si basa anche su chiusure di espressioni di JavaScript 1.8 per la comodità nell’espressione di modelli in Firefox (almeno fino a quando non sarà ansible implementare la forma abbreviata ES6 per i metodi).

Disclaimer: questo è il mio codice.

Ho scritto un adattatore dom per il mio framework di elaborazione JSON basato su jackson molto tempo fa. Usa la libreria nu.xom. La struttura ad albero risultante funziona con le strutture java xpath e xslt. Ho fatto alcune scelte di implementazione che sono piuttosto semplici. Ad esempio il nodo radice è sempre chiamato “root”, gli array vanno in un nodo ol con elementi secondari li (come in html), e tutto il resto è solo un sub nodo con un valore primitivo o un altro nodo object.

JsonXmlConverter.java

Utilizzo: JsonObject sampleJson = sampleJson(); org.w3c.dom.Document domNode = JsonXmlConverter.getW3cDocument(sampleJson, "root"); JsonObject sampleJson = sampleJson(); org.w3c.dom.Document domNode = JsonXmlConverter.getW3cDocument(sampleJson, "root");

Un approccio non ancora dato è quello di utilizzare un generatore di parser per creare un parser in XSLT che analizza JSON e produce un output XML.

Un’opzione che viene menzionata molto nelle conferenze XML è il generatore di parser ReX ( http://www.bottlecaps.de/rex/ ) – sebbene totalmente non documentato sul sito, le ricette sono disponibili per la ricerca.

Potrebbe essere ansible utilizzare XSLT con JSON. La versione 3 di XPath (3.1) XSLT (3.0) e XQuery (3.1) supporta JSON in qualche modo. Questo sembra essere disponibile nella versione commerciale di Saxon, e potrebbe a un certo punto essere incluso nella versione HE. https://www.saxonica.com/html/documentation/functions/fn/parse-json.html

Cosa mi aspetterei da una soluzione alternativa:

Vorrei poter inserire JSON per recuperare un insieme di dati corrispondente e generare JSON o TEXT.

Accedi a proprietà arbitrarie e valuta i valori

Supporto per la logica condizionale

Vorrei che gli script di trasformazione fossero esterni allo strumento, basati su testo e preferibilmente un linguaggio comunemente usato.

Potenziale alternativa?

Mi chiedo se SQL potrebbe essere un’alternativa adatta. https://docs.microsoft.com/en-us/sql/relational-databases/json/json-data-sql-server

Sarebbe bello se lo strumento alternativo potesse gestire JSON e XML https://docs.microsoft.com/en-us/sql/relational-databases/xml/openxml-sql-server

Non ho ancora provato a convertire gli script XSLT che uso per SQL, o ancora valutato questa opzione, ma spero di esaminarlo più presto. Solo alcuni pensieri finora.

JSON-e ha implementazioni in Node.js, Python e Go.