Intenta SACUDIR. Es una biblioteca de transformación JSON a JSON escrita en Java.

Se creó específicamente porque no queríamos jugar al juego "JSON -> XML -> XSLT -> XML -> JSON", y usar una plantilla para cualquier transformación suficientemente compleja es imposible de mantener.

Equivalentes XSLT para JSON-una lista de candidatos (herramientas y especificaciones)

Herramientas

1. XSLT

   Puede usar XSLT para JSON con el objetivo de fn:json-to-xml.

   Esta sección describe las facilidades que permiten procesar datos JSON usando XSLT.

2. jq Último compromiso 12 de mayo de 2018

   Jq es como sed para los datos JSON - se puede utilizar para dividir y filtrar y mapear y transformar datos estructurados con la misma facilidad que sed, awk, grep y friends te permiten jugar con texto. Hay paquetes de instalación para diferentes sistemas operativos.

3. jj Último compromiso Mar 2, 2018

   JJ es una utilidad de línea de comandos que proporciona una forma rápida y sencilla de recuperar o actualizar valores de documentos JSON. Es impulsado por GJSON y SJSON bajo el capó.

4. fx Último compromiso Mar 20, 2018

   JSON de línea de comandos herramienta de procesamiento

   • No es necesario aprender nueva sintaxis
   • Javascript simple
   • Formateo y resaltado
   • Binario independiente

5. jsawk Último compromiso Mar 4, 2015

   Jsawk es como awk, pero para JSON. Se trabaja con una matriz de objetos JSON leídos desde stdin, se filtran usando JavaScript para producir una matriz de resultados que se imprime en stdout.

6. json Último compromiso Mar 3, 2017

   Json es una herramienta de CLI rápida para trabajar con JSON. Es un nodo de un solo archivo.script js sin deps externos (que no sean node.js en sí).

7. jl Último compromiso Apr 10, 2018

   Jl ("JSON lambda") es un pequeño lenguaje funcional para consultar y manipular JSON.

8. yate Último compromiso Mar 13, 2017

   Las pruebas pueden utilizarse como docu https://github.com/pasaran/yate/tree/master/tests

9. transformaciones json Último compromiso Dec 1, 2017

   Proporciona un enfoque recursivo 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, opcionalmente recursiva para transformar hijo objeto.

10. jsonpath-object-transform Último compromiso Jan 18, 2017

    Extrae datos de un literal de objeto usando JSONPath y genera nuevos objetos basados en una plantilla.

11. SACUDIDA Último compromiso 1 de mayo de 2018

    Biblioteca de transformación JSON a JSON escrita en Java donde la "especificación" para la transformación es en sí un documento JSON.

12. Gron Última Commit Apr 5, 2018

    ¡Haz que JSON sea compatible! gron transforma JSON en asignaciones discretas para facilitar grep para lo que desea y ver el 'camino' absoluto a él. Facilita la exploración de API que devuelven grandes blobs de JSON pero tienen una documentación terrible.

13. Grapado Last Commit Sep 16, 2013

    Grapado es una biblioteca JavaScript que habilita el formato XSLT para objetos JSON. En lugar de utilizar un Motor de plantillas JavaScript y plantillas de texto/html, Grapado le da la oportunidad de usar plantillas XSLT - cargadas asíncronamente con Ajax y luego en caché del lado del cliente - para analizar sus fuentes de datos JSON.

14. Json-e Último compromiso 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 otros datos estructura 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 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 XML documento

• JSPath

  JSPath para JSON es como XPath para XML."

• JSONiq

  La principal fuente de inspiración detrás de JSONiq es XQuery, que hasta ahora ha demostrado ser un lenguaje de consulta exitoso y productivo para datos semiestructurados

XSLT soporta JSON como se ve en http://www.w3.org/TR/xslt-30/#json

XML utiliza corchetes angulares para los símbolos delimitadores, JSON utiliza llaves, corchetes,... Es decir, menos comparaciones de reconocimiento de tokens de XML significa que está optimizado para la transformación declarativa, mientras que más comparaciones, al ser como la instrucción switch, por razones de velocidad asumen la predicción de ramas especulativas para la que el código imperativo en lenguajes de scripting es útil. 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 receptivas. Para la carga útil de datos insignificante, las transformaciones podrían funcionar igual de bien con JSON sin serialización XML. La decisión del W3 debería basarse en un mejor análisis.

Recientemente encontré una herramienta que me encanta para diseñar JSON: https://github.com/twigkit/tempo . Herramienta muy fácil de usar in en mi opinión, es mucho más fácil de trabajar que XSLT no no hay necesidad de consultas XPATH.

Jq-procesador JSON de línea de comandos ligero y flexible

No está basado en plantillas como XSLT, sino más conciso. por ejemplo, para extraer name y address campos en una matriz: [.name, .address]

El tutorial recorre un ejemplo de transformación de la API JSON de Twitter (y el manual tiene muchos ejemplos).

Echa un vistazo a jsonpath-object-transform

Decir que la falta de herramientas sugiere la falta de necesidad es solo pedir la 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 las grandes compañías de juegos y hardware no desarrollan?). Probablemente las personas que necesitarían usar XSLT y JSON terminarían usando una solución algo trivial: Transformar JSON en XML. Pero esa no es la solución óptima, ¿verdad?

Cuando usted 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 tradicional de javascript puede convertirse en un dolor en el culo.

De hecho, he implementado un enfoque de "edad de piedra" para XSLT, utilizando el análisis de subcadenas para interpretar algunos comandos básicos para javascript, como llamar a una plantilla, procesos secundarios, etc. Ciertamente, implementar un motor de transformación con un objeto JSON es mucho más fácil que implementar un analizador XML completo para analizar el XSLT. El problema es que, para usar plantillas XML para transformar un objeto JSON, necesita analizar el XML de las plantillas.

Para transformar un objeto JSON con XML (o HTML, o texto o lo que sea) necesita pensar cuidadosamente sobre la sintaxis y qué caracteres especiales necesita usar para identificar los comandos de transformación. De lo contrario, tendrás que diseñar un analizador para tu propio lenguaje de plantillas personalizado. Habiendo caminado por ese camino, Puedo decirte que no es bonito.

Actualización (12 de noviembre de 2010): Después de un par de semanas trabajando en mi analizador, he sido capaz de 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 plantilla es una mezcla de HTML y una sintaxis homebrew similar al código de shell. He sido capaz de transformar un documento JSON complejo en HTML para hacer un editor de documentos. El código es de alrededor de 1K líneas para el editor (es para un private project so I can't share it) y alrededor de 990 líneas para el código de transformación JSON (incluye comandos de iteración, comparaciones simples, llamadas a plantillas, ahorro de variables y evaluación). Planeo liberarlo bajo una licencia del MIT. Envíame un correo si quieres involucrarte.

Hay ahora! Recientemente creé una biblioteca, json-transforms , exactamente para este propósito:

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

Utiliza una combinación de JSPath, un DSL modelado en XPath, y un enfoque de coincidencia de patrones 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 la salida de la 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 Honda, y luego coincide recursivamente. La segunda regla coincide con cualquier objeto con una propiedad maker, mostrando las propiedades model y year. La final es la transformación de identidad que coincide recursivamente.

Como otra nueva respuesta a una vieja pregunta, sugeriría un vistazo a DefiantJS. No es un XSLT equivalente para JSON, es 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>

Escribí mi propia pequeña biblioteca alrededor de esto, recientemente, que trata de mantenerse lo más cerca posible de {[12]]}

5.1 Modelo de procesamiento (XSLT REC) https://www.w3.org/TR/xslt#section-Processing-Model

Como es posible (como podría de todos modos), en unas pocas líneas de código JavaScript.

Aquí hay algunos ejemplos de uso no completamente triviales...

1. JSON-to-some-markup:

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

(inspirado en 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-to-JSON:

Violín: https://jsfiddle.net/YSharpLanguage/ppfmmu15/10

Donde esto:

// (A "Company" is just an object with a "Team")
function Company(obj) {
  return obj.team && Team(obj.team);
}

// (A "Team" is just a non-empty array that contains at least one "Member")
function Team(obj) {
  return ({ }.toString.call(obj) === "[object Array]") &&
         obj.length &&
         obj.find(function(item) { return Member(item); });
}

// (A "Member" must have first and last names, and a gender)
function Member(obj) {
  return obj.first && obj.last && obj.sex;
}

function Dude(obj) {
  return Member(obj) && (obj.sex === "Male");
}

function Girl(obj) {
  return Member(obj) && (obj.sex === "Female");
}

var data = { team: [
  { first: "John", last: "Smith", sex: "Male" },
  { first: "Vaio", last: "Sony" },
  { first: "Anna", last: "Smith", sex: "Female" },
  { first: "Peter", last: "Olsen", sex: "Male" }
] };

var TO_SOMETHING_ELSE = { $: [

  [ [ Company ],
    function(company) {
      return { some_virtual_dom: {
        the_dudes: { ul: company.team.select(Dude).through(this) },
        the_grrls: { ul: company.team.select(Girl).through(this) }
      } }
    } ],

  [ [ Member ],
    function(member) {
      return { li: "{first} {last} ({sex})".of(member) };
    } ]

] };

console.log(JSON.stringify(data.through(TO_SOMETHING_ELSE), null, 4));

... da:

{
    "some_virtual_dom": {
        "the_dudes": {
            "ul": [
                {
                    "li": "John Smith (Male)"
                },
                {
                    "li": "Peter Olsen (Male)"
                }
            ]
        },
        "the_grrls": {
            "ul": [
                {
                    "li": "Anna Smith (Female)"
                }
            ]
        }
    }
}

3. XSLT vs JavaScript:

Un equivalente de JavaScript de...

XSLT 3.0 REC Sección 14.4 Ejemplo: Agrupar 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...

Sección de Casos de Uso de JSONiq 1.1.2. Agrupar consultas para JSON

(en: https://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. cuestionando contra el eje ancestro, como lo plantea esta pregunta (y ciertamente otras).

Por ejemplo, cómo obtener el descuento de un artículo de comestibles sabiendo su identificación 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);

... que da:

Discount of #983: 20

' HTH,

He estado muy cansado de la enorme cantidad de motores de plantillas JavaScript que hay, y todas sus plantillas HTML en línea, diferentes estilos de marcado, etc., y decidió construir una pequeña biblioteca que habilita el formato XSLT para estructuras de datos JSON. No es ciencia de cohetes de ninguna manera it es solo JSON analizado a XML y luego formateado con un documento XSLT. También es rápido, no tan rápido como los motores de plantillas JavaScript en Chrome, pero en la mayoría de los otros navegadores es al menos tan rápido como el JS motor alternativo para estructuras de datos más grandes.

JSONiq es un estándar y Zorba una implementación de código abierto en C++. JSONiq también se puede ver como XQuery con la adición de JSON como un tipo de datos nativo.

Estoy usando la ruta de camello umarshal(xmljson) -> a(xlst) -> marshal(xmljson). Lo suficientemente eficiente (aunque no 100% perfecto), pero simple, si ya está utilizando Camel.

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 de todos modos), y normalmente se utiliza el lenguaje de los objetos en sí para hacer transformaciones (Java para objetos Java creados a partir de JSON, lo mismo para Perl, Python, Perl, c#, PHP y así sucesivamente). Solo con asignaciones normales (o set, get), looping y así sucesivamente.

Quiero decir, XSLT es solo otro lenguaje, y una razón por la que se necesita es que XML no es un objeto la notación y, por lo tanto, los objetos de los lenguajes de programación no son ajustes exactos (impedancia entre el modelo xml jerárquico y los objetos/estructuras).

Es muy posible convertir JSON usando XSLT: necesita JSON2SAX deserializer y SAX2JSON serializer.

Código de ejemplo en Java: http://www.gerixsoft.com/blog/json/xslt4json

Yate ( https://github.com/pasaran/yate ) está diseñado específicamente después de XSLT, cuenta con JPath (un equivalente natural de XPath para JS), compila a JavaScript y tiene un buen historial de uso de producción. Es prácticamente indocumentado, pero leer muestras y pruebas debería ser suficiente.

Por qué no convierte JSON a XML usando Mr.Data Coverter, lo transforma usando XSLT y luego lo cambia de nuevo a JSON usando el mismo.

Para un doodle/prueba de concepto de trabajo de un enfoque para utilizar JavaScript puro junto con el patrón familiar y declarativo detrás de las expresiones coincidentes de XSLT y las plantillas recursivas, consulte https://gist.github.com/brettz9/0e661b3093764f496e36

(Se podría adoptar un enfoque similar para JSON.)

Tenga en cuenta que la demo también se basa en cierres de expresión JavaScript 1.8 para mayor comodidad en la expresión de plantillas en Firefox (al menos hasta el formulario corto ES6 para los métodos puede aplicarse).

Descargo de responsabilidad: Este es mi propio código.

Escribí un adaptador dom para mi framework de procesamiento json basado en Jackson hace mucho tiempo. Utiliza la nu.biblioteca xom. El árbol dom resultante funciona con las instalaciones 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", los arrays van a un nodo ol con subelementos li (como en html), y todo lo demás es solo un sub nodo con un valor primitivo u otro objeto nodo.

JsonXmlConverter.java

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

Un enfoque aún no dado es usar un generador de analizador para crear un analizador en XSLT que analiza JSON y produce una salida XML.

Una opción que se menciona mucho en las conferencias XML es el generador de parser ReX ( http://www.bottlecaps.de/rex / ) - aunque totalmente indocumentado en el sitio, recetas están disponibles en la búsqueda.

Puede ser posible usar XSLT con JSON. Versión 3 de XPath(3.1) XSLT(3.0) y XQuery (3.1) soporta JSON de alguna manera. Esto parece estar disponible en la versión comercial de Saxon, y podría en algún momento ser incluido 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 salida JSON o TEXTO.

Acceda a propiedades arbitrarias y evalúe los valores

Soporte para lógica condicional

Me gustaría que los scripts de transformación fueran externos a la herramienta, basados 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 el herramienta alternativa podría 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, pero espero verlo más pronto. Sólo algunas ideas hasta ahora.

JSON-e tiene implementaciones en Node.js, Python y listo.