XSLT等效JSON(XSLT equivalent for JSON)

是否有一个XSLT等效JSON？ 东西让我做JSON的转换像XSLT那样以XML。

Answer 1:

有趣的想法。 在谷歌搜索的一些产生了兴趣，其中包括了几页：

• 一个轮廓的怎么这么“jsonT”工具可能实现， 一些下载
• 一些该实现的讨论
• 该公司可能已经实现了适合的东西

希望这可以帮助。

Answer 2:

尝试JOLT 。 这是一个JSON以JSON转换库用Java编写的。

它的建立特别是因为我们不想打“JSON - > XML - > XSLT - > XML - > JSON”的游戏，并使用模板任何足够复杂的变换是不可维护的。

Answer 3:

XSLT等价物JSON - 候选人（工具和规格）的列表

工具

1. XSLT

   您可以使用XSLT为JSON具有以下目的的FN：JSON到XML 。

   本节介绍设施允许JSON数据使用XSLT处理。

2. JQ

   JQ是像sed的JSON数据 - 你可以用它来切片和过滤器和地图，并与用sed，awk中，grep和朋友让你玩的文字一样简单变换的结构化数据。 此外，不同的操作系统安装软件包。

3. JJ

   JJ是一个命令行工具，它提供了快速和简单的方法来从JSON文件检索或更新值。 它的引擎盖下搭载GJSON和SJSON。

4. FX

   命令行JSON处理工具

   • 不需要学习新的语法
   • 普通的JavaScript
   • 格式化并强调
   • 独立二进制

5. JL

   JL（“JSON拉姆达”）是用于查询和操作JSON一个微小的功能语言。

6. 颠簸

   JSON以Java编写的JSON转换库，其中“规范”的转变本身就是一个JSON文件。

7. GRON

   使JSON greppable！ GRON转换JSON成离散的分配，使其更容易给grep你想要的东西，看到了绝对的“路径”，以它。 它简化了返回JSON的大斑点，但有可怕的API文档的探索。

8. JSON

   JSON是用于JSON的快速CLI工具。 这是一个单文件的Node.js脚本没有外部DEPS（node.js的比本身以外）。

9. JSON-E

   JSON-E是用于JSON对象嵌入上下文数据结构参数化系统。 中心思想是治疗数据结构作为“模板”和变换它，使用另一个数据结构作为上下文，以产生输出数据结构。

10. JSLT

    JSLT是JSON完整的查询和转换语言。 该语言的设计是由JQ，的XPath和XQuery的启发。

11. JSON-变换最后一次提交的2017年12月1日

    提供递归，模式匹配的方法来转化JSON数据。 变换被定义为一组匹配JSON对象的结构，该结构的规则。 当发生匹配时，规则发出变换后的数据，任选地递归变换子对象。

12. jsawk最后提交2015年3月4日

    Jsawk是如awk，但对于JSON。 你与来自标准输入读取JSON对象的数组工作，使用JavaScript，以产生被打印到stdout一个结果阵列筛选。

13. 亚特最后提交2017年3月13日

    测试可作为实况https://github.com/pasaran/yate/tree/master/tests

14. jsonpath对象变换最后一次提交的2017年1月18日

    从使用JSONPath对象文本中提取数据，并基于模板的新对象。

15. 装订最后提交2013年9月16日

    装订是一个JavaScript库，使XSLT格式化JSON对象。 相反，使用JavaScript模板引擎和文本/ HTML模板，装订让您有机会使用XSLT模板 - 使用Ajax异步加载，然后缓存的客户端 - 解析你的JSON数据源。

眼镜：

• JsonPointer

  JSON指针定义用于识别JavaScript对象符号（JSON）文件内的特定值的字符串的语法。

• JsonPath

  JSONPath表达式总是指JSON结构以相同的方式作为XPath表达式组合使用与XML文档

• JSPath

  JSPath为JSON是喜欢的XPath XML“。

• JSONiq

  背后JSONiq灵感的主要来源是XQuery的，它迄今已证明对半结构化数据的成功和富有成效的查询语言

Answer 4:

XSLT支持JSON作为在看到http://www.w3.org/TR/xslt-30/#json

XML用来分隔标记尖括号，JSON使用大括号，括号，...一，即 XML的较少标志物辨别比较意味着它的声明性变换优化的，而更多的比较，是一样的switch语句，对速度的原因承担投机的分支预测，在脚本语言命令式代码是有用的。 作为直接后果，对于半结构化数据的不同组合，你可能想基准XSLT和JavaScript引擎作为响应页面的部分性能。 对于可以忽略不计的数据有效载荷，转换可能与JSON很好的工作没有XML序列化。 W3的决定应该是基于更好的分析。

Answer 5:

我最近发现一个工具，我的造型JSON喜爱： https://github.com/twigkit/tempo 。 使用非常简单的工具 - 在我看来，这是很容易比XSLT工作 - 无需XPath查询。

Answer 6:

JQ -重量轻且灵活的命令行处理器JSON

它不是基于模板像XSLT，但更简洁。 例如，以提取name和address字段到一个数组： [.name, .address]

的教程遍历转化Twitter的JSON API的一个例子（以及手动有许多的例子）。

Answer 7:

看看jsonpath对象变换

Answer 8:

如果说缺少工具提示缺少需要的仅仅是在回避问题。 这同样可以适用于在Linux中X或Y支持（何苦这样的少数OS开发高质量的驱动程序和/或游戏？为什么要注意的是大型游戏和硬件公司没有为开发一个操作系统？）。 大概谁也需要使用XSLT和JSON最终使用一个有点微不足道解决办法人民：转变JSON转换成XML。 但是，这并不是最佳的解决方案，是吗？

当你有一个原生JSON格式，并要编辑在浏览器中“wysywyg”，XSLT将是问题的一个绰绰有余的解决方案。 这样，与传统的Javascript编程可以成为一个痛苦的屁股。

事实上，我已经实现了“石器时代”的方式XSLT，采用串解析成解释JavaScript的一些基本的命令，比如调用模板，流程的孩子，等等。当然实现转换引擎与一个JSON对象比更容易实施全面的XML解析器解析XSLT。 问题是，使用XML模板来改变你需要分析模板的XML JSON对象。

要变换分析与XML（或HTML，或文本或其他）JSON对象，你需要仔细考虑语法，什么特别的你需要使用标识变换命令字符。 否则，你会最终不得不设计一个解析器自己的自定义模板语言。 通过这条道路已经走了，我可以告诉你，这是不漂亮。

更新（2010年11月12日）：一对夫妇对我的解析器工作周后，我已经能够优化它。 模板预先解析和命令被存储为JSON对象。 转换规则也JSON对象，而模板代码是HTML的结构和类似于shell代码的一个自制的语法。 我已经能够改变一个复杂的JSON文档转换为HTML，使文档编辑器。 该代码是编辑者1K左右线（它是一个私人项目，所以我不能分享）和JSON的转换代码周围990线（包括重复命令，简单的比较，模板调用，变量保存和评价）。 我打算将其释放下MIT许可证。 如果你想参与进来给我发邮件。

Answer 9:

还有就是现在！ 我最近建立了一个图书馆，JSON-变换 ，正是为了这个目的：

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

这种转变是由三个规则。 其中第一个是通过由本田，发光的对象与任何汽车匹配Honda属性，然后递归匹配。 第二条规则的任何对象匹配与maker属性，输出model和year属性。 最后是恒等变换是递归匹配。

Answer 10:

作为又一个新的答案，一个老问题，我建议你看看DefiantJS 。 这不是一个XSLT 等同于JSON，它是 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>

Answer 11:

我写了解决这个自己的小型图书馆，最近，它试图保持接近

5.1处理模型（XSLT REC） https://www.w3.org/TR/xslt#section-Processing-Model

因为是可能的（尽我所能反正），在JavaScript的几行代码。

下面是使用的一些未完全平凡的例子...

1. JSON到一些的标记：

小提琴： 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>

和

2. JSON到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例子：分组节点基于共同价值观

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

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

哪里...

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

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

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

哪里...

/*
  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 （当然其它）。

例如，如何得到一个杂货店项目的折扣知道它的品牌标识，在

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

Answer 12:

我已经真的累了JavaScript的模板引擎的大量的在那里，所有的内嵌HTML模板，不同的标记样式等，并决定建立一个小型图书馆 ，让XSLT格式化JSON数据结构。 以任何方式不是火箭科学 - 它只是JSON解析为XML，然后用XSLT文档格式。 它速度快也不能快于Chrome浏览器的JavaScript模板引擎，但在大多数其他浏览器它至少一样快JS引擎替代了更大的数据结构。

Answer 13:

JSONiq是这样的标准和左巴一个开放源代码C ++实现。 JSONiq也可以看作是XQuery的与添加JSON作为本地数据类型。

Answer 14:

我使用的骆驼航线umarshal（xmljson） - >到（XLST） - >元帅（xmljson）。 足够有效的（虽然不是100％完美的），但简单，如果你已经在使用骆驼。

Answer 15:

它很可能使用XSLT转换成JSON：你需要JSON2SAX解串器和SAX2JSON串行器。

在Java中的示例代码： http://www.gerixsoft.com/blog/json/xslt4json

Answer 16:

亚特（ https://github.com/pasaran/yate ）XSLT后专门设计，拥有JPath（一种天然的XPath等效JS），编译为JavaScript和拥有的生产使用也颇有一段历史。 这实际上是无证的，而是通过采样和测试读数应该够了。

Answer 17:

JSLT是非常接近一个JSON相当于XSLT的。 这是你写的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实现对杰克逊的顶部。

Answer 18:

不要太肯定有必要为此，对我缺乏工具暗示缺乏必要的。 JSON作为对象（它在JS做反正方式）最好的处理，您通常使用对象的语言本身做变换（Java进行Java对象从JSON创建的，同样为Perl，Python，Perl和C＃，PHP等上）。 只是与正常分配（或设置，获取），循环等。

我的意思是，XSLT是另一种语言，一个原因，它需要的是XML是不是一个对象的符号，因此编程语言的对象是不准确的配合（分层XML模型和对象/结构之间的阻抗）。

Answer 19:

你为什么不转换JSON使用XML 数据Coverter先生 ，变换分析它使用XSLT，然后使用相同的改回JSON。

Answer 20:

对于方法的概念的工作涂鸦/证明利用与背后XSLT的匹配表达式和递归模板熟悉和声明图案沿纯JavaScript，请参阅https://gist.github.com/brettz9/0e661b3093764f496e36

（类似的方法可能采取的JSON）。

需要注意的是演示还依赖于JavaScript 1.8封表达为方便表达在Firefox模板（至少直到方法ES6简短形式可以实现）。

免责声明：这是我自己的代码。

Answer 21:

我很久以前写过一个DOM适配器我的杰克逊基于JSON处理框架。 它使用nu.xom库。 得到的DOM树的作品与Java XPath和XSLT设施。 我做了一些实施选择是非常简单的。 例如根节点始终称为“根”，阵列进入与Li子元素（如在HTML）的醇节点，以及其他一切仅仅是一个带有原始值或另一个目的节点的子节点。

JsonXmlConverter.java

用法： JsonObject sampleJson = sampleJson(); org.w3c.dom.Document domNode = JsonXmlConverter.getW3cDocument(sampleJson, "root"); JsonObject sampleJson = sampleJson(); org.w3c.dom.Document domNode = JsonXmlConverter.getW3cDocument(sampleJson, "root");

Answer 22:

尚未给出一种方法是使用一个解析器生成器来创建XSLT，它解析JSON并产生XML输出的分析器。

这被在XML会议提到了很多的一个选择是REX解析器生成（ http://www.bottlecaps.de/rex/ ） -虽然在网站上完全没有证件，菜谱都可以寻觅。

Answer 23:

它可能会使用XSLT使用JSON。 的XPath（3.1）XSLT（3.0）和XQuery（3.1）的尔松3支持JSON以某种方式。 这似乎是在萨克森的商业版本，并可能在某个时刻被列入HE版本。 https://www.saxonica.com/html/documentation/functions/fn/parse-json.html

-

我希望从一个替代的解决方案是什么：

我希望能够输入JSON获取匹配的一组数据，并输出JSON或文本。

访问任意属性和评估值

有条件的逻辑支持

我想在转换脚本是从工具，基于文本的，并且最好是常用的语言外。

潜在的替代？

我不知道如果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，或充分评估这个选项，但我希望能更尽快调查一下。 只是一些想法至今。

Answer 24:

JSON-E拥有的Node.js，Python和去实现。

文章来源: XSLT equivalent for JSON