json - JSON 的 XSLT 等效项

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

score 15 · Accepted Answer

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

score 15 · Accepted Answer

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

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

本教程介绍了一个转换 Twitter 的 JSON API 的示例（手册中有许多示例）。

score 12 · Accepted Answer

12

看看jsonpath-object-transform

于 2015-02-13T16:36:37.797 回答

score 12 · Accepted Answer

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

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>

和

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

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

score 11 · Accepted Answer

说缺乏工具表明缺乏需求只是在乞求问题。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 行（包括迭代命令、简单比较、模板调用、变量保存和评估）。我计划在 MIT 许可下发布它。如果您想参与，请给我发邮件。

score 11 · Accepted Answer

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

score 9 · Accepted Answer

现在有！我最近创建了一个库，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 }
  ]
}

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

score 5 · Accepted Answer

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

score 4 · Accepted Answer

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

score 3 · Accepted Answer

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

score 3 · Accepted Answer

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 实现的。

score 2 · Accepted Answer

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

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

score 1 · Accepted Answer

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

score 0 · Accepted Answer

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

score 0 · Accepted Answer

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

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

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

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

score 0 · Accepted Answer

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

JsonXmlConverter.java

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

score 0 · Accepted Answer

尚未给出的一种方法是使用解析器生成器在 XSLT 中创建解析器，该解析器解析 JSON 并生成 XML 输出。

在 XML 会议上经常提到的一个选项是 ReX 解析器生成器 ( http://www.bottlecaps.de/rex/ ) - 虽然在网站上完全没有记录，但可以通过搜索获得食谱。

score 0 · Accepted Answer

可以将 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 或 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，或者还没有完全评估过这个选项，但我希望能尽快研究它。到目前为止只是一些想法。

score -3 · Accepted Answer

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

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

json - JSON 的 XSLT 等效项

23 回答 23

工具

眼镜：

1. JSON-to-some-markup：

2. JSON 到 JSON：

3. XSLT 与 JavaScript：

4. JSONiq 与 JavaScript：

Related

Reference