質問

ありますか？ XSLT JSONと同等ですか？XSLT が XML に対して行うのと同じように、JSON に対して変換を実行できるようにするものです。

役に立ちましたか？

解決

興味深いアイデア。 Googleで検索すると、次のような興味深いページがいくつか見つかりました。

これがお役に立てば幸いです。

他のヒント

試す 衝撃. 。これは、Java で書かれた JSON から JSON への変換ライブラリです。

これは、「JSON -> XML -> XSLT -> XML -> JSON」というゲームをしたくなかったために特別に作成されたものであり、十分に複雑な変換にテンプレートを使用するのは保守不可能です。

JSONに相当するXSLT-候補のリスト（ツールと仕様）

ツール

  1. XSLT

    fn：json-to-xml 。

      

    このセクションでは、XSLTを使用してJSONデータを処理できる機能について説明します。

  2. jq
      

    jqはJSONデータのsedに似ています-sed、awk、grep、friendsがテキストで遊ぶのと同じように簡単に構造化データをスライス、フィルター、マッピング、変換できます。   OSごとにインストールパッケージがあります。

  3. jj
      

    JJは、JSONドキュメントから値を取得または更新するための高速で簡単な方法を提供するコマンドラインユーティリティです。これは、GJSONとSJSONによって内部で動作します。

  4. fx
      

    コマンドラインJSON処理ツール

         
        
    • 新しい構文を学ぶ必要はありません
      •   
    • プレーンJavaScript
      •   
    • フォーマットと強調表示
      •   
    • スタンドアロンバイナリ
      •   
  5. jl
      

    jl（＆quot; JSON lambda＆quot;）は、JSONをクエリおよび操作するための小さな関数型言語です。

  6. JOLT
      

    「仕様」がJavaで記述されたJSONからJSONへの変換ライブラリトランスフォーム自体はJSONドキュメントです。

  7. gron
      

    JSONをgreppableにします！   gronはJSONを個別の割り当てに変換して、必要なものをgrepし、その絶対パスを確認しやすくします。 JSONの大きな塊を返すが、ひどいドキュメントがあるAPIの探索を容易にします。

  8. json
      

    jsonは、JSONを操作するための高速CLIツールです。これは、単一のファイルnode.jsスクリプトであり、外部の依存関係はありません（node.js自体を除く）。

  9. json-e
      

    JSON-eは、JSONオブジェクトにコンテキストを埋め込むためのデータ構造パラメーター化システムです。   中心的なアイデアは、データ構造を「テンプレート」として扱うことです。コンテキストとして別のデータ構造を使用して変換し、出力データ構造を生成します。

  10. JSLT
      

    JSLTは、JSONの完全なクエリおよび変換言語です。言語設計は、jq、XPath、およびXQueryに触発されています。

  11. json-transforms 最終コミット2017年12月1日
      

    JSONデータを変換するための再帰的なパターンマッチングアプローチを提供します。変換は、JSONオブジェクトの構造に一致する一連のルールとして定義されます。一致が発生すると、ルールは変換されたデータを出力し、オプションで子オブジェクトを変換するために再帰します。

  12. jsawk 最終コミット2015年3月4日
      

    Jsawk

XSLTは、 http://www.w3.org/TRにあるJSONをサポートしています。 / xslt-30 /＃json

XMLは区切りトークンに角括弧を使用し、JSONは中括弧、角括弧を使用します。 XMLのトークン認識比較が少ないということは、宣言変換に最適化されていることを意味しますが、switch文のように、速度上の理由から、スクリプト言語の命令型コードが役立つ投機的な分岐予測を想定している比較が多いことを意味します。直接的な結果として、半構造化データのさまざまな組み合わせに対して、レスポンシブページの一部としてXSLTおよびjavascriptエンジンのパフォーマンスをベンチマークすることができます。無視できるデータペイロードの場合、XMLシリアル化なしのJSONでも変換は同様に機能する可能性があります。 W3の決定は、より良い分析に基づくべきです。

最近、JSONのスタイリングに気に入っているツールを見つけました： https://github.com/twigkit/tempo 。非常に使いやすいツール-私の意見では、XSLTよりも作業がはるかに簡単です-XPATHクエリは不要です。

jq-軽量で柔軟なコマンドラインJSONプロセッサ

XSLTのようなテンプレートベースではありませんが、より簡潔です。例えば name および address フィールドを配列に抽出するには： [。name、.address]

チュートリアルでは、TwitterのJSON APIを変換する例（およびマニュアルには多くの例があります。

jsonpath-object-transform

をご覧ください

ツールの欠如が必要性の欠如を示唆していると言うことは、ただ質問を懇願することです。 LinuxでのXまたはYのサポートにも同じことが当てはまります（なぜ少数のOS向けに高品質のドライバーやゲームを開発する必要があるのでしょうか？また、大手ゲーム会社やハードウェア会社が開発していないOSに注意を払うのはなぜですか？）おそらく、XSLTとJSONを使用する必要がある人々は、やや些細な回避策を使用することになります。JSONをXMLに変換することです。しかし、それは最適なソリューションではありませんか？

ネイティブJSON形式があり、それを編集する場合＆quot; wysywyg＆quot;ブラウザでは、XSLTは問題を解決するのに十分なソリューションです。従来のjavascriptプログラミングでこれを行うと、苦痛になります。

実際、「石器時代」を実装しました。 XSLTへのアプローチ。部分文字列解析を使用して、テンプレートの呼び出し、子プロセスなど、javascriptの基本的なコマンドを解釈します。問題は、XMLテンプレートを使用してJSONオブジェクトを変換するには、テンプレートのXMLを解析する必要があることです。

JSONオブジェクトをXML（またはHTML、またはテキストなど）で変換するには、構文と変換コマンドを識別するために使用する必要がある特殊文字について慎重に検討する必要があります。そうしないと、独自のカスタムテンプレート言語用のパーサーを設計することになります。その道を歩いて、私はそれがきれいではないと言うことができます。

更新（2010年11月12日）：パーサーで数週間作業した後、最適化することができました。テンプレートは事前に解析され、コマンドはJSONオブジェクトとして保存されます。変換ルールもJSONオブジェクトですが、テンプレートコードはHTMLとシェルコードに似た自作の構文を組み合わせたものです。複雑なJSONドキュメントをHTMLに変換して、ドキュメントエディターを作成することができました。コードはエディターでは約1K行（共有プロジェクトではないため共有できません）、JSON変換コードでは約990行（反復コマンド、単純な比較、テンプレートの呼び出し、変数の保存と評価を含む）です。 MITライセンスでリリースする予定です。参加したい場合は私にメールを送ってください。

最近、これについて独自の小さなライブラリを作成しました。

5.1処理モデル（XSLT REC） https://www.w3.org/TR/xslt#section-Processing-Model

可能な限り（とにかく）、JavaScriptコードの数行で。

これは、完全ではないが自明な使用例です。

1。 JSON-to-some-markup：

フィドル： https://jsfiddle.net/YSharpLanguage/kj9pk8oz/10

（ D.1ドキュメントの例（XSLT REC）に触発された https://www.w3.org/TR/xslt#section-Document-Example ）

ここ：

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

...与えるもの：

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

and

2。 JSON-to-JSON：

フィドル： https://jsfiddle.net/YSharpLanguage/ppfmmu15/10

ここ：

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

...与えるもの：

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

3。 XSLTとJavaScript：

同等のJavaScript ...

XSLT 3.0 RECセクション14.4例：共通値に基づいてノードをグループ化する

（at： http://jsfiddle.net/YSharpLanguage/8bqcd0ey/1 ）

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

where ... 

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

...与えるもの：

<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とJavaScript：

同等のJavaScript ...

JSONiqユースケースセクション1.1.2。 JSONのクエリのグループ化

（at： https://jsfiddle.net/YSharpLanguage/hvo24hmk/3 ）

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

where ... 

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

...与えるもの：

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

JSONPath wrtの制限を克服することも役立ちます。 このSO質問で発生した、祖先軸に対するクエリ（そして確かにその他）。

たとえば、ブランドIDを知っている食料品の割引を取得する方法、

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

？

可能な解決策は次のとおりです。

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

...これは以下を与えます：

Discount of #983: 20

'HTH、

今があります！この目的のために、 json-transforms というライブラリを最近作成しました：

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

JSPath 、XPathでモデル化されたDSL、および再帰的なパターンマッチングアプローチの組み合わせを使用し、 XSLTから直接インスパイアされました。

簡単な例を示します。次の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 }
  ]
};

これは変換です：

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

次を出力します：

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

この変換は、3つのルールで構成されています。最初のコードは、ホンダ製のすべての自動車に一致し、 Honda プロパティを持つオブジェクトを出力してから、再帰的に一致します。 2番目のルールは、 maker プロパティを持つオブジェクトと一致し、 model および year プロパティを出力します。最後は、再帰的に一致するID変換です。

古い質問に対するさらに別の新しい答えとして、 DefiantJS をご覧になることをお勧めします。 JSONのXSLTではありませんが、 JSONのXSLTです。 「テンプレート」ドキュメントのセクションには次の例が含まれています。

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

膨大な量のJavaScriptテンプレートエンジン、およびすべてのインラインHTMLテンプレート、さまざまなマークアップスタイルなどに本当にうんざりしており、小さなライブラリを作成して、JSONデータ構造のXSLTフォーマットを有効にします。決してロケット科学ではありません。XMLに解析され、XSLTドキュメントでフォーマットされたJSONです。これも高速で、ChromeのJavaScriptテンプレートエンジンほど高速ではありませんが、他のほとんどのブラウザーでは、少なくとも大規模なデータ構造用のJSエンジンの代替と同じくらい高速です。

JSONiq はそのような標準であり、 Zorba はオープンソースのC ++実装です。 JSONiqは、ネイティブデータ型としてJSONを追加したXQueryとも見なすことができます。

キャメルルートunmarshal（xml json）を使用しています-＆gt; to（xslt）-＆gt; marshal（xmljson）。十分に効率的ですが（100％完全ではありませんが）、すでにCamelを使用している場合は簡単です。

XSLTを使用してJSONを変換することは非常に可能です。JSON2SAXデシリアライザーとSAX2JSONシリアライザーが必要です。

Javaのサンプルコード： http://www.gerixsoft.com/blog/json/xslt4json

Yate（ https://github.com/pasaran/yate ）は、XSLTの後に特別に設計されています、JPath（JSに相当する自然なXPath）を備え、JavaScriptにコンパイルされ、実稼働での使用のかなりの歴史を持っています。実際には文書化されていませんが、サンプルやテストを読むだけで十分です。

JSLT は、XSLTに相当するJSONに非常に近いものです。これは、JSON構文で出力の固定部分を記述し、式を挿入してテンプレートに挿入する値を計算する変換言語です。

例：

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

ジャクソンの上にJavaで実装されています。

これが必要かどうかはあまりわかりませんが、ツールが不足していることは必要性がないことを示唆しています。 JSONはオブジェクトとして処理するのが最適です（とにかくJSで行われる方法です）、通常はオブジェクト自体の言語を使用して変換を行います（JSONから作成されたJavaオブジェクトのJava、Perl、Python、Perl、c＃、PHPなどでも同じです）に）。通常の割り当て（または設定、取得）、ループなどで。

つまり、XSLTは単なる別の言語であり、XMLがオブジェクト表記ではないため、プログラミング言語のオブジェクトは完全に適合しない（階層型xmlモデルとオブジェクト/構造体の間のインピーダンス）ためです。 p>

氏を使用してJSONをXMLに変換しないのはなぜですか。 Data Coverter 、XSLTを使用して変換し、同じものを使用してJSONに戻します。

XSLTの一致表現と再帰テンプレートの背後にある馴染みのある宣言型パターンとともに純粋なJavaScriptを利用するためのDoodle / Proof of Conceptの作業については、 https://gist.github.com/brettz9/0e661b3093764f496e36

（JSONについても同様のアプローチが取られる可能性があります。）

デモは、Firefoxでテンプレートを表現するのに便利なJavaScript 1.8の式クロージャーにも依存していることに注意してください（少なくともメソッドのES6ショートフォームが実装されるまで）。

免責事項：これは私自身のコードです。

ずっと前に、Jacksonベースのjson処理フレームワーク用のdomアダプターを書きました。 nu.xomライブラリを使用します。結果のdomツリーは、java xpathおよびxslt機能で動作します。私は実装をかなり簡単に選択しました。たとえば、ルートノードは常に＆quot; root＆quot;と呼ばれ、配列は（htmlなどの）liサブ要素を持つolノードに入り、その他はすべてプリミティブ値または別のオブジェクトノードを持つサブノードになります。

JsonXmlConverter .java

使用法： <コード> JsonObject sampleJson = sampleJson（）;         org.w3c.dom.Document domNode = JsonXmlConverter.getW3cDocument（sampleJson、＆quot; root＆quot;）;

まだ提供されていないアプローチの1つは、パーサージェネレーターを使用して、JSONを解析してXML出力を生成するXSLTでパーサーを作成することです。

XML会議で多くの言及があったオプションの1つに、ReXパーサージェネレーター（ http：// www .bottlecaps.de / rex / ）-サイトには完全に文書化されていませんが、検索でレシピを入手できます。

JSONでXSLTを使用できる場合があります。 XPath（3.1）XSLT（3.0）およびXQuery（3.1）のVerson 3は、何らかの方法でJSONをサポートしています。 これは商用版のSaxonで利用できるようで、ある時点でHEバージョンに含まれる可能性があります。 https://www.saxonica.com/html/documentation/ functions / fn / parse-json.html

-

代替ソリューションに期待すること：

JSONを入力して一致するデータのセットを取得し、JSONまたはTEXTを出力できるようにしたいです。

任意のプロパティにアクセスして値を評価する

条件付きロジックのサポート

変換スクリプトはツールの外部にあり、テキストベースであり、できれば一般的に使用される言語である必要があります。

潜在的な代替手段

SQLが適切な代替手段になるのではないかと思います。 https://docs.microsoft。 com / en-us / sql / relational-databases / json / json-data-sql-server

代替ツールがJSONとXMLを処理できたらいいと思います https://docs.microsoft.com/ en-us / sql / relational-databases / xml / openxml-sql-server

使用しているXSLTスクリプトをまだSQLに変換しようとしていないか、このオプションを完全に評価していませんが、すぐに調べたいと思っています。これまでのところ、いくつかの考えがあります。

JSON-e にはNode.js、Python、Goの実装があります。

ライセンス： CC-BY-SA と 帰属
所属していません StackOverflow
scroll top