XSLT 相当于 JSON
[英]XSLT equivalent for JSON
24 个解决方案
解决方案1
151 2018-02-27 14:49:17
JSON 的 XSLT 等效项 - 候选列表（工具和规范）
工具
1. XSLT
您可以将XSLT 用于 JSON以达到fn:json-to-xml 的目的。
本节描述允许使用 XSLT 处理 JSON 数据的工具。
jq 就像用于 JSON 数据的 sed - 您可以使用它来切片、过滤、映射和转换结构化数据，就像 sed、awk、grep 和朋友让您处理文本一样轻松。 有适用于不同操作系统的安装包。
JJ 是一个命令行实用程序，它提供了一种快速而简单的方法来检索或更新 JSON 文档中的值。 它由 GJSON 和 SJSON 提供支持。
4.外汇
命令行 JSON 处理工具 - 不需要学习新语法 - 纯 JavaScript - 格式化和高亮 - 独立二进制
jl（“JSON lambda”）是一种用于查询和操作 JSON 的微型函数式语言。
6.震动
用 Java 编写的 JSON 到 JSON 转换库，其中转换的“规范”本身就是一个 JSON 文档。
7.格隆
使 JSON grepable！ gron 将 JSON 转换为离散分配，以便更轻松地搜索您想要的内容并查看它的绝对“路径”。 它简化了对返回大量 JSON 但具有糟糕文档的 API 的探索。
8. json-e
JSON-e 是一种数据结构参数化系统，用于在 JSON 对象中嵌入上下文。 中心思想是将数据结构视为“模板”，并使用另一个数据结构作为上下文对其进行转换，以生成输出数据结构。
9. JSLT
JSLT 是一种完整的 JSON 查询和转换语言。 语言设计的灵感来自 jq、XPath 和 XQuery。
10. JSONata
JSONata 是一种用于 JSON 数据的轻量级查询和转换语言。 受 XPath 3.1 的“位置路径”语义的启发，它允许以简洁直观的符号表示复杂的查询。
11. JSONPath 加
分析、转换和有选择地从 JSON 文档（和 JavaScript 对象）中提取数据。 jsonpath-plus 在原始规范的基础上进行了扩展，添加了一些额外的运算符，并明确了原始规范中没有说明的一些行为。
12. json-transforms上次提交 2017 年 12 月 1 日
提供一种递归的模式匹配方法来转换 JSON 数据。 转换被定义为一组匹配 JSON 对象结构的规则。 当匹配发生时，规则发出转换后的数据，可选地递归转换子对象。
13. json上次提交时间 2018 年 6 月 23 日
json 是一个用于处理 JSON 的快速 CLI 工具。 它是一个单文件 node.js 脚本，没有外部 deps（除了 node.js 本身）。
14. jsawk最后一次提交时间为 2015 年 3 月 4 日
Jsawk 类似于 awk，但用于 JSON。 您使用从 stdin 读取的 JSON 对象数组，使用 JavaScript 过滤它们以生成打印到 stdout 的结果数组。
15. yate最后一次提交 2017 年 3 月 13 日
16. jsonpath-object-transform上次提交 2017 年 1 月 18 日
使用 JSONPath 从对象文字中提取数据并基于模板生成新对象。
17. Stapling最后一次提交 2013 年 9 月 16 日
Stapling 是一个 JavaScript 库，可为 JSON 对象启用 XSLT 格式。 Stapling 不是使用 JavaScript 模板引擎和 text/html 模板，而是让您有机会使用 XSLT 模板（通过 Ajax 异步加载然后缓存客户端）来解析您的 JSON 数据源。
眼镜：
JSON 指针定义了一种字符串语法，用于标识 JavaScript 对象表示法 (JSON) 文档中的特定值。
JSONPath 表达式始终以与 XPath 表达式与 XML 文档结合使用的相同方式引用 JSON 结构
JSON 的 JSPath 就像 XML 的 XPath。”
JSONiq 背后的主要灵感来源是 XQuery，迄今为止，它已被证明是一种成功且高效的半结构化数据查询语言
解决方案2
79 已采纳 2009-10-24 17:59:40
有趣的想法。 在 Google 上的一些搜索产生了一些有趣的页面，包括：
- 如何实现这样的“jsonT”工具的概述，以及一些下载
- 对该实现的一些讨论
- 可能已经实施了一些合适的东西的公司
希望这可以帮助。
解决方案3
72 2013-07-01 20:45:24
试试JOLT 。 它是一个用 Java 编写的 JSON 到 JSON 转换库。
它是专门创建的，因为我们不想玩“JSON -> XML -> XSLT -> XML -> JSON”游戏，并且使用模板进行任何足够复杂的转换都是不可维护的。
解决方案4
16 2013-09-29 18:38:34
XSLT 支持 JSON，见http://www.w3.org/TR/xslt-30/#json
XML 使用尖括号作为分隔符，JSON 使用大括号、方括号……即。 XML 较少的标记识别比较意味着它针对声明性转换进行了优化，而更多的比较（如 switch 语句）出于速度原因假设推测性分支预测，脚本语言中的命令式代码对其有用。 作为直接结果，对于半结构化数据的不同组合，您可能希望将 XSLT 和 javascript 引擎的性能作为响应页面的一部分进行基准测试。 对于可忽略不计的数据负载，转换可能与 JSON 一样好，无需 XML 序列化。 W3 的决定应该基于更好的分析。
解决方案5
15 2013-07-05 21:25:09
它不像 XSLT 那样基于模板，但更简洁。 例如将name和address字段提取到数组中： [.name, .address] name [.name, .address]
解决方案6
15 2011-05-09 14:14:33
我最近发现了一个我喜欢的 JSON 样式工具： https : //github.com/twigkit/tempo 。 非常容易使用的工具——在我看来，它比 XSLT 更容易使用——不需要 XPATH 查询。
解决方案7
12 2015-02-13 16:36:37
解决方案8
12 2016-02-26 23:06:48
我最近围绕这个写了我自己的小图书馆，它试图保持尽可能接近
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 的局限性也很有用。 查询祖先轴，如this SO question （当然还有其他问题）提出。
例如，如何在知道其品牌 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，
解决方案9
11 2010-11-02 16:11:12
说缺乏工具意味着缺乏需求只是在问这个问题。 这同样适用于 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 以制作文档编辑器。 编辑器的代码大约有 1000 行（它是用于私人项目，所以我无法共享它）和大约 990 行的 JSON 转换代码（包括迭代命令、简单比较、模板调用、变量保存和评估）。 我计划在 MIT 许可下发布它。 如果你想参与，给我发邮件。
解决方案10
10 2016-01-20 21:15:33
作为对旧问题的另一个新答案，我建议看看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>
解决方案11
10 2016-07-10 17:42:24
现在有！ 我最近创建了一个库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 制造的任何汽车，发出具有Honda属性的对象，然后递归匹配。 第二条规则匹配具有maker属性的任何对象，输出model和year属性。 最后是递归匹配的恒等变换。
解决方案12
5 2012-05-10 07:36:53
我真的厌倦了大量的 JavaScript 模板引擎，以及它们所有的内联 HTML 模板、不同的标记样式等，并决定构建一个小型库，为 JSON 数据结构启用 XSLT 格式。 无论如何都不是火箭科学——它只是将 JSON 解析为 XML，然后使用 XSLT 文档进行格式化。 它也很快，不如 Chrome 中的 JavaScript 模板引擎快，但在大多数其他浏览器中，它至少与用于更大数据结构的 JS 引擎替代品一样快。
解决方案13
4 2014-07-31 18:16:52
我正在使用骆驼路线 umarshal(xmljson) -> to(xlst) -> marshal(xmljson)。 足够高效（虽然不是 100% 完美），但很简单，如果您已经在使用 Camel。
解决方案14
3 2014-07-21 08:00:56
解决方案15
3 2018-10-12 06:05:58
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 实现的。
解决方案16
2 2017-03-22 04:25:18
Yate ( https://github.com/pasaran/yate ) 是在 XSLT 之后专门设计的，具有 JPath（JS 的自然 XPath 等价物），编译为 JavaScript 并且有相当长的生产使用历史。 它实际上没有记录，但通读示例和测试应该就足够了。
解决方案17
2 2012-02-20 15:43:38
很可能使用 XSLT 转换 JSON：您需要 JSON2SAX 反序列化器和 SAX2JSON 序列化器。
Java 中的示例代码： http : //www.gerixsoft.com/blog/json/xslt4json
解决方案18
0 2013-01-01 05:36:23
为什么不使用Mr. Data Coverter将 JSON 转换为 XML，使用 XSLT 转换它，然后使用相同的方法将其改回 JSON。
解决方案19
0 2014-12-02 08:38:26
有关使用纯 JavaScript 以及 XSLT 匹配表达式和递归模板背后熟悉的声明性模式的方法的工作涂鸦/概念证明，请参阅https://gist.github.com/brettz9/0e661b3093764f496e36
（对于 JSON 可能会采用类似的方法。）
请注意，该演示还依赖 JavaScript 1.8 表达式闭包，以方便在 Firefox 中表达模板（至少在 ES6 方法的简写形式可能实现之前）。
免责声明：这是我自己的代码。
解决方案20
0 2016-12-16 09:29:04
很久以前，我为我的基于 jackson 的 json 处理框架编写了一个 dom 适配器。 它使用 nu.xom 库。 生成的 dom 树与 java xpath 和 xslt 工具一起使用。 我做了一些非常简单的实现选择。 例如，根节点总是被称为“根”，数组进入一个带有 li 子元素的 ol 节点（如在 html 中），其他一切都只是一个带有原始值或另一个对象节点的子节点。
用法： JsonObject sampleJson = sampleJson(); org.w3c.dom.Document domNode = JsonXmlConverter.getW3cDocument(sampleJson, "root"); JsonObject sampleJson = sampleJson(); org.w3c.dom.Document domNode = JsonXmlConverter.getW3cDocument(sampleJson, "root");
解决方案21
0 2017-07-07 19:34:22
尚未给出的一种方法是使用解析器生成器在 XSLT 中创建解析器，该解析器解析 JSON 并生成 XML 输出。
在 XML 会议上经常提到的一个选项是 ReX 解析器生成器 ( http://www.bottlecaps.de/rex/ ) - 尽管网站上完全没有记录，但可以通过搜索找到食谱。
解决方案22
0 2017-11-16 15:49:45
可以将 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，或者还没有完全评估这个选项，但我希望尽快研究它。 到目前为止只是一些想法。
解决方案23
0 2022-11-24 10:55:25
CsvCruncher
尽管它的名字并没有暗示它，但 CsvCruncher 可以有效地用于读取表格* JSON 数据并使用 SQL 处理它们。
*表格表示 JSON 树的某些部分是规则的，即具有相同或相似结构的一对多条目。
CsvCruncher 将树的这一部分变成了一个 SQL 表，然后你就有了一个完整的 SQL 语法来查询它。
您还可以加载多个 JSON 树，然后可以玩多个表。
您还可以将 SQL 结果存储为 JSON（或 CSV），然后再次处理它。
这比真正复杂的 XSLT 方法更适合我（尽管当你真正深入了解它时它会很有趣）。
免责声明：我是 CsvCruncher 的开发者。
解决方案24
-3 2010-09-29 05:06:59
不太确定是否需要这样做，对我来说缺乏工具意味着缺乏需要。 JSON 最好作为对象处理（无论如何它在 JS 中完成的方式），并且您通常使用对象本身的语言来进行转换（Java 用于从 JSON 创建的 Java 对象，对于 Perl、Python、Perl、c#、PHP 等也是如此）在）。 只需使用正常的赋值（或设置、获取）、循环等。
我的意思是，XSLT 只是另一种语言，需要它的一个原因是 XML 不是对象表示法，因此编程语言的对象并不完全匹配（分层 xml 模型和对象/结构之间的阻抗）。
XSLT等效于XML到JSON
声明:本站的技术帖子网页，遵循CC BY-SA 4.0协议，如果您需要转载，请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.