Существует ли XSLT эквивалент для JSON? Что-то, что позволяет мне делать преобразования в JSON, например XSLT, в XML.
XSLT эквивалент для JSON
Ответ 1
Интересная идея. Некоторые поиски в Google произвели несколько интересующих страниц, в том числе:
- a план о том, как можно реализовать такой инструмент jsonT, и некоторые загрузки
- some обсуждение этой реализации
- компания, которая может реализовать что-то подходящее
Надеюсь, что это поможет.
Ответ 2
Попробуйте JOLT. Это библиотека преобразования JSON для JSON, написанная на Java.
Он был создан специально, потому что мы не хотели играть в игру JSON → XML → XSLT → XML → JSON, а использование шаблона для любого достаточно сложного преобразования недостижимо.
Ответ 3
XSLT-эквиваленты для JSON - список кандидатов (инструменты и спецификации)
инструменты
- XSLT
Вы можете использовать XSLT для JSON с целью fn: json-to-xml.
В этом разделе описываются средства, позволяющие обрабатывать данные JSON с использованием XSLT.
- JQ
jq похож на sed для данных JSON - вы можете использовать его для нарезки, фильтрации, отображения и преобразования структурированных данных с той же легкостью, с которой sed, awk, grep и friends позволяют вам играть с текстом. Есть инсталляционные пакеты для разных ОС.
- JJ
JJ - это утилита командной строки, которая обеспечивает быстрый и простой способ извлечения или обновления значений из документов JSON. Он работает на GJSON и SJSON под капотом.
- FX
Средство обработки JSON из командной строки
- Не нужно изучать новый синтаксис
- Простой JavaScript
- Форматирование и выделение
- Автономный бинарный
- JL
jl ("JSON lambda") - крошечный функциональный язык для запросов и управления JSON.
- тряска
Библиотека преобразования JSON в JSON, написанная на Java, где "спецификация" для преобразования сама является документом JSON.
- Грон
Сделайте JSON greppable! gron преобразует JSON в отдельные назначения, чтобы упростить поиск того, что вам нужно, и увидеть абсолютный "путь" к нему. Это облегчает исследование API, которые возвращают большие двоичные объекты JSON, но имеют ужасную документацию.
- JSON
json - это быстрый инструмент CLI для работы с JSON. Это однофайловый скрипт node.js без внешних deps (кроме самого node.js).
- JSON-е
JSON-e - это система параметризации структуры данных для встраивания контекста в объекты JSON. Основная идея состоит в том, чтобы рассматривать структуру данных как "шаблон" и преобразовывать ее, используя другую структуру данных в качестве контекста, для создания структуры выходных данных.
- JSLT
JSLT - это полный язык запросов и преобразований для JSON. Дизайн языка вдохновлен jq, XPath и XQuery.
- json-transforms Последний коммит 1 декабря 2017 г.
Предоставляет рекурсивный подход сопоставления с образцом для преобразования данных JSON. Преобразования определяются как набор правил, которые соответствуют структуре объекта JSON. Когда происходит совпадение, правило генерирует преобразованные данные, необязательно повторяющиеся для преобразования дочерних объектов.
- jsawk Последний коммит 4 марта 2015
Jsawk похож на awk, но для JSON. Вы работаете с массивом JSON-объектов, считываемых из stdin, фильтруете их с помощью JavaScript, чтобы создать массив результатов, который выводится на стандартный вывод.
- yate Last Commit 13 марта 2017 г.
Тесты могут быть использованы как документ https://github.com/pasaran/yate/tree/master/tests
- jsonpath-object-transform Последний коммит 18 января 2017 г.
Извлекает данные из литерала объекта с помощью JSONPath и создает новые объекты на основе шаблона.
- Сшивание последнего коммита 16 сентября 2013
Сшивание - это библиотека JavaScript, которая позволяет форматировать XSLT для объектов JSON. Вместо использования механизма шаблонов JavaScript и шаблонов text/html Stapling дает вам возможность использовать шаблоны XSLT - загружаемые асинхронно с Ajax, а затем кэшированные на стороне клиента - для анализа ваших источников данных JSON.
Технические характеристики:
- JsonPointer
JSON Pointer определяет строковый синтаксис для определения конкретного значения в документе JavaScript Object Notation (JSON).
- JsonPath
Выражения JSONPath всегда ссылаются на структуру JSON так же, как выражения XPath используются в сочетании с документом XML.
- JSPath
JSPath для JSON похож на XPath для XML ".
- JSONiq
Основным источником вдохновения для JSONiq является XQuery, который до сих пор оказался успешным и продуктивным языком запросов для полуструктурированных данных.
Ответ 4
Недавно я нашел инструмент, который мне нравится для стилизации JSON: https://github.com/twigkit/tempo. Очень простой инструмент для использования - на мой взгляд, гораздо проще работать с XSLT - нет необходимости в запросах XPATH.
Ответ 5
XSLT поддерживает JSON, как показано на http://www.w3.org/TR/xslt-30/#json
XML использует скобки angular для токенов-разделителей, JSON использует фигурные скобки, квадратные скобки,... I. e. XML меньше сопоставлений распознавания токенов означает, что он оптимизирован для декларативного преобразования, тогда как больше сравнений, как оператор switch, по соображениям скорости предполагают предположение о спекулятивном ветвлении, которое полезно для императивного кода на языках сценариев. Как непосредственное следствие, для разных сочетаний полуструктурированных данных вы можете сравнить производительность XSLT и javascript-движков как часть чувствительных страниц. Для незначительной полезной нагрузки данных преобразования могут работать с JSON без XML-сериализации. Решение W3 должно основываться на лучшем анализе.
Ответ 6
jq - легкий и гибкий процессор JSON с командной строкой
Это не шаблон, как XSLT, но более сжатый. например для извлечения полей name и address в массив: [.name, .address]
tutorial проходит пример преобразования JSON API Twitter (и manual имеет много примеров).
Ответ 7
Говорить о недостатке инструментов означает отсутствие необходимости - это просто попросить вопрос. То же самое можно было бы применить для поддержки 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 и синтаксиса homebrew, аналогичного коду оболочки. Я смог преобразовать сложный документ JSON в HTML, чтобы сделать редактор документов. Код составляет около 1 тыс. Строк для редактора (он для частного проекта, поэтому я не могу его разделить) и около 990 строк для кода преобразования JSON (включает в себя команды итерации, простые сравнения, вызов шаблона, сохранение переменных и оценку). Я планирую выпустить его под лицензией MIT. Бросьте мне письмо, если вы хотите принять участие.
Ответ 8
Посмотрите jsonpath-object-transform
Ответ 9
Недавно я написал свою собственную маленькую библиотеку, которая старается держаться как можно ближе к
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-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 против 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 в отношении. запрос к оси предка, как это поднимается этим 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
"НТН,
Ответ 10
Теперь есть! Недавно я создал библиотеку 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. Финал - это тождественное преобразование, которое рекурсивно соответствует.
Ответ 11
Как еще один новый ответ на старый вопрос, я бы предложил посмотреть DefiantJS. Это не эквивалент XSLT для JSON, а - XSLT для JSON. Раздел "Templating" документации включает в себя этот пример:
<!-- 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>
Ответ 12
Я действительно устал от огромного количества шаблонов JavaScript, там и всех встроенных HTML-шаблонов, разных стилей разметки и т.д., и решил создать небольшую библиотеку, которая позволяет форматировать XSLT для структур данных JSON. Не наука о ракетах - это просто JSON анализировал XML, а затем форматировал документ XSLT. Это тоже быстро, не так быстро, как движки JavaScript-шаблонов в Chrome, но в большинстве других браузеров он, по крайней мере, так же быстро, как альтернатива JS-движка для более крупных структур данных.
Ответ 13
JSONiq является таким стандартом и Zorba реализация С++ с открытым исходным кодом. JSONiq также можно рассматривать как XQuery с добавлением JSON в качестве нативного типа данных.
Ответ 14
Я использую маршрут Camel umarshal (xmljson) → to (xlst) → marshal (xmljson). Достаточно эффективный (хотя и не 100% совершенный), но простой, если вы уже используете Camel.
Ответ 15
очень удобно конвертировать JSON с помощью XSLT: вам нужен десериализатор JSON2SAX и сериализатор SAX2JSON.
Пример кода в Java: http://www.gerixsoft.com/blog/json/xslt4json
Ответ 16
Yate (https://github.com/pasaran/yate) специально разработан после XSLT, имеет JPath (естественный эквивалент XPath для JS), компилируется на JavaScript и имеет довольно историю использования продукции. Его практически недокументированное, но чтение образцов и тестов должно быть достаточно.
Ответ 17
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 поверх Jackson.
Ответ 18
Не слишком уверен, что в этом есть необходимость, а мне недостаток инструментов говорит о необходимости. JSON лучше всего обрабатывать как объекты (как это делается в JS в любом случае), и вы обычно используете язык самих объектов для выполнения преобразований (Java-объекты Java, созданные из JSON, то же самое для Perl, Python, Perl, С#, PHP и т.д. на). Просто с обычными назначениями (или набором, get), циклом и т.д.
Я имею в виду, что XSLT - это еще один язык, и одна из причин, по которой он нужен, заключается в том, что XML не является объектной нотацией, и поэтому объекты языков программирования не являются точными (импеданс между иерархической xml-моделью и объектами/структурами).
Ответ 19
Почему бы вам не преобразовать JSON в XML с помощью Mr. Data Coverter, преобразуйте его с помощью XSLT, а затем измените его на JSON, используя тот же самый.
Ответ 20
Для рабочего doodle/доказательства концепции подхода к использованию чистого JavaScript вместе со знакомым и декларативным шаблоном для подходов XSLT-соответствия и рекурсивных шаблонов см. https://gist.github.com/brettz9/0e661b3093764f496e36
(Аналогичный подход может быть применен для JSON.)
Обратите внимание, что демонстрационная версия также использует ограничения на эксплойт JavaScript 1.8 для удобства выражения шаблонов в Firefox (по крайней мере, до тех пор, пока не будет реализована краткая форма ES6 для методов).
Отказ от ответственности: это мой собственный код.
Ответ 21
Я уже давно написал адаптер dom для моей json-обработки json. Он использует библиотеку nu.xom. Полученное дерево dom работает с возможностями java xpath и xslt. Я сделал некоторые варианты реализации, которые довольно просты. Например, root node всегда называется "root", массивы переходят в ol node с подчиненными элементами li (например, в html), а все остальное - это только суб node с примитивным значением или другим объектом node.
Использование:
JsonObject sampleJson = sampleJson();
org.w3c.dom.Document domNode = JsonXmlConverter.getW3cDocument(sampleJson, "root");
Ответ 22
Один из подходов, которые еще не заданы, - использовать генератор парсера для создания синтаксического анализатора в XSLT, который анализирует JSON и выдает XML-вывод.
Один из вариантов, который много упоминается на конференциях XML, - генератор парсеров ReX (http://www.bottlecaps.de/rex/) - хотя полностью недокументирован на сайт, рецепты доступны при поиске.
Ответ 23
Возможно использование XSLT с JSON. Verson 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 или 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, или полностью оценил этот вариант, но я надеюсь, что он будет рассмотрен в ближайшее время. До сих пор некоторые мысли.
Ответ 24
JSON-e имеет реализации в Node.js, Python и Go.
Ответ 25
Просто нашел С# потрясающую реализацию. Он называется Just.Net и работает как шарм.