相当于JSON的XSLT

JSON有等价的XSLT吗?它允许我对JSON进行转换，就像XSLT对XML所做的那样。

177485 次浏览
小开
最佳答案

有趣的想法。在谷歌上的一些搜索产生了一些有趣的页面，包括:

希望这能有所帮助。

小开

我不太确定是否需要这样做，对我来说，缺乏工具意味着缺乏需求。JSON最好作为对象处理(无论如何在JS中是这样做的)，并且您通常使用对象本身的语言来进行转换(Java用于从JSON创建的Java对象，同样用于Perl、Python、Perl、c#、PHP等)。只是普通的赋值(或set, get)，循环等等。

我的意思是，XSLT只是另一种语言，需要它的一个原因是XML不是一种对象符号，因此编程语言的对象并不完全匹配(层次结构XML模型和对象/结构之间的阻抗)。

小开

说缺乏工具就意味着缺乏需求，这只是在回避问题。这同样适用于Linux中的X或Y支持(为什么要为这样一个少数操作系统开发高质量的驱动程序和/或游戏呢?为什么要关注一个大型游戏和硬件公司不会开发的操作系统?)可能需要使用XSLT和JSON的人最终会使用一种有点琐碎的解决方法:将JSON转换为XML。但这不是最优解，对吧?

当您有一个原生JSON格式，并且希望在浏览器中以“所见即所得”的方式编辑它时，XSLT将是一个非常合适的解决方案。用传统的javascript编程来实现这一点可能会让人头疼。

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

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

更新(2010年11月12日):在我的解析器上工作了几周之后，我已经能够优化它了。模板被预先解析，命令被存储为JSON对象。转换规则也是JSON对象，而模板代码是HTML和类似于shell代码的自制语法的混合。我已经能够将复杂的JSON文档转换为HTML来制作文档编辑器。编辑器的代码大约有1K行(这是一个私人项目，所以我不能分享)，JSON转换代码大约有990行(包括迭代命令、简单比较、模板调用、变量保存和计算)。我计划在MIT的许可下发布它。如果你想参与进来，给我发封邮件。

小开

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

小开

使用XSLT转换JSON是非常可能的:您需要JSON2SAX反序列化器和SAX2JSON序列化器。

示例代码: http://www.gerixsoft.com/blog/json/xslt4json < / p >

小开

我已经厌倦了大量的JavaScript模板引擎，以及它们所有的内联html模板，不同的标记样式等，并决定使用建立一个小型图书馆，它支持JSON数据结构的XSLT格式化。在任何方面都不复杂——它只是将JSON解析为XML，然后用XSLT文档进行格式化。它的速度也很快，虽然不如Chrome中的JavaScript模板引擎快，但在大多数其他浏览器中，它至少和大型数据结构的JS引擎替代物一样快。

小开

为什么不使用数据伪装先生将JSON转换为XML，使用XSLT将其转换，然后使用相同的方法将其转换回JSON呢?

小开

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

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

小开

< a href = " http://stedolan.github。io/jq/" rel="noreferrer">jq -轻量级灵活的命令行JSON处理器

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

教程给出了一个转换Twitter JSON API的例子(手册有很多例子)。

小开

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

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

小开

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

小开

我使用骆驼路由marshal(xmljson) ->到(xlst) -> marshal(xmljson)。足够高效(虽然不是100%完美)，但简单，如果你已经在使用Camel。

小开

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

(JSON也可以采用类似的方法。)

注意，为了方便在Firefox中表达模板，演示还依赖于JavaScript 1.8表达式闭包(至少在实现方法的ES6简写形式之前是如此)。

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

小开

看看jsonpath-object-transform

小开

作为一个老问题的另一个新答案，我建议看看DefiantJS。它不是用于JSON的XSLT 等效，而是用于JSON的< em > < / em > 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>
小开

最近，我围绕着这个写了自己的小库，尽量保持接近

5.1处理模型(XSLT REC) https://www.w3.org/TR/xslt#section-Processing-Model < / p >

在几行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-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)

Cf。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用例JSON . group查询

(在:https://jsfiddle.net/YSharpLanguage/hvo24hmk/3)

Cf。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,

小开

现在有了!我最近创建了一个库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属性。最后一个是递归匹配的恒等变换。

小开

很久以前，我为我的基于jackson的json处理框架写了一个dom适配器。它用了。xom图书馆。生成的dom树可以使用java xpath和xslt工具。我做了一些非常简单的实现选择。例如，根节点总是被称为“root”，数组进入一个带有li子元素的ol节点(就像在html中一样)，而其他一切都只是一个带有原始值或另一个对象节点的子节点。

JsonXmlConverter.java

< p >用法: JsonObject sampleJson = sampleJson(); org.w3c.dom。文档domNode = JsonXmlConverter。getW3cDocument (sampleJson,“根”); < /代码> < / p >
小开

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

小开

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

在XML会议上被多次提及的一个选项是ReX解析器生成器(http://www.bottlecaps.de/rex/)——尽管在站点上完全没有记录，但可以通过搜索获得配方。

小开
可以将XSLT与JSON结合使用。 XPath(3.1)、XSLT(3.0)和XQuery(3.1)的Verson 3在某种程度上支持JSON。 这似乎在Saxon的商业版本中可用，并且可能在某个时候包含在HE版本中。 https://www.saxonica.com/html/documentation/functions/fn/parse-json.html < / p >

-

我对另一种解决方案的期望是:

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

访问任意属性并计算值

支持条件逻辑

我希望转换脚本来自于工具的外部，基于文本，最好是一种常用的语言。

潜在的替代吗?

我想知道SQL是否是一个合适的替代方案。 https://learn.microsoft.com/en-us/sql/relational-databases/json/json-data-sql-server < / p > 如果替代工具可以处理JSON和XML就太好了 https://learn.microsoft.com/en-us/sql/relational-databases/xml/openxml-sql-server < / p >

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

小开

JSON的XSLT等价物——候选工具(工具和规范)列表

工具

1. XSLT

你可以使用JSON的XSLT来实现fn: json-to-xml。

本节描述允许使用XSLT处理JSON数据的功能。

2. < a href = " https://stedolan.github。Io /jq/" rel="nofollow noreferrer">jq .

jq就像JSON数据的sed一样——你可以用它来切片、过滤、映射和转换结构化数据，就像sed、awk、grep和其他朋友让你处理文本一样简单。 不同操作系统有不同的安装包

3.jj

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

4. fx

命令行JSON处理工具

  • 不需要学习新的语法
  • 纯JavaScript
  • 格式和高亮显示
  • 独立的二进制

5. CsvCruncher

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

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

6. jl

jl ("JSON lambda")是一种用于查询和操作JSON的小型函数式语言。

7. JOLT

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

8. gron

使JSON可greppable! 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脚本，没有外部deps(除了node.js本身)。

15. jsawk最后一次提交2015年3月4日

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

16. yate最后提交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 Pointer定义了一个用于标识特定值的字符串语法

. JavaScript对象表示法(JSON)文档

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

JSPath for JSON就像XPath for XML。

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

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

小开

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
}

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

小开

CsvCruncher

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

* Tabular表示JSON树的某些部分是规则的，即一个到多个相同或相似结构的条目。

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

与真正复杂的XSLT方法相比，这种方法对我的帮助更大(尽管当您真正深入了解它时，它非常有趣)。

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


提交答案