Odpowiedniki XSLT dla JSON-lista kandydatów (narzędzia i specyfikacje)

Narzędzia

1. XSLT

Możesz użyć XSLT dla JSON w celu fn:json-to-xml .

Ta sekcja opisuje udogodnienia umożliwiające przetwarzanie danych JSON przy użyciu XSLT.

2. jq

Jq jest jak sed dla danych JSON - można go używać do wycinania i filtrowania, mapowania i przekształcania ustrukturyzowanych danych z taką samą łatwością sed, awk, grep i znajomi pozwalają Ci bawić się tekstem. Istnieją pakiety instalacyjne dla różnych systemów operacyjnych.

3. jj

JJ to narzędzie wiersza poleceń, które zapewnia szybki i prosty sposób pobierania lub aktualizowania wartości z dokumentów JSON. Zasilany jest przez GJSONA i SJSONA pod maską.

4. fx

Command-line JSON processing tool - Nie trzeba uczyć się nowej składni - Zwykły JavaScript - Formatowanie i podświetlanie - Standalone binary

5. jl

JL ("JSON lambda") jest małym funkcjonalnym językiem do zapytań i manipulacji JSON.

6. JOLT

Biblioteka transformacji JSON do JSON napisana w Javie, gdzie "specyfikacja" dla transformacji jest sama w sobie dokumentem JSON.

7. gron

Make JSON greppable! gron przekształca JSON w dyskretne przypisania do Ułatw grep dla tego, co chcesz i zobacz absolutną "ścieżkę" do niego. Ułatwia to eksplorację interfejsów API, które zwracają duże plamy JSON, ale mają okropną dokumentację.

8. json-e

JSON-e jest systemem parametryzacji struktury danych do osadzania kontekstu w obiektach JSON. Główną ideą jest traktowanie struktury danych jako "szablonu" i przekształcenie jej, używając innej struktury danych jako kontekstu, w celu wytworzenia danych wyjściowych struktura.

9. JSLT

JSLT jest kompletnym językiem zapytań i transformacji dla JSON. Projekt Języka jest inspirowany przez jq, XPath i XQuery.

10. JSONata

JSONata jest lekkim językiem zapytań i transformacji dla danych JSON. Zainspirowany semantyką "ścieżki lokalizacji" XPath 3.1, pozwala wyrażać złożone zapytania w kompaktowy i intuicyjny sposób notacja.

11. JSONPath Plus

Analizuj, przekształcaj i selektywnie wyodrębniaj dane z dokumentów JSON (i obiektów JavaScript). jsonpath-plus rozszerza oryginalną specyfikację, aby dodać kilka dodatkowych operatorów i wyraźnie określa niektóre zachowania, których oryginał nie określił.

12. JSON-transformuje ostatnia Zmiana 1 grudnia 2017

Zapewnia rekurencyjne, dopasowujące wzorce podejście do przekształcania JSON data. Transformacje są definiowane jako zbiór reguł, które pasują do struktury obiektu JSON. Gdy dojdzie do dopasowania, reguła emituje przekształcone dane, opcjonalnie rekurencyjnie przekształcając obiekty potomne.

13. json ostatnia zmiana Jun 23, 2018

Json jest szybkim narzędziem CLI do pracy z JSON. Jest to węzeł jednotematyczny.skrypt js bez zewnętrznych depów (innych niż node.samego js).

14. jsawk Ostatni post Mar 4, 2015

Jsawk jest jak awk, ale dla JSON. Pracujesz z tablicą obiektów JSON odczytanych ze standardowego wejścia, filtrując je za pomocą JavaScript, aby stworzyć tablicę wyników, która jest drukowana na standardowym wyjściu.

15. yate Ostatni Commit Mar 13, 2017

Testy mogą być używane jako docu https://github.com/pasaran/yate/tree/master/tests

16. jsonpath-object-transform ostatnia Zmiana 18 stycznia 2017

Pobiera dane z obiekt za pomocą jsonpath i generuje nowe obiekty na podstawie szablonu.

17. Zszywanie Ostatnia Zmiana Wrz 16, 2013

Stapling jest biblioteką JavaScript, która umożliwia formatowanie XSLT dla obiektów JSON. Zamiast korzystać z silnika szablonów JavaScript i szablonów tekstowych/html, Stapling daje możliwość użycia szablonów XSLT - ładowanych asynchronicznie z Ajaxem, a następnie buforowanych po stronie klienta - do analizy JSON źródła danych.

Specs:

• JsonPointer

Wskaźnik JSON definiuje składnię ciągu znaków do identyfikacji określonej wartości w dokumencie JavaScript Object Notation (JSON).

• JsonPath

Wyrażenia JSONPath zawsze odnoszą się do struktury JSON w taki sam sposób, jak wyrażenia XPath są używane w połączeniu z XML document

• JSPath

JSPath dla JSON jest jak XPath dla XML."

• JSONiq

Głównym źródłem inspiracji dla JSONiq jest XQuery, który do tej pory okazał się udanym i produktywnym językiem zapytań dla częściowo ustrukturyzowanych danych

Spróbuj wstrząs . Jest to biblioteka transformacji JSON do JSON napisana w Javie.

Został stworzony specjalnie dlatego, że nie chcieliśmy grać w grę" JSON -> XML -> XSLT - > XML - > JSON", a użycie szablonu dla dowolnej wystarczająco złożonej transformacji jest niemożliwe do utrzymania.

Jq-lekki i elastyczny procesor wiersza poleceń JSON

Nie jest oparty na szablonach jak XSLT, ale bardziej zwięzły. np. aby wyodrębnić pola name i address do tablicy: [.name, .address]

Tutorial przedstawia przykład przekształcania interfejsu JSON API Twittera (a instrukcja ma wiele przykładów).

XSLT obsługuje JSON jak widać na http://www.w3.org/TR/xslt-30/#json

XML używa nawiasów kątowych dla ograniczników, JSON używa nawiasów kwadratowych,... Mniej porównań rozpoznawania tokenów w XML oznacza, że jest zoptymalizowany pod kątem transformacji deklaratywnej, podczas gdy więcej porównań, jest jak polecenie switch, ze względu na szybkość, zakłada spekulatywne przewidywanie gałęzi, do których potrzebny jest imperatywny kod w językach skryptowych. W konsekwencji, dla różnych mieszanek dane półstrukturalne, możesz porównać wydajność silników XSLT i javascript jako część stron responsywnych. W przypadku nieistotnego ładunku danych transformacje mogą działać równie dobrze z JSON bez serializacji XML. Decyzja W3 powinna opierać się na lepszej analizie.

Ostatnio znalazłem narzędzie, które uwielbiam do stylizacji JSON: https://github.com/twigkit/tempo . bardzo proste narzędzie w użyciu - moim zdaniem jest dużo łatwiejsze w obsłudze niż XSLT-nie ma potrzeby zadawania zapytań XPATH.

Spójrz na jsonpath-object-transform

Ostatnio napisałem własną małą bibliotekę wokół tego, która stara się pozostać jak najbliżej

5.1 model przetwarzania (XSLT REC) https://www.w3.org/TR/xslt#section-Processing-Model

Jak to możliwe (jak i tak mogłem), w kilku linijkach kodu JavaScript.

Oto kilka nie do końca trywialnych przykładów użycia...

1. JSON-to-some-markup:

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

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

Gdzie to:

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

... daje:

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

I

2. JSON-to-JSON:

Https://jsfiddle.net/YSharpLanguage/ppfmmu15/10

Gdzie to:

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

... daje:

{
    "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:

Odpowiednik JavaScript...

XSLT 3.0 Rec sekcja 14.4 przykład: grupowanie węzłów na podstawie wspólnych wartości

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

Gdzie...

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

... daje:

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

Odpowiednik JavaScript...

Sekcja Przypadków Użycia JSONiq 1.1.2. Grupowanie zapytań dla JSON

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

Gdzie...

/*
  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()

... daje:

[
  {
    "CA": [
      {
        "clothes": [
          {
            "socks": 510
          }
        ]
      },
      {
        "kitchen": [
          {
            "broiler": 20
          },
          {
            "toaster": 150
          }
        ]
      }
    ]
  },
  {
    "MA": [
      {
        "clothes": [
          {
            "shirt": 10
          }
        ]
      },
      {
        "kitchen": [
          {
            "blender": 250
          },
          {
            "toaster": 50
          }
        ]
      }
    ]
  }
]

Jest to również przydatne do przezwyciężenia ograniczeń jsonpath wrt. pytanie przeciw osi przodka, jak podniesione przez to pytanie (i na pewno inne).

Np. jak uzyskać zniżka na produkt spożywczy znając jego ID marki, w

{
 "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"
     }
 ]
}

?

Możliwe rozwiązanie to:

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

... co daje:

Discount of #983: 20

'HTH,

Powiedzieć, że brak narzędzi sugeruje brak potrzeby, to tylko pytanie. To samo można by zastosować do obsługi X lub Y w Linuksie (po co trudzić się tworzeniem wysokiej jakości sterowników i/lub gier dla tak mniejszościowego systemu operacyjnego? I po co zwracać uwagę na system operacyjny, do którego nie rozwijają się wielkie firmy zajmujące się grami i sprzętem?). Prawdopodobnie ludzie, którzy musieliby używać XSLT i JSON, używają nieco trywialnego obejścia: przekształcania JSON w XML. Ale to nie jest optymalne rozwiązanie, prawda?

Kiedy masz natywny format JSON i chcesz go edytować "wysywyg" w przeglądarce, XSLT byłby bardziej niż odpowiednim rozwiązaniem problemu. Robienie tego za pomocą tradycyjnego programowania javascript może stać się wrzodem na dupie.

W rzeczywistości zaimplementowałem podejście" epoki kamienia " do XSLT, używając parsowania podłańcuchów do interpretacji niektórych podstawowych poleceń dla javascript, takich jak wywołanie szablonu, dzieci procesów itp. Z pewnością zaimplementowanie silnika transformacji za pomocą obiektu JSON jest znacznie łatwiejsze niż implementacja pełnowartościowego parsera XML do analizy XSLT. Problem polega na tym, że aby użyć szablonów XML do przekształcenia obiektu JSON, musisz przeanalizować XML szablonów.

Aby przekształcić obiekt JSON za pomocą XML (lub HTML, lub tekstu lub czegokolwiek), musisz dokładnie przemyśleć składnię i znaki specjalne, których potrzebujesz, aby zidentyfikować polecenia transformacji. W przeciwnym razie będziesz musiał zaprojektować parser dla własnego języka szablonów. Przeszedłszy tą ścieżką, Mogę ci powiedzieć, że to nie jest ładne.

Update (Nov 12, 2010): po kilku tygodniach pracy nad moim parserem, udało mi się go zoptymalizować. Szablony są wcześniej przetwarzane, A polecenia są przechowywane jako obiekty JSON. Reguły transformacji są również obiektami JSON, podczas gdy kod szablonu jest mieszanką HTML i składni homebrew podobnej do kodu powłoki. Udało mi się przekształcić złożony dokument JSON w HTML, aby stworzyć edytor dokumentów. Kod jest około 1K linii dla edytora (jest to dla prywatny projekt, więc nie mogę go udostępnić) i około 990 linii kodu transformacji JSON (zawiera polecenia iteracji, proste porównania, wywołanie szablonu, zapisywanie zmiennych i ewaluacja). Planuję wydać go na licencji MIT. Wyślij mi maila, jeśli chcesz się zaangażować.

Jako kolejna nowa odpowiedź na Stare pytanie, proponuję spojrzeć na DefiantJS . To nie jest odpowiednik XSLT dla JSON, to na XSLT dla JSON. Sekcja "Szablony" dokumentacji zawiera ten przykład:

<!-- 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>

Teraz jest! Niedawno stworzyłem bibliotekę json-transforms , dokładnie w tym celu:

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

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 }
  ]
};

Oto transformacja:

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

Które wyprowadzają po:

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

Byłem naprawdę zmęczony ogromną ilością szablonów JavaScript tam, i wszystkie ich wbudowane szablony HTML, różne style znaczników, itp., i postanowił zbudować małą bibliotekę , która umożliwia formatowanie XSLT dla struktur danych JSON. W żadnym wypadku nie jest to tylko JSON parsowany do XML, a następnie sformatowany dokumentem XSLT. Jest też szybki, nie tak szybki jak silniki szablonów JavaScript w Chrome, ale w większości innych przeglądarek jest co najmniej tak szybki jak JS alternatywa silnika dla większych struktur danych.

Używam trasy wielbłąda umarshal (xmljson) -> to(XLST) - > marshal(xmljson). Wystarczająco wydajny (choć nie w 100% idealny), ale prosty, jeśli już używasz Camel.

JSONiq jest takim standardem, a Zorba implementacją c++ o otwartym kodzie źródłowym. JSONiq może być również postrzegany jako XQuery z dodaniem JSON jako natywnego typu danych.

Jest bardzo możliwe, aby przekonwertować JSON za pomocą XSLT: potrzebujesz json2sax deserializer i sax2json serializer.

Przykładowy kod w Javie: http://www.gerixsoft.com/blog/json/xslt4json

Yate ( https://github.com/pasaran/yate) jest specjalnie zaprojektowany po XSLT, posiada JPath( naturalny odpowiednik XPath dla JS), kompiluje się do JavaScript i ma długą historię zastosowań produkcyjnych. To praktycznie nieudokumentowane, ale czytanie próbek i testów powinno wystarczyć.

Jslt jest bardzo zbliżony do JSON odpowiednik XSLT. Jest to język transformacji, w którym zapisujesz stałą część wyjścia w składni JSON, a następnie wstawiasz wyrażenia, aby obliczyć wartości, które chcesz wstawić do szablonu.

Przykład:

{
  "time": round(parse-time(.published, "yyyy-MM-dd'T'HH:mm:ssX") * 1000),
  "device_manufacturer": .device.manufacturer,
  "device_model": .device.model,
  "language": .device.acceptLanguage
}

Jest zaimplementowany w Javie na szczycie Jacksona.

Dlaczego nie przekonwertujesz JSON na XML używając Mr. Data Coverter, przetransformuj go używając XSLT, a następnie zmień go z powrotem na JSON używając tego samego.

Aby uzyskać roboczy bazodel/dowód koncepcji podejścia do wykorzystania czystego JavaScript wraz ze znanym i deklaratywnym wzorcem za pasującymi wyrażeniami XSLT i rekurencyjnymi szablonami, zobacz https://gist.github.com/brettz9/0e661b3093764f496e36

(podobne podejście można zastosować w przypadku JSON.)

Zauważ, że demo opiera się również na zamknięciach wyrażeń JavaScript 1.8 Dla wygody w wyrażaniu szablonów w Firefoksie (przynajmniej do krótkiej formy ES6 dla metod mogą być realizowane).

Zastrzeżenie: to jest mój własny kod.

Napisałem Adapter dom dla mojego frameworka przetwarzania JSON opartego na Jacksonie dawno temu. Używa nu.biblioteka xom. Wynikowe drzewo dom współpracuje z funkcjami java XPath i xslt. Dokonałem pewnych wyborów implementacyjnych, które są dość proste. Na przykład węzeł główny jest zawsze nazywany "root", tablice trafiają do węzła ol z podelementami li (jak w html), a Wszystko inne jest tylko węzłem podrzędnym z prymitywną wartością lub innym obiektem węzeł.

JsonXmlConverter.java

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

Nie podano jeszcze jednego podejścia do użycia generatora parserów do utworzenia parsera w XSLT, który parsuje JSON i wytwarza wyjście XML.

Jedną z opcji, która jest często wymieniana na konferencjach XML, jest generator parserów ReX ( http://www.bottlecaps.de/rex / ) - mimo że na stronie są całkowicie nieudokumentowane, przepisy są dostępne w wyszukiwarce.

Możliwe jest użycie XSLT z JSON. Verson 3 z XPath(3.1) XSLT(3.0) i XQuery (3.1) obsługuje JSON w pewien sposób. Wydaje się, że jest on dostępny w komercyjnej wersji Saxona i może być w pewnym momencie włączony do wersji HE. https://www.saxonica.com/html/documentation/functions/fn/parse-json.html

-

Czego oczekuję od alternatywnego rozwiązania:

Chciałbym móc wprowadzić JSON, aby pobrać pasujący zestaw danych i wyjście JSON lub tekst.

Dostęp do dowolnych właściwości i ewaluacja wartości

Obsługa logiki warunkowej

Chciałbym, aby Skrypty transformacji były zewnętrzne od narzędzia, oparte na tekście, a najlepiej na powszechnie używanym języku.

Potencjalna alternatywa?

Zastanawiam się, czy SQL może być odpowiednią alternatywą. https://docs.microsoft.com/en-us/sql/relational-databases/json/json-data-sql-server

Byłoby miło, gdyby alternatywne narzędzie może obsługiwać JSON i XML https://docs.microsoft.com/en-us/sql/relational-databases/xml/openxml-sql-server

Nie próbowałem jeszcze przekonwertować skryptów XSLT, których używam do SQL, lub w pełni oceniłem tę opcję, ale mam nadzieję, że wkrótce przyjrzę się jej bardziej. Na razie tylko kilka myśli.

Nie jestem pewien, czy jest to potrzebne, a dla mnie brak narzędzi sugeruje brak potrzeby. JSON jest najlepiej przetwarzany jako obiekty (tak jak i w JS), a do transformacji zazwyczaj używa się języka samych obiektów (Java dla obiektów Java utworzonych z JSON, to samo dla Perla, Pythona, Perla, c#, PHP itd.). Tylko z normalnymi zadaniami( lub set, get), zapętlaniem i tak dalej.

Chodzi mi o to, że XSLT jest po prostu innym językiem, a jednym z powodów, dla których jest potrzebny, jest to, że XML nie jest obiektem notacja, a więc obiekty języków programowania nie są dokładnymi dopasowaniami (impedancja między hierarchicznym modelem xml a obiektami/strukturami).