JSON是否有等价的XSLT ?它允许我对JSON进行转换，就像XSLT对XML所做的那样。
当前回答
现在有了!我最近创建了一个库，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属性的对象，输出模型和年份属性。最后一个是递归匹配的恒等变换。
其他回答
最近，我围绕着这个写了自己的小库，尽量保持接近
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示例:基于公共值对节点进行分组
(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 vs. 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,
作为一个老问题的另一个新答案，我建议看看defantjs。它不是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>
说缺乏工具就意味着缺乏需求，这只是在回避问题。这同样适用于Linux中的X或Y支持(为什么要为这样一个少数操作系统开发高质量的驱动程序和/或游戏呢?为什么要关注一个大型游戏和硬件公司不会开发的操作系统?)可能需要使用XSLT和JSON的人最终会使用一种有点琐碎的解决方法:将JSON转换为XML。但这不是最优解，对吧?
当您有一个原生JSON格式，并且希望在浏览器中以“所见即所得”的方式编辑它时，XSLT将是一个非常合适的解决方案。用传统的javascript编程来实现这一点可能会让人头疼。
事实上，我已经实现了一种“石器时代”的XSLT方法，使用子字符串解析来解释javascript的一些基本命令，比如调用模板、子进程等。当然，使用JSON对象实现转换引擎要比实现成熟的XML解析器来解析XSLT容易得多。问题是，要使用XML模板转换JSON对象，您需要解析模板的XML。
要将JSON对象转换为XML(或HTML、文本或其他内容)，您需要仔细考虑语法以及需要使用哪些特殊字符来标识转换命令。否则，您将不得不为自己的自定义模板语言设计一个解析器。走过这条路后，我可以告诉你，它并不漂亮。
Update (Nov 12, 2010): After a couple of weeks working on my parser, I've been able to optimize it. Templates are parsed beforehand and commands are stored as JSON objects. Transformation rules are also JSON objects, while the template code is a mix of HTML and a homebrew syntax similar to shell code. I've been able to transform a complex JSON document into HTML to make a document editor. The code is around 1K lines for the editor (it's for a private project so I can't share it) and around 990 lines for the JSON transformation code (includes iteration commands, simple comparisons, template calling, variable saving and evaluation). I plan to release it under a MIT license. Drop me a mail if you want to get involved.
有关利用纯JavaScript的方法以及XSLT匹配表达式和递归模板背后熟悉的声明式模式的工作演示/概念证明，请参见https://gist.github.com/brettz9/0e661b3093764f496e36
(JSON也可以采用类似的方法。)
注意，为了方便在Firefox中表达模板，演示还依赖于JavaScript 1.8表达式闭包(至少在实现方法的ES6简写形式之前是如此)。
免责声明:这是我自己的代码。
JSON的XSLT等价物——候选工具(工具和规范)列表
工具
1. XSLT
您可以将XSLT用于JSON，目的是实现fn: JSON -to-xml。
本节描述允许使用XSLT处理JSON数据的功能。
2. 金桥
jq就像JSON数据的sed一样——你可以用它来切片、过滤、映射和转换结构化数据，就像sed、awk、grep和其他一些朋友让你处理文本一样简单。 不同操作系统有不同的安装包。
3. jj
JJ是一个命令行实用程序，提供了从JSON文档检索或更新值的快速而简单的方法。它在底层由GJSON和SJSON提供支持。
4. 外汇
命令行JSON处理工具 不需要学习新的语法 纯JavaScript 格式和高亮显示 独立的二进制
5. CsvCruncher
基于sql的命令行表格数据处理工具 不需要学习新的语法 适用于JSON包含具有相似项的大型数组时 支持将多个文档作为多个SQL表处理 用Kotlin编写，在Java上运行 也可以作为Java库在Maven Central存储库中使用
6. jl
jl(“JSON lambda”)是一种用于查询和操作JSON的小型函数式语言。
7. 震动
用Java编写的JSON到JSON转换库，其中转换的“规范”本身就是一个JSON文档。
8. gron
使JSON易于获取! 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多
分析、转换和选择性地从JSON文档(和JavaScript对象)中提取数据。 Jsonpath-plus扩展了原始规范，添加了一些额外的操作符，并显式地显示了原始规范没有阐明的一些行为。
13. 2017年12月1日
提供一种递归的模式匹配方法来转换JSON数据。转换被定义为一组匹配JSON对象结构的规则。当发生匹配时，规则发出转换后的数据，可选地递归转换子对象。
14. 最后提交2018年6月23日
json是一个使用json的快速CLI工具。它是一个单文件node.js脚本，没有外部deps(除了node.js本身)。
15. jsawk最后提交2015年3月4日
Jsawk类似于awk，但用于JSON。您使用从stdin读取的JSON对象数组，使用JavaScript对它们进行过滤，生成输出到stdout的结果数组。
16. 2017年3月13日
测试可以作为文档https://github.com/pasaran/yate/tree/master/tests使用
17. jsonpath-object-transform最后提交2017年1月18日
使用JSONPath从对象文字中提取数据，并基于模板生成一个新对象。
18. 装订最后提交2013年9月16日
Stapling是一个JavaScript库，支持JSON对象的XSLT格式。 与使用JavaScript模板引擎和文本/html模板不同，Stapling让您有机会使用XSLT模板(使用Ajax异步加载，然后在客户端缓存)来解析JSON数据源。
规格:
Json指针
JSON Pointer定义了用于标识特定值的字符串语法 在JavaScript对象表示法(JSON)文档中。
JsonPath
JSONPath表达式总是引用JSON结构，就像XPath表达式与XML文档结合使用一样
JSPath
JSPath for JSON就像XPath for XML。”
JSONiq
JSONiq背后的主要灵感来源是XQuery，到目前为止，它已被证明是一种用于半结构化数据的成功且高效的查询语言
杰梅斯帕斯
JMESPath是一种JSON的查询语言。JMESPath语言是用ABNF语法和完整的规范描述的。
推荐文章
- 查询JSON类型内的数组元素
- 将JSON字符串转换为HashMap
- 将JsonNode转换为POJO
- Json_encode()转义正斜杠
- c# vs Java Enum(适合c#新手)
- 如何写一个JSON文件在c# ?
- 如何在XSLT中实现if-else语句?
- 在序列化和反序列化期间JSON属性的不同名称
- 为什么PHP的json_encode函数转换UTF-8字符串为十六进制实体?
- Ajax会调用什么样的响应，比如'for (;;);{json data}的意思?
- 在JavaScript中将JSON字符串解析为特定对象原型
- 使用Jackson将JSON字符串转换为漂亮的打印JSON输出
- jQuery。由于转义了JSON中的单引号，parseJSON抛出“无效JSON”错误
- 用c#解析JSON
- XPath查找节点是否存在
