Эквивалент XSLT для JSON
https://stackoverflow.com/questions/1618038
-
06-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianВопрос
Существует ли XSLT эквивалент для JSON?Что-то, что позволило бы мне выполнять преобразования в JSON, как XSLT делает с XML.
Решение
Интересная идея.Поиск в Google выдал несколько интересных страниц, в том числе:
- ан набросок о том, как такой инструмент "jsonT" мог бы быть реализован, и некоторые загрузки
- некоторые обсуждение этой реализации
- компания , которая возможно, реализовали что-то подходящее
Надеюсь, это поможет.
Другие советы
Попробуйте JOLT . Это библиотека преобразования JSON в JSON, написанная на Java.
Он был создан специально потому, что мы не хотели воспроизводить " JSON - > XML - > XSLT - > XML - > JSON & Quot; игра, и использование шаблона для любого достаточно сложного преобразования не поддерживается.
Эквиваленты XSLT для JSON - список кандидатов (инструменты и спецификации)
Инструменты
- XSLT
Вы можете использовать XSLT для JSON с целью fn: преобразование json в xml.
В этом разделе описываются средства, позволяющие обрабатывать данные JSON с использованием XSLT.
- jq
jq подобен sed для обработки данных в формате JSON - вы можете использовать его для нарезки, фильтрации, сопоставления и преобразования структурированных данных с той же легкостью, с какой sed, awk, grep и friends позволяют вам играть с текстом.Существуют установочные пакеты для разных ОС.
- джей Джей
JJ - это утилита командной строки, которая предоставляет быстрый и простой способ извлечения или обновления значений из документов JSON.Он работает на GJSON и SJSON under the hood.
- валюта
Инструмент обработки JSON из командной строки
- Не нужно изучать новый синтаксис
- Простой JavaScript
- Форматирование и выделение
- Автономный двоичный файл
- jl
jl ("JSON lambda") - это крошечный функциональный язык для запросов к JSON и манипулирования им.
- ТОЛЧОК
Библиотека преобразования JSON в JSON, написанная на Java, где "спецификация" для преобразования сама по себе является документом JSON.
- грон
Сделайте JSON доступным для использования!gron преобразует JSON в дискретные назначения, чтобы упростить поиск в grep того, что вы хотите, и увидеть абсолютный "путь" к нему.Это облегчает изучение API, которые возвращают большие двоичные объекты JSON, но имеют ужасную документацию.
- json
json - это быстрый CLI-инструмент для работы с JSON.Это однофайловый node.js скрипт без внешних deps (кроме самого node.js).
- json-e
JSON-e - это система параметризации структуры данных для встраивания контекста в объекты JSON.Центральная идея состоит в том, чтобы рассматривать структуру данных как "шаблон" и преобразовывать ее, используя другую структуру данных в качестве контекста, для создания выходной структуры данных.
- JSLT
JSLT - это полноценный язык запросов и преобразований для JSON.Дизайн языка вдохновлен jq, XPath и XQuery.
- json-преобразования Последняя фиксация 1 декабря 2017 г.
Обеспечивает рекурсивный подход к преобразованию данных JSON на основе сопоставления с шаблоном.Преобразования определяются как набор правил, которые соответствуют структуре объекта JSON.Когда происходит совпадение, правило выдает преобразованные данные, при необходимости повторяясь для преобразования дочерних объектов.
- jsawk ( ястреб ) Последняя фиксация 4 марта 2015 г.
Jsawk похож на awk, но для JSON.Вы работаете с массивом объектов JSON, считанных из stdin, фильтруете их с помощью JavaScript для получения массива результатов, который печатается в stdout.
- йейт Последняя фиксация 13 марта 2017 г.
Тесты могут быть использованы в качестве документа https://github.com/pasaran/yate/tree/master/tests
- jsonpath-объект-преобразование Последний Коммит 18 января 2017 г.
Извлекает данные из объектного литерала с помощью JSONPath и генерирует новые объекты на основе шаблона.
- Сшивание Последняя фиксация 16 сентября 2013 г.
Сшивание - это библиотека JavaScript, которая позволяет форматировать XSLT для объектов JSON.Вместо использования механизма создания шаблонов JavaScript и текстовых / html-шаблонов Stapling дает вам возможность использовать шаблоны XSLT, загружаемые асинхронно с Ajax, а затем кэшируемые на стороне клиента, для анализа ваших источников данных JSON.
Технические характеристики:
- JsonPointer - указатель
Указатель JSON определяет строковый синтаксис для идентификации конкретного значения в документе JavaScript Object Notation (JSON).
- JSONPath - путь к JSONPath
Выражения JSONPath всегда ссылаются на структуру JSON таким же образом, как выражения XPath используются в сочетании с XML-документом
- JSPath
JSPath для JSON подобен XPath для XML".
- JSONiq
Основным источником вдохновения для JSONiq является XQuery, который до сих пор зарекомендовал себя как успешный и продуктивный язык запросов для полуструктурированных данных
XSLT поддерживает JSON, как показано на http://www.w3.org/TR / 30-XSLT / # JSON
XML использует угловые скобки для маркеров-разделителей, JSON использует скобки, квадратные скобки, ... I. e. Меньшее число сравнений распознавания токенов в XML означает, что он оптимизирован для декларативного преобразования, в то время как большее количество сравнений, подобно выражению switch, по соображениям скорости предполагают спекулятивный прогноз ветвления, для которого полезен императивный код в языках сценариев. Как прямое следствие, для различных наборов полуструктурированных данных вы можете захотеть сравнить производительность XSLT и движков javascript как части отзывчивых страниц. Для незначительной полезной нагрузки данных преобразования могут работать так же хорошо с JSON без XML-сериализации. Решение W3 должно основываться на лучшем анализе.
Недавно я нашел инструмент, который мне нравится для стилизации JSON: https://github.com/twigkit/tempo . Очень простой в использовании инструмент, по-моему, с ним гораздо проще работать, чем с XSLT, - нет необходимости в запросах XPATH.
jq - легкий и гибкий процессор JSON для командной строки
Он не основан на шаблонах, как XSLT, но более лаконичен. например извлечь поля name и address в массив: [. name, .address]
Учебное пособие содержит пример преобразования JSON API Twitter (и manual имеет много примеров).
Ознакомьтесь с jsonpath-object-transform
Сказать, что нехватка инструментов говорит о том, что в этом нет нужды, значит просто задавать вопрос. То же самое можно применить к поддержке X или Y в Linux (Зачем беспокоиться о разработке качественных драйверов и / или игр для такой малой ОС? И зачем обращать внимание на ОС, для которых не разрабатываются крупные компании, занимающиеся разработкой игр и оборудования?). Вероятно, люди, которым нужно будет использовать XSLT и JSON, в конечном итоге используют несколько тривиальное решение: преобразование JSON в XML. Но это не оптимальное решение?
Если у вас есть собственный формат JSON и вы хотите его отредактировать " wysywyg " в браузере XSLT будет более чем адекватным решением проблемы. Выполнение этого с традиционным программированием на JavaScript может стать проблемой в заднице.
На самом деле, я реализовал "каменный век" подход к XSLT, использование синтаксического анализа подстроки для интерпретации некоторых базовых команд для javascript, таких как вызов шаблона, дочерние процессы и т. д. Конечно, реализовать механизм преобразования с помощью объекта JSON намного проще, чем реализовать полноценный анализатор XML для анализа XSLT. Проблема заключается в том, что для использования шаблонов XML для преобразования объекта JSON необходимо проанализировать XML шаблонов.
Чтобы преобразовать объект JSON с помощью XML (или HTML, или текста, или чего-либо еще), вам необходимо тщательно продумать синтаксис и какие специальные символы вам нужно использовать для идентификации команд преобразования. В противном случае вам придётся создавать парсер для вашего собственного языка шаблонов. Пройдя по этому пути, я могу вам сказать, что это не красиво.
Обновление (12 ноября 2010 г.). После нескольких недель работы над парсером я смог оптимизировать его. Шаблоны предварительно разбираются, а команды хранятся в виде объектов JSON. Правила преобразования также являются объектами JSON, в то время как код шаблона представляет собой смесь HTML и синтаксиса доморощенного кофе, похожего на код оболочки. Мне удалось преобразовать сложный документ JSON в HTML, чтобы создать редактор документов. Код составляет около 1K строк для редактора (это для частного проекта, поэтому я не могу поделиться им) и около 990 строк для кода преобразования JSON (включает в себя команды итерации, простые сравнения, вызов шаблона, сохранение и оценку переменных). Я планирую выпустить его под лицензией MIT. Напишите мне, если хотите принять участие.
Недавно я написал свою собственную небольшую библиотеку по этому поводу, которая старается быть как можно ближе к
5.1 Модель обработки (XSLT REC) https://www.w3.org/TR/xslt#section-Processing-Model
насколько это возможно (насколько я мог бы, во всяком случае), в нескольких строках кода JavaScript.
Вот несколько не совсем тривиальных примеров использования...
1.JSON-to-some-разметка:
Скрипка: 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.запрос к оси-предку, заданный это ТАКОЙ вопрос (и, конечно же, другие).
Например, как получить скидку на продуктовый товар, зная его фирменный знак, в
{
"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
'ХТХ,
Есть сейчас! Недавно для этой цели я создал библиотеку json-transforms :
https://github.com/ColinEberhardt/json-transforms
Он использует комбинацию JSPath , DSL, смоделированного в 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 }
]
}
Это преобразование состоит из трех правил. Первый соответствует любому автомобилю, который сделан Honda, испускает объект со свойством Honda , а затем рекурсивно совпадает. Второе правило сопоставляет любой объект со свойством maker , выводя свойства model и year . Финальным является преобразование идентичности, которое рекурсивно совпадает.
В качестве еще одного нового ответа на старый вопрос, я бы предложил взглянуть на DefiantJS . Это не XSLT эквивалент для JSON, это is XSLT для JSON. & Quot; Шаблоны " раздел документации включает в себя этот пример:
<!-- 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>
Я очень устал от огромного количества шаблонизаторов JavaScript и всех их встроенных HTML-шаблонов, разных стилей разметки и т. д. и решил создать небольшую библиотеку , которая позволяет форматировать XSLT для структур данных JSON. В любом случае это не ракетостроение - это просто JSON, анализируемый в XML, а затем отформатированный с помощью документа XSLT. Это также быстро, не так быстро, как механизмы шаблонов JavaScript в Chrome, но в большинстве других браузеров это, по крайней мере, так же быстро, как альтернатива движку JS для больших структур данных.
Я использую маршевый маршрут Camel (xml json) - > к (xslt) - > маршал (xmljson). Достаточно эффективно (хотя и не на 100% идеально), но просто, если вы уже используете Camel.
очень возможно конвертировать JSON с помощью XSLT: вам нужен десериализатор JSON2SAX и сериализатор SAX2JSON.
Пример кода на Java: http://www.gerixsoft.com/blog/json/xslt4json
Yate ( https://github.com/pasaran/yate ) специально разработан после XSLT , имеет JPath (естественный эквивалент XPath для JS), компилируется в JavaScript и имеет довольно большую историю использования в производственных целях. Он практически не документирован, но чтения образцов и тестов должно быть достаточно.
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
}
Он реализован на Java поверх Джексона.
Не слишком уверен, что в этом есть необходимость, и для меня отсутствие инструментов говорит о том, что в этом нет необходимости. JSON лучше всего обрабатывать как объекты (как это делается в JS в любом случае), и вы обычно используете язык самих объектов для выполнения преобразований (Java для объектов Java, созданных из JSON, то же самое для Perl, Python, Perl, c #, PHP и т. Д. на). Просто с обычными назначениями (или set, get), зацикливанием и т. Д.
Я имею в виду, что XSLT - это просто еще один язык, и одна из причин, по которой он необходим, заключается в том, что XML не является нотацией объектов, и, следовательно, объекты языков программирования не точно соответствуют друг другу (полное сопротивление между иерархической моделью xml и объектами / структурами).
Почему бы вам не преобразовать JSON в XML с помощью мистера Data Coverter , преобразуйте его с помощью XSLT, а затем измените его на JSON, используя тот же.
Работающий рисунок / подтверждение концепции подхода к использованию чистого JavaScript вместе со знакомым и декларативным шаблоном, лежащим в основе соответствующих выражений и рекурсивных шаблонов XSLT, см. в https://gist.github.com/brettz9/0e661b3093764f496e36
(Аналогичный подход может быть использован для JSON.)
Обратите внимание, что демонстрационная версия также использует закрытие выражений JavaScript 1.8 для удобства выражения шаблонов в Firefox (по крайней мере до тех пор, пока не будет реализована краткая форма ES6 для методов).
Отказ от ответственности: это мой собственный код.
Я давным-давно написал dom-адаптер для своего фреймворка обработки json на базе jackson.Он использует библиотеку nu.xom.Результирующее дерево dom работает со средствами Java xpath и xslt.Я сделал несколько вариантов реализации, которые довольно просты.Например, корневой узел всегда называется "root", массивы переходят в узел ol с вложенными элементами li (как в html), а все остальное - это просто вложенный узел с примитивным значением или другой объектный узел.
Использование:
JsonObject sampleJson = sampleJson();
org.w3c.dom.Document domNode = JsonXmlConverter.getW3cDocument(sampleJson, "root");
Один из подходов, который еще не дан, заключается в использовании генератора синтаксического анализатора для создания синтаксического анализатора в XSLT, который анализирует JSON и создает вывод XML.
Одним из вариантов, который часто упоминается на конференциях XML, является генератор синтаксических анализаторов ReX ( http: // www .bottlecaps.de / rex / ) - хотя на сайте нет документов, рецепты доступны для поиска.
Возможно, удастся использовать XSLT с JSON.Версия 3 XPath(3.1), XSLT (3.0) и XQuery (3.1) некоторым образом поддерживают JSON.Похоже, это доступно в коммерческой версии Saxon и может в какой-то момент быть включено в версию HE.https://www.saxonica.com/html/documentation/functions/fn/parse-json.html
-
Чего бы я ожидал от альтернативного решения:
Я бы хотел иметь возможность вводить JSON для получения соответствующего набора данных и выводить JSON или ТЕКСТ.
Получите доступ к произвольным свойствам и оцените их значения
Поддержка условной логики
Я бы хотел, чтобы сценарии преобразования были внешними по отношению к инструменту, основанными на тексте и предпочтительно на часто используемом языке.
Потенциальная альтернатива?
Интересно, может ли 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 и не оценивал полностью этот вариант, но я надеюсь изучить его подробнее в ближайшее время.Пока просто несколько мыслей.
JSON-e имеет реализации в Node.js, Python и Go.
