JSON 的 XSLT 等效项

Question

Closed. This question is seeking recommendations for software libraries, tutorials, tools, books, or other off-site resources. It does not meet Stack Overflow guidelines. It is not currently accepting answers.

---

我们不允许提出寻求软件库、教程、工具、书籍或其他场外资源推荐的问题。您可以编辑问题，以便用事实和引文来回答。

8 个月前已关闭。

Answer 1

JSON 的 XSLT 等效项 - 候选列表（工具和规范）

工具

1。 XSLT

您可以使用 XSLT for JSON 旨在 fn:json-to-xml。

本节介绍允许使用 XSLT 处理 JSON 数据的工具。

2. jq

jq 就像 JSON 数据的 sed - 您可以使用它来切片、过滤、映射和转换结构化数据，就像 sed、awk、grep 和朋友让您处理文本一样轻松。
有针对不同操作系统的安装包。

3. jj

JJ 是一个命令行实用程序，它提供了一种快速而简单的方法来检索或更新 JSON 文档中的值。它的底层由 GJSON 和 SJSON 提供支持。

4. fx

命令行 JSON 处理工具

• 不需要学习新语法
• 纯 JavaScript
• 格式设置和突出显示
• 独立二进制文件

5. CsvCruncher

基于SQL的命令行表格数据处理工具

• 不需要学习新语法
• 适用于 JSON 包含具有相似项的大型数组时
• 支持将多个文档作为多个SQL表进行处理
• 用 Kotlin 编写，在 Java 上运行
• 也可作为 Maven 中央存储库中的 Java 库

6. jl

jl（“JSON lambda”）是一种用于查询和操作 JSON 的小型函数式语言。

7. JOLT

用 Java 编写的 JSON 到 JSON 转换库，其中转换的“规范”本身就是一个 JSON 文档。

8. gron

使 JSON 可 grep 化！
gron 将 JSON 转换为离散赋值，以便更轻松地 grep 查找您想要的内容并查看它的绝对“路径”。它简化了对返回大量 JSON 但文档很糟糕的 API 的探索。

9. json-e

JSON-e 是一个数据结构参数化系统，用于在 JSON 对象中嵌入上下文。
中心思想是将数据结构视为“模板”，并使用另一个数据结构作为上下文对其进行转换，以生成输出数据结构。

10. JSLT

JSLT 是一种完整的 JSON 查询和转换语言。语言设计的灵感来自 jq、XPath 和 XQuery。

11. JSONata

JSONata 是一种轻量级的 JSON 数据查询和转换语言。受到 XPath 3.1 的“位置路径”语义的启发，它允许以紧凑且直观的符号来表达复杂的查询。

12. JSONPath Plus

分析、转换并有选择地从 JSON 文档（和 JavaScript 对象）中提取数据。
jsonpath-plus 在原始规范的基础上进行了扩展，添加了一些额外的运算符，并明确了原始规范中未阐明的一些行为。

13. json-transforms 最后提交时间：2017 年 12 月 1 日

提供一种递归的模式匹配方法来转换 JSON 数据。转换被定义为与 JSON 对象的结构相匹配的一组规则。当发生匹配时，规则会发出转换后的数据，并可选择递归以转换子对象。

14. json 最后提交时间：2018 年 6 月 23 日

json 是一个用于处理 JSON 的快速 CLI 工具。它是一个单文件 Node.js 脚本，没有外部依赖（除了 Node.js 本身）。

15. jsawk 最后提交时间：2015 年 3 月 4 日

Jsawk 类似于 awk，但用于 JSON。您使用从 stdin 读取的 JSON 对象数组，使用 JavaScript 过滤它们以生成打印到 stdout 的结果数组。

16. yate 最后提交时间：2017 年 3 月 13 日

测试可以用作文档https://github.com/pasaran/yate /树/主/测试

17. jsonpath-object-transform 最后提交时间：2017 年 1 月 18 日

使用 JSONPath 从对象文字中提取数据并基于模板生成新对象。

18. 装订 最后提交时间：2013 年 9 月 16 日

Stapling 是一个 JavaScript 库，支持 JSON 对象的 XSLT 格式设置。
Stapling 不使用 JavaScript 模板引擎和 text/html 模板，而是让您有机会使用 XSLT 模板（通过 Ajax 异步加载，然后缓存客户端）来解析 JSON 数据源。

19. mapneat

MapNeat 是一个用 Kotlin 编写的 JVM 库，它提供了一种易于使用的 DSL（领域特定语言），用于以声明方式将 JSON 转换为 JSON、XML 转换为 JSON、POJO 转换为 JSON。

20。 DTL

DTL 的主要优势之一是它与 JavaScript 的兼容性，这意味着您可以在任何可以使用 JavaScript 的地方使用它。 DTL 的用途也非常广泛，可用于在各种场景中操作数据，包括处理来自表单或 API 调用的输入数据以及在数据格式之间进行转换。

规格：

• JSON 指针

JSON 指针是一种字符串语法或地址，用于标识较大 JSON 对象中的特定对象。它没有查询功能或转换功能。 JSON 指针的指示对象可以是任何 JSON 对象。

• JsonPath

JSONPath 表达式始终引用 JSON 结构，就像 XPath 表达式与 XML 文档结合使用一样

• JSPath

JSON 的 JSPath 就像 XML 的 XPath。”

• JSONiq

JSONiq 背后的主要灵感来源是 XQuery，迄今为止，它已被证明是一种成功且高效的半结构化数据查询语言

• JMESPATH< /a>

JMESPath 是一种 JSON 查询语言。 JMESPath语言采用ABNF语法描述，具有完整的规范。

Answer 2

有趣的想法。在 Google 上进行的一些搜索产生了一些有趣的页面，其中包括：

• 概述，说明这样的“jsonT”是如何实现的工具可能会被实现，并且一些下载
• 一些对该实施的讨论
• 一家公司可能已经实现了一些合适的东西

希望这会有所帮助。

Answer 3

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

它是专门创建的，因为我们不想玩“JSON -> XML -> XSLT -> XML -> JSON”游戏，并且使用模板进行任何足够复杂的转换是无法维护的。

Answer 4

XSLT 支持 JSON，如 http://www.w3.org/TR/xslt- 所示30/#json

XML 使用尖括号作为分隔符，JSON 使用大括号、方括号……即XML 较少的标记识别比较意味着它针对声明性转换进行了优化，而更多的比较（如 switch 语句）出于速度原因假设推测分支预测，而脚本语言中的命令式代码对此很有用。作为直接结果，对于半结构化数据的不同组合，您可能希望将 XSLT 和 JavaScript 引擎的性能作为响应式页面的一部分进行基准测试。对于可忽略不计的数据负载，转换可能与无需 XML 序列化的 JSON 一样有效。 W3的决定应该基于更好的分析。

Answer 5

jq - 轻量级、灵活的命令行 JSON 处理器

它不像 XSLT 那样基于模板，但更简洁。例如，将 name 和 address 字段提取到数组中： [.name, .address]

教程 演练了转换 Twitter 的 JSON API 的示例（以及 手册 有很多例子）。

Answer 6

我最近发现了一个我喜欢的 JSON 样式工具： https://github.com/twigkit/tempo。非常容易使用的工具——在我看来，它比 XSLT 更容易使用——不需要 XPATH 查询。

Answer 7

看看 jsonpath-object-transform

Answer 8

最近，我围绕此编写了自己的小型库，它试图尽可能接近

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

尽可能地（无论如何我都可以），用几行 JavaScript 代码。

以下是一些不完全简单的使用示例...

1. JSON 到某些标记：

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

相当于...

JSONiq 用例第 1.1.2 节。 JSON 分组查询

（位于：https://jsfiddle.net/YSharpLanguage/hvo24hmk/3< /a>)

参见。 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问题提出的（当然还有其他人）。

例如，如何在知道其品牌 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，

Answer 9

如果说缺乏工具就意味着缺乏需求，这只是在回避问题。同样的情况也适用于 Linux 中对 X 或 Y 的支持（为什么要为如此少数的操作系统开发高质量的驱动程序和/或游戏？为什么要关注大型游戏和硬件公司不开发的操作系统？）。可能需要使用 XSLT 和 JSON 的人最终会使用一种有些微不足道的解决方法：将 JSON 转换为 XML。但这不是最佳解决方案，不是吗？

当您拥有本机 JSON 格式并且想要在浏览器中“所见即所得”编辑它时，XSLT 将是解决该问题的充分解决方案。使用传统的 JavaScript 编程来做到这一点可能会变得很痛苦。

事实上，我已经实现了 XSLT 的“石器时代”方法，使用子字符串解析来解释 javascript 的一些基本命令，例如调用模板、处理子级等。当然，使用 JSON 对象实现转换引擎比实现一个成熟的 XML 解析器来解析 XSLT。问题是，要使用 XML 模板转换 JSON 对象，您需要解析模板的 XML。

要使用 XML（或 HTML、文本或其他内容）转换 JSON 对象，您需要仔细考虑语法以及需要使用哪些特殊字符来标识转换命令。否则，您最终将不得不为您自己的自定义模板语言设计一个解析器。走过那条路之后，我可以告诉你，这条路并不美好。

更新（2010 年 11 月 12 日）：经过几周的解析器工作，我已经能够对其进行优化。预先解析模板并将命令存储为 JSON 对象。转换规则也是 JSON 对象，而模板代码是 HTML 和类似于 shell 代码的自制语法的混合。我已经能够将复杂的 JSON 文档转换为 HTML 来制作文档编辑器。编辑器代码约为 1K 行（这是一个私人项目，所以我无法共享），JSON 转换代码约为 990 行（包括迭代命令、简单比较、模板调用、变量保存和评估）。我计划在麻省理工学院的许可下发布它。如果您想参与，请给我发邮件。

Answer 10

作为老问题的另一个新答案，我建议看看 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>

Answer 11

现在有了！我最近创建了一个库，json-transforms，正是为了这个目的：

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

它使用 DSL 的组合 JSPath以 XPath 为模型，以及直接受 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 }
  ]
}

该转换由三个规则组成。第一个匹配本田制造的任何汽车，发出具有本田属性的对象，然后递归匹配。第二条规则匹配具有 maker 属性的任何对象，输出 model 和 year 属性。最后是递归匹配的恒等变换。

Answer 12

我真的厌倦了大量的 JavaScript 模板引擎，以及它们所有的内联 HTML 模板、不同的标记样式等，并决定 构建一个小型库，支持 JSON 数据结构的 XSLT 格式。无论如何，这都不是火箭科学——它只是将 JSON 解析为 XML，然后使用 XSLT 文档进行格式化。它也很快，虽然不如 Chrome 中的 JavaScript 模板引擎快，但在大多数其他浏览器中，它至少与大型数据结构的 JS 引擎替代品一样快。

Answer 13

我正在使用 Camel 路线 umashal(xmljson) ->到（xlst）->元帅（xmljson）。足够高效（虽然不是 100% 完美），但很简单，如果您已经在使用 Camel。

Answer 14

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
}

它是在 Jackson 之上用 Java 实现的。

Answer 15

JSONiq 就是这样一个标准，Zorba 开源 C++ 实现。 JSONiq 也可以被视为添加 JSON 作为本机数据类型的 XQuery。

Answer 16

很可能使用 XSLT 转换 JSON：您需要 JSON2SAX 反序列化器和 SAX2JSON 序列化器。

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

Answer 17

Yate (https://github.com/pasaran/yate) 是在 XSLT 之后专门设计的，具有 JPath 特性（JS 的自然 XPath 等效项），编译为 JavaScript，并且具有相当长的生产使用历史。它实际上没有记录，但阅读示例和测试应该足够了。

Answer 18

我知道这是一篇旧帖子，但我刚刚遇到它，尽管我有偏见，因为我最初编写了该工具，但我认为我有最适合该问题的答案。

该语言、DTL 或数据转换语言是专门为转换 JSON（或任何结构化数据）而设计的。它的用途与 XSLT 非常相似，您可以在 npm 上以 dtl-js 形式或在网站 getdtl.org 上找到它其中包括一个实时浏览器内工具来探索它。

看起来像这样：

{ 
  "out": { 
    "id": "(: $user_id :)", 
    "personalInfo": { 
      "name": "(: &( $first_name ' ' $last_name ) :)", 
      "age": "(: $age :)" 
    }, 
    "contactDetails": { 
      "email": "(: $email :)", 
      "phone": "(: $phone :)" 
    }, 
    "address": { 
      "street": "(: $address1 :)", 
      "unit": "(: $address2 :)", 
      "city": "(: $addr_city :)", 
      "postal_code": "(: $addr_zip :)" 
    } 
  } 
}

DTL 和 XSLT 在几个重要方面是相似的：

1. 数据转换的目的：XSLT 和 DTL 主要用于转换数据。它们获取输入数据并将其转换为所需的输出格式。

2. 支持复杂转换：两者都可以处理复杂的数据转换，允许用户以复杂的方式操作和重组数据。

3. 嵌入性：两者都可以嵌入到它们转换的数据中。 DTL 可以嵌入到 JSON 结构中，就像 XML 文件中的 XSLT 一样。

4. 基于规则的逻辑：它们根据定义的规则或模式进行操作 - XSLT 对 XML 元素使用模板规则，而 DTL 对 JSON 元素使用转换表达式。

5. 模式匹配：XSLT 使用 XPath 来选择 XML 节点，类似地，DTL 使用表达式根据特定条件选择和操作 JSON 元素。

6. 声明性：两种语言都是声明性的，重点关注转换应该实现什么而不是如何完成。

7. 迭代和条件处理：它们支持条件逻辑和迭代 - XSLT，具有 xsl:for-each 和 xsl:if 等结构，以及带有 map 和 grep 等帮助器的 DTL。

8. 可扩展性：两者都可以通过附加功能进行扩展，例如 XSLT 中的自定义函数和 DTL 中的自定义帮助程序。

9. 转换上下文感知：每个都有一个上下文感知转换过程，这对于将正确的转换逻辑应用于数据至关重要。

10. 数据不可知逻辑：两者中的转换逻辑都是数据不可知的，允许其应用于符合预期结构的不同数据集。

简而言之，DTL 是为 JSON 量身定制的，专门设计用于对 JSON 执行与 XSLT 对 XML 执行的完全相同的工作。

再说一次，我有偏见，但 DTL 与 XSLT 不同的一些重要方面：

1. 更容易理解：
   DTL 转换结构通常反映所需的输出结构，并且语法更易于理解和阅读。 （您可以查看快速入门，它告诉您需要了解的所有信息。 ）

2. 数据格式灵活性：
   虽然 DTL 主要是为 JSON 设计的，但它也可以处理 YAML、CSV，甚至纯文本数据。这种多功能性使得 DTL 更适合 XML 之外的各种数据格式。 dtl 命令行工具可使用多种格式进行批量数据处理。

3. 与现代网络技术集成：
   DTL 与 JavaScript 和现代 Web 开发实践无缝集成，使其非常适合主要使用 JSON 的 Web 应用程序。它运行在服务器上、浏览器中，甚至直接用于 MongoDB 等 NoSQL 数据库。

4. 易于调试：
   DTL 更简单的语法和结构可以使调试更容易，尤其是在 JavaScript 环境中使用时。 网站上的交互式工具和 dtlr 命令行 REPL/数据浏览器让一切变得简单弄清楚你需要做什么。

5. 可读性和维护：
   DTL 简单的语法和类似 JSON 的结构可以使 DTL 转换更具可读性和可维护性。

6. 强大的编辑器支持：
   DTL 具有强大的编辑器支持，为 vs-code、sublime-text 和 vim 中的所有内置功能提供语法突出显示和片段。

再说一次，我最初写它是因为我有偏见，但我写它是因为这个问题没有一个好的答案。它很稳定且易于维护，自 2013 年以来已被许多公司投入生产使用，而且它的功能非常出色。

希望有帮助。

Answer 19

为什么不使用 Mr. 将 JSON 转换为 XML Data Coverter，使用 XSLT 将其转换，然后使用相同的方法将其更改回 JSON。

Answer 20

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

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

请注意，该演示还依赖于 JavaScript 1.8 表达式闭包，以便于表达模板在 Firefox 中（至少在方法的 ES6 缩写形式可能实现之前）。

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

Answer 21

很久以前，我为我的基于 Jackson 的 json 处理框架编写了一个 dom 适配器。它使用 nu.xom 库。生成的 dom 树与 java xpath 和 xslt 工具一起使用。我做出了一些非常简单的实现选择。例如，根节点始终称为“root”，数组进入带有 li 子元素的 ol 节点（如在 html 中），其他所有内容都只是具有原始值的子节点或另一个对象节点。

JsonXmlConverter.java< /a>

用法：
<代码>
JsonObject 样本Json = 样本Json();
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。
这似乎在 Saxon 的商业版本中可用，并且可能在某个时候包含在 HE 版本中。
https://www.saxonica.com/html/documentation/ functions/fn/parse-json.html

-

我对替代解决方案的期望：

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

访问任意属性并评估值

支持条件逻辑

我希望转换脚本位于工具外部、基于文本，并且最好是常用语言。

潜在的替代方案？

我想知道 SQL 是否是一个合适的替代方案。
https://learn.microsoft。 com/en-us/sql/relational-databases/json/json-data-sql-server

如果替代工具可以处理 JSON 和 XML 那就太好了
https://learn.microsoft.com/ en-us/sql/relational-databases/xml/openxml-sql-server

我还没有尝试将我使用的 XSLT 脚本转换为 SQL，也没有完全评估此选项，但我希望研究一下很快就会有更多。到目前为止只是一些想法。

Answer 24

CsvCruncher

尽管它的名字没有暗示，CsvCruncher 可以有效地用于读取表格* JSON 数据并使用 SQL 处理它们。

* 表格表示 JSON 树的某些部分是规则的，即具有相同或相似结构的一对多条目。

CsvCruncher 将树的这一部分转换为 SQL 表，然后您就有完整的 SQL 语法来查询它。
您还可以加载多个 JSON 树，然后使用多个表。
您还可以将 SQL 结果存储为 JSON（或 CSV），然后再次处理。

这比真正复杂的 XSLT 方法更适合我（尽管当您真正深入了解它时它会很有趣）。

免责声明：我是 CsvCruncher 的开发者。

Answer 25

不太确定是否需要这样做，对我来说，缺乏工具就意味着缺乏需要。 JSON 最好作为对象进行处理（无论如何，它在 JS 中的处理方式），并且您通常使用对象本身的语言来进行转换（Java 用于从 JSON 创建的 Java 对象，同样适用于 Perl、Python、Perl、c#、PHP 等在）。只需进行正常的赋值（或设置、获取）、循环等即可。

我的意思是，XSLT 只是另一种语言，需要它的一个原因是 XML 不是对象表示法，因此编程语言的对象并不完全适合（分层 xml 模型和对象/结构之间的阻抗）。