XSLT Äquivalent für JSON

https://stackoverflow.com/questions/1618038

06-07-2019
|

Frage

Gibt es eine XSLT Äquivalent für JSON? Etwas mir zu erlauben, Transformationen auf JSON zu tun, wie XSLT tut, um XML.

Lösung

Interessante Idee. Einige Suche auf Google produziert ein paar Seiten von Interesse, einschließlich:

, wie ein solches "jsonT" Werkzeug könnte implementiert werden, umreißen, und einige Downloads
Diskussion dieser Implementierung
ein Unternehmen, das etwas umgesetzt haben geeignet

Hope, das hilft.

Andere Tipps

Versuchen Sie JOLT . Es ist eine JSON JSON geschrieben Transformation Bibliothek in Java.

Es wurde speziell geschaffen, weil wir nicht das „JSON -> XML -> XSLT -> XML -> JSON“ spielen wollten. Spiel, und mit einer Vorlage für jeden hinreichend komplexe Transformation wartbaren

XSLT-Äquivalente für JSON - eine Liste von Kandidaten (Werkzeuge und Spezifikationen)

Werkzeuge

XSLT
Sie können mit XSLT für JSON mit dem Ziel, fn: json-to-xml .

Dieser Abschnitt beschreibt Einrichtungen JSON-Daten ermöglicht XSLT verarbeitet werden.
jq

JQ ist wie sed für JSON-Daten - Sie können es verwenden, in Scheiben schneiden und Filter und Karte und strukturierte Daten mit der gleichen Leichtigkeit zu verwandeln, sed, awk, grep und Freunde können Sie mit Text spielen. Es gibt Installieren von Paketen für verschiedene OS.
jj

JJ ist ein Kommandozeilenprogramm, das eine schnelle und einfache Möglichkeit bietet, Dokumente abzurufen oder zu aktualisieren Werte von JSON. Es wird angetrieben durch GJSON und SJSON unter der Haube.
fx
Die Kommandozeilen JSON Bearbeitungswerkzeug
- Sie brauchen nicht neue Syntax
- Plain JavaScript
- Formatierung und Hervorhebung
- Standalone binäre
jl

jl ( "JSON Lambda") ist eine kleine funktionale Sprache für die Abfrage und JSON zu manipulieren.
JOLT

JSON JSON Transformation Bibliothek in Java geschrieben, wo die "Spezifikation" für die Transformation ist selbst ein JSON-Dokument.
gron

Machen Sie JSON greppable! Gron verwandelt JSON in einzelne Aufgaben zu erleichtern, für grep, was Sie wollen und den absoluten ‚Pfad‘, um es sehen. Es erleichtert die Erforschung von APIs, die große Blobs von JSON zurück, sondern haben schreckliche Dokumentation.
json

json ist ein schnelles CLI-Tool für mit JSON zu arbeiten. Es ist ein Single-File-Skript ohne externe deps (außer node.js selbst) node.js.
json-e

JSON-e ist eine Datenstruktur Parametriersystem für Kontextobjekte in JSON einbetten. Die zentrale Idee ist es, eine Datenstruktur als „Vorlage“ zu behandeln und zu transformieren, eine andere Datenstruktur als Kontext verwendet wird, eine Ausgangsdatenstruktur zu erzeugen.
JSLT

JSLT ist eine komplette Abfrage und Transformationssprache für JSON. Die Sprache Design ist inspiriert von jq, XPath und XQuery.
json-transformiert Commit Letzte 1. Dezember 2017

Stellt eine rekursive, Pattern-Matching-Ansatz JSON-Daten zu transformieren. Transformationen werden als ein Satz von Regeln definiert, die die Struktur eines JSON Objekt anzupassen. Wenn eine Übereinstimmung gefunden wird, gibt die Regel, die die transformierten Daten, gegebenenfalls untergeordnete Objekte zu verwandeln Rekursion.
jsawk begehen Last 4. März 2015

Jsawk ist wie awk, aber für JSON. Siearbeiten mit einer Reihe von JSON-Objekte von stdin lesen, filtern sie JavaScript mit einem Ergebnis-Reihe zu erzeugen, die auf die Standardausgabe gedruckt wird.
yate Letzte Commit 13. März 2017

Die Tests können als Doku https://github.com/pasaran/yate/ verwendet werden Baum / Master / Tests
jsonpath-Objekt-trans Zuletzt Jan Commit 18 2017

Pulls Daten von einem Objektliteral JSONPath verwenden und eine neue Objekte basierend auf einer Vorlage erzeugen.
Heftung Commit Last 16, September 2013

Heftung ist eine JavaScript-Bibliothek, die XSLT-Formatierung für JSON-Objekte ermöglicht. Statt einen JavaScript-Template-Engine verwenden und text / html Vorlagen, Heftung gibt Ihnen die Möglichkeit XSLT-Vorlagen zu verwenden - asynchron mit Ajax geladen und dann Client-Seite im Cache - Ihre JSON-Datenquellen zu analysieren.

Specs:

JsonPointer

JSON Pointer definiert eine Zeichenfolge Syntax für einen bestimmten Wert zu identifizieren innerhalb einer JavaScript Object Notation (JSON) Dokument.
JsonPath

JSONPath Ausdrücke auf eine JSON-Struktur in der gleichen Weise wie XPath-Ausdruck beziehen sich immer in Kombination mit einem XML-Dokument verwendet werden
JSPath

JSPath für JSON ist wie XPath für XML. "
JSONiq

Die Hauptquelle der Inspiration hinter JSONiq ist XQuery, die bisher eine erfolgreiche und produktive Abfragesprache für semi-strukturierte Daten erwiesenermaßen

XSLT unterstützt JSON wie gesehen unter http://www.w3.org/TR / xslt-30 / # json

XML eckige Klammern für Begrenzer-Token verwendet, verwendet JSON Klammern, eckige Klammern, ... I. e. XML ist weniger Token Erkennungsvergleiche bedeutet es für deklarative Transformation optimiert ist, während mehr Vergleiche, wobei wie switch-Anweisung, aus Geschwindigkeitsgründen spekulative Verzweigungsvorhersage davon aus, dass zwingend Code in Skriptsprachen ist geeignet. Als direkte Folge für verschiedene Mischungen von semi-strukturierten Daten, können Sie Benchmarks für XSLT wollen und JavaScript-Performance Motoren als Teil ansprechender Seiten. Für vernachlässigbare Datennutzlast, Transformationen könnten genauso gut mit JSON ohne XML-Serialisierung arbeiten. W3 Entscheidung sollte auf einer besseren Analyse werden.

Vor kurzem fand ich ein Tool, das ich für das Styling JSON lieben: https://github.com/twigkit/tempo . Sehr bedienungsfreundliches Werkzeug, - meiner Meinung nach, ist es viel einfacher ist als mit XSLT zu arbeiten -. Keine Notwendigkeit für XPath-Abfragen

jq - leichte und flexible Befehlszeilen JSON Prozessor

Es ist nicht Template-basiert wie XSLT, aber prägnanter. z.B. zu extrahieren name und address Felder in ein Array: [.name, .address]

Die Tutorial geht durch ein Beispiel für Twitters JSON API Transformation (und die Handbuch viele Beispiele hat).

Hier finden Sie aktuelle jsonpath-Objekt-Transformation

Zu sagen, Mangel an Tool Mangel an Bedarf nur vorschlagen, die Frage ist Betteln. Das gleiche könnte angewendet werden, für X oder Y in Linux (Warum stören die Entwicklung von Qualitäts Fahrer und / oder Spiele für eine solche Minderheit OS? Und warum achten Sie auf ein Betriebssystem, das große Spiel und Hardware-Unternehmen entwickeln sich nicht für?) Zu unterstützen. Wahrscheinlich sind die Leute, die brauchen würde XSLT verwenden und JSON am Ende mit einer etwas trivial Abhilfe: Transforming JSON in XML. Aber das ist nicht die optimale Lösung, oder?

Wenn Sie ein native JSON-Format haben und Sie wollen es „wysywyg“ im Browser bearbeiten, XSLT wäre eine mehr als adäquate Lösung für das Problem sein. dass mit traditioneller Javascript-Programmierung tut ein Schmerz im Arsch werden kann.

In der Tat, ich habe einen „Steinzeit“ -Ansatz, um XSLT implementiert, Teilzeichenfolge Parsing mit einigen grundlegenden Befehle für JavaScript zu interpretieren, wie eine Vorlage aufrufen, Prozess Kinder usw. Sicherlich eine Transformations-Engine mit einem JSON-Objekt Implementierung ist viel einfacher als ein vollwertiges XML-Parser Implementierung des XSLT zu analysieren. Das Problem ist, dass XML-Vorlagen zu verwenden, um ein JSON-Objekt zu verwandeln, müssen Sie die XML des Templates analysieren.

Um ein JSON-Objekt mit XML tranform (oder HTML oder Text oder was auch immer) Sie sorgfältig über die Syntax denken müssen und welche Sonderzeichen müssen Sie verwenden, um die Transformation Befehle zu identifizieren. Sonst wirst du einen Parser für Ihre eigene Template-Sprache zu entwerfen, die am Ende. Nachdem durch diesen Weg gehe, kann ich Ihnen sagen, dass es nicht schön ist.

Update (12. November 2010): Nach ein paar Wochen auf meinem Parser arbeiten, ich habe in der Lage gewesen, es zu optimieren. Vorlagen werden im Vorfeld analysiert und Befehle werden als JSON-Objekte gespeichert. Transformationsregeln sind auch Objekte JSON, während der Template-Code eine Mischung aus HTML und eine Homebrew-Syntax ähnliche Code beschießen. Ich habe in der Lage gewesen, ein komplexes JSON-Dokument in HTML zu transformieren, um ein Dokument-Editor zu machen. Der Code ist um 1 K Linien für den Editor (es ist für ein privates Projekt, so kann ich nicht teilen) und rund 990 Linien für den JSON Transformationscode (enthält Iteration Befehle, einfache Vergleiche, schablonen calling, variable Speicherung und Auswertung). Ich plane es unter einer Lizenz MIT freizugeben. Schreiben Sie mir eine E-Mail, wenn Sie sich zu engagieren.

Ich schrieb meine eigene kleine Bibliothek, um dies, vor kurzem, die so nahe zu bleiben versucht,

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

wie möglich ist (wie ich konnte sowieso), in ein paar Zeilen JavaScript-Code.

Hier sind ein paar nicht-ganz-trivialen Anwendungsbeispiele ...

1. JSON-to-some-Markup:

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

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

Dabei gilt folgendes:

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

... gibt:

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

und

2. JSON-to-JSON:

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

Dabei gilt folgendes:

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

... gibt:

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

Ein JavaScript-Äquivalent ...

XSLT 3.0 REC Abschnitt 14.4 Beispiel: Gruppierung von Knoten, basierend auf gemeinsamen Werten

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

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

Dabei gilt ...

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

... gibt:

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

Ein JavaScript-Äquivalent ...

JSONiq Use Cases Abschnitt 1.1.2. Gruppieren von Abfragen für JSON

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

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

Dabei gilt ...

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

... gibt:

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

Es ist auch nützlich, um die Grenzen der JSONPath WRT zu überwinden. Abfragen gegen die Vorfahren Achse, wie von diese Frage SO (und sicherlich andere).

z. B., wie den Rabatt von einem Lebensmitteleinzelteil erhalten seine Marke ID zu wissen, 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"
     }
 ]
}

Eine mögliche Lösung ist:

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

... das gibt:

Discount of #983: 20

"HTH,

Es gibt jetzt! Ich habe vor kurzem eine Bibliothek, json-Transformationen , genau für diesen Zweck:

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

Es verwendet eine Kombination von JSPath , einem DSL auf XPath modelliert, und eine rekursive Pattern-Matching-Ansatz, direkt von XSLT inspiriert.

Hier ist ein kurzes Beispiel. Angesichts der folgenden JSON-Objekt:

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

Hier ist eine Transformation:

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

Welche Ausgabe der folgende:

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

Diese Transformation besteht aus drei Regeln. Die erste entspricht jedes Fahrzeug, das durch Honda gemacht wird, ein Objekt mit einer Honda Eigenschaft emittierende, dann rekursiv entsprechen. Die zweite Regel paßt auf jedes Objekt mit einer maker Eigenschaft, die model und year Eigenschaften ausgeben. Das Finale wird die Identität Transformation, die rekursiv übereinstimmt.

Als noch eine weitere neue Antwort auf eine alte Frage, würde ich vorschlagen, einen Blick auf DefiantJS . Es ist nicht eine XSLT Äquivalent für JSON, es ist XSLT für JSON. Der „Templating“ Abschnitt der Dokumentation enthält dieses Beispiel:

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

Ich war von der enormen Menge von JavaScript Templating Engines da draußen wirklich müde, und alle ihre Inline-HTML-Vorlagen, verschiedene Markup-Arten, etc., und beschlossen,

JSONiq ist ein solcher Standard und Zorbas eine Open-Source-C ++ Implementierung. JSONiq kann auch mit dem Hinzufügen von JSON als native Datentyp gesehen als XQuery wird.

Ich bin mit Camel Route Abstellungs (xml json) -> bis (XSLT) -> Marschall (xmljson). Effizient genug (wenn auch nicht 100% perfekt), aber einfach, wenn Sie bereits mit Kamel.

es sehr gut möglich ist JSON zu konvertieren XSLT verwenden. Sie JSON2SAX Deserializer und SAX2JSON Serializer benötigen

Beispielcode in Java: http://www.gerixsoft.com/blog/json/xslt4json

Yate ( https://github.com/pasaran/yate ) ist speziell nach XSLT entworfen bietet JPath (eine natürliche XPath Äquivalent für JS), kompiliert JavaScript und hat eine ganze Geschichte der Produktion Verwendung. Es ist praktisch nicht dokumentiert, aber das Lesen durch Proben und Tests sollte genug sein.

JSLT ist sehr nah an einem JSON-Äquivalent von XSLT. Es ist eine Transformationssprache, wo Sie den festen Teil der Ausgabe in JSON-Syntax schreiben, dann Ausdrücke legen Sie die Werte, die Sie in der Vorlage eingefügt werden sollen berechnen.

Ein Beispiel:

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

Es ist in Java auf der Jackson umgesetzt werden.

Nicht zu sicher, dass es diese Notwendigkeit, und mir Mangel an Werkzeugen schlägt Mangel an Bedarf. JSON ist am besten als Objekte verarbeitet werden (die Art und Weise es ohnehin in JS getan hat), und Sie verwenden in der Regel die Sprache der Objekte selbst Transformationen zu tun (Java für Java-Objekte aus JSON erstellt, das gleiche für Perl, Python, Perl, C #, PHP und so auf). Nur mit normalen Zuordnungen (oder Set erhalten), Looping und so weiter.

Ich meine, XSLT ist nur ein andere Sprache, und ein Grund, warum es notwendig ist, ist, dass XML ist kein Objekt Notation und damit Objekte von Programmiersprachen sind nicht exakt passen (Impedanz zwischen hierarchischen XML-Modell und Objekten / structs).

Warum nicht Sie wandelt JSON zu XML Mr. Daten Coverter , tranform es mit Hilfe von XSLT und es dann zu JSON ändern zurück, die diese verwendet.

Ein funktionstüchtiges doodle / Proof of Concept einen Ansatz zusammen mit den bekannten und deklarativen Mustern hinter XSLT die passenden Ausdrücke und rekursive Vorlagen reinen JavaScript zu verwenden, finden Sie unter https://gist.github.com/brettz9/0e661b3093764f496e36

(Ein ähnlicher Ansatz könnte für JSON genommen werden.)

Beachten Sie, dass die Demo beruft sich auch auf JavaScript 1.8 Expression Verschlüsse, die das in Vorlagen in Firefox exprimierenden (zumindest bis die ES6 Kurzform für Methoden implementiert werden kann).

Disclaimer: Dies ist mein eigener Code

Ich schrieb einen dom Adapter für meinen jackson basierend json Verarbeitungsrahmen vor langer Zeit. Es nutzt die nu.xom Bibliothek. Der resultierende DOM-Baum arbeitet mit dem Java-XPath und XSLT-Einrichtungen. Ich habe einige Implementierung Entscheidungen, die ziemlich einfach sind. Zum Beispiel wird der Wurzelknoten immer „root“ genannt, gehen Arrays in einen ol Knoten mit li Teilelemente (wie in html), und alles andere ist nur ein Teilknoten mit einem primitiven Wert oder einem anderen Objekt-Knoten.

JsonXmlConverter .java

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

Ein Ansatz noch nicht gegeben ist, einen Parser-Generator zu verwenden, um einen Parser in XSLT zu schaffen, die JSON analysiert und erzeugt eine XML-Ausgabe.

Eine Option, die eine Menge an den XML-Konferenzen erwähnt wird ist der ReX Parser-Generator ( http: // www .bottlecaps.de / rex / .) - obwohl völlig auf der Seite ohne Papiere, Rezepte sind auf der Suche

Es kann möglich sein XSLT mit JSON zu verwenden. Verson 3 von XPath (3.1) XSLT (3.0) und XQuery (3.1) unterstützt in irgendeiner Weise JSON. Dies scheint in der kommerziellen Version von Saxon zur Verfügung zu stehen, und irgendwann vielleicht in der HE-Version enthalten sein. https://www.saxonica.com/html/documentation/ Funktionen / fn / Parse-json.html

Was würde ich von einer alternativen Lösung erwarten:

Ich mag die Lage Eingang JSON, um einen passenden Satz von Daten und die Ausgabe JSON oder TEXT zu holen.

Zugriff beliebige Eigenschaften und werten die Werte

Unterstützung für bedingte Logik

Ich würde die Transformation Skripte will aus dem Werkzeug außerhalb sein, textbasierte und vorzugsweise eine häufig verwendete Sprache.

Mögliche Alternative?

Ich frage mich, ob SQL eine geeignete Alternative sein könnte. https://docs.microsoft. com / en-us / sQL / relationale Datenbanken / json / json-data-sQL-Server

Es wäre schön, wenn das alternative Tool JSON und XML umgehen kann https://docs.microsoft.com/ en-us / sQL / relationale Datenbanken / xml / openxml-sQL-Server

Ich habe noch nicht versucht, den XSLT-Skripte ich zu SQL verwenden, um zu konvertieren, oder vollständig diese Option noch ausgewertet, aber ich hoffe, bald mehr in sie zu suchen. Nur ein paar Gedanken so weit.

JSON-e hat Implementierungen in Node.js, Python und Go.

Lizenziert unter: CC-BY-SA mit Zuschreibung

Nicht verbunden mit StackOverflow