equivalent преобразование - XSLT эквивалент для JSON




онлайн generate (21)

Недавно я написал свою небольшую библиотеку, которая пытается оставаться как можно ближе к

5.1. Модель обработки (XSLT REC) https://www.w3.org/TR/xslt#section-Processing-Model

как это возможно (как я мог это сделать), в нескольких строках кода JavaScript.

Вот несколько не совсем тривиальных примеров использования ...

1. JSON-to-some-markup:

Скрипт: 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:

Скрипт: 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-эквивалент ...

jsfiddle.net/YSharpLanguage/hvo24hmk/3 jsfiddle.net/YSharpLanguage/hvo24hmk/3

(по адресу: 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

«НТН,

Существует ли эквивалент XSLT для JSON? Что-то, что позволяет мне делать преобразования на JSON, например XSLT, для XML.


Возможно использование 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, или полностью оценил этот вариант, но я надеюсь посмотреть на него в ближайшее время. Только некоторые мысли до сих пор.


Я написал адаптер dom для моей json-обработки, основанной на jsonson, давным-давно. Он использует библиотеку nu.xom. Полученное дерево dom работает с возможностями java xpath и xslt. Я сделал некоторые варианты реализации, которые довольно просты. Например, корневой узел всегда называется «root», массивы переходят в узел ol с подчиненными элементами li (например, в html), а все остальное является только узлом с примитивным значением или другим узлом объекта.

JsonXmlConverter.java

Использование: JsonObject sampleJson = sampleJson(); org.w3c.dom.Document domNode = JsonXmlConverter.getW3cDocument(sampleJson, "root"); JsonObject sampleJson = sampleJson(); org.w3c.dom.Document domNode = JsonXmlConverter.getW3cDocument(sampleJson, "root");


Почему бы вам не преобразовать JSON в XML с помощью Mr. Data Coverter , преобразовать его с помощью XSLT и затем сменить его обратно на JSON, используя то же самое.


XSLT поддерживает JSON, как показано на XSLT

XML использует угловые скобки для токенов-разделителей, JSON использует скобки, квадратные скобки, ... I. e. Меньшее количество сопоставлений распознавания токенов в XML означает, что оно оптимизировано для декларативного преобразования, тогда как большее количество сравнений, как оператор switch, по соображениям скорости предполагают предположение о спекулятивном ветвлении, которое полезно для императивного кода на языках сценариев. Как непосредственное следствие, для разных сочетаний полуструктурированных данных вы можете сравнить производительность XSLT и javascript-движков как часть чувствительных страниц. Для незначительной полезной нагрузки данных преобразования могут работать с JSON без XML-сериализации. Решение W3 должно основываться на лучшем анализе.


json-e имеет реализации в Node.js, Python и Go.


Недавно я нашел инструмент, который мне нравится для стилизации JSON: https://github.com/twigkit/tempo . Очень простой инструмент для использования - на мой взгляд, гораздо проще работать с XSLT - нет необходимости в запросах XPATH.




JSONiq - такой стандарт, а Zorba - реализация C ++ с открытым исходным кодом. JSONiq также можно рассматривать как XQuery с добавлением JSON в качестве родного типа данных.


XSLT эквиваленты для JSON - список кандидатов (инструменты и спецификации)

инструменты

  1. XSLT

    Вы можете использовать XSLT с целью fn:json-to-xml .

    В этом разделе описываются средства, позволяющие обрабатывать данные JSON с использованием XSLT.

  2. jq Last commit 12 мая 2018 г.

    jq подобен sed для данных JSON - вы можете использовать его для среза и фильтрации, а также для преобразования и преобразования структурированных данных с той же легкостью, что sed, awk, grep и friends позволяют вам играть с текстом. Существуют пакеты установки для разных ОС.

  3. jj Последний коммит 2 марта 2018 года

    JJ - это утилита командной строки, которая обеспечивает быстрый и простой способ получения или обновления значений из документов JSON. Он работает от GJSON и SJSON под капотом.

  4. fx Last commit Март 20, 2018

    Инструмент обработки JSON командной строки

    • Не нужно изучать новый синтаксис
    • Обычный JavaScript
    • Форматирование и выделение
    • Автономный бинарный
  5. jsawk Последний коммит 4 марта 2015 г.

    Jsawk похож на awk, но для JSON. Вы работаете с массивом объектов JSON, считанных с stdin, фильтруйте их с помощью JavaScript для создания массива результатов, который печатается в stdout.

  6. json Last Commit Mar 3, 2017

    json - быстрый инструмент CLI для работы с JSON. Это однофайловый скрипт node.js без внешних отведений (кроме самого node.js).

  7. jl Last Commit 10 апр, 2018

    jl («JSON lambda») - это крошечный функциональный язык для запросов и управления JSON.

  8. yate Last Commit Март 13, 2017

    Тесты могут быть использованы в качестве документа https://github.com/pasaran/yate/tree/master/tests

  9. json-transforms Last Commit 1 декабря 2017 г.

    Обеспечивает рекурсивный подход к сопоставлению шаблонов для преобразования данных JSON. Трансформации определяются как набор правил, которые соответствуют структуре объекта JSON. Когда происходит совпадение, правило испускает преобразованные данные, необязательно рекурсивные для преобразования дочерних объектов.

  10. jsonpath-object-transform Last Commit 18 января 2017 г.

    Вытягивает данные из литерала объекта с помощью JSONPath и генерирует новые объекты на основе шаблона.

  11. JOLT Last Commit 1 мая 2018 г.

    Библиотека JSON для JSON, написанная на Java, где «спецификация» для преобразования сама является документом JSON.

  12. gron Last Commit 5 апреля 2018 г.

    Сделайте JSON greppable! gron преобразует JSON в дискретные назначения, чтобы облегчить grep для того, что вы хотите, и увидеть абсолютный «путь» к нему. Это облегчает исследование API, которые возвращают большие капли JSON, но имеют ужасную документацию.

  13. Stapling последней фиксации 16 сентября 2013 г.

    Stapling - это библиотека JavaScript, которая позволяет форматировать XSLT для объектов JSON. Вместо использования шаблонов JavaScript-шаблонов и шаблонов text / html, Stapling дает вам возможность использовать шаблоны XSLT, загруженные асинхронно с Ajax, а затем кэшированную клиентскую сторону - для анализа ваших источников данных JSON.

  14. json-e Last Commit 22 мая 2018 г.

    JSON-e - это система параметризации данных для встраивания контекста в объекты JSON. Основная идея состоит в том, чтобы рассматривать структуру данных как «шаблон» и преобразовывать ее, используя другую структуру данных в качестве контекста, для создания выходной структуры данных.

Технические характеристики:

  • JsonPointer

    JSON Pointer определяет синтаксис строки для идентификации определенного значения в документе JavaScript Object Notation (JSON).

  • JsonPath

    Выражения JSONPath всегда относятся к структуре JSON так же, как выражение XPath используются в сочетании с XML-документом

  • JSPath

    JSPath для JSON похож на XPath для XML ».

  • JSONiq

    Основным источником вдохновения для JSONiq является XQuery, который до сих пор доказал успешный и продуктивный язык запросов для полуструктурированных данных


Попробуйте JOLT . Это библиотека преобразования JSON для JSON, написанная на Java.

Он был создан специально, потому что мы не хотели играть в игру JSON -> XML -> XSLT -> XML -> JSON, а использование шаблона для любого достаточно сложного преобразования недостижимо.


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.


Я действительно устал от огромного количества шаблонов JavaScript, там, и всех их встроенных HTML-шаблонов, разных стилей разметки и т. Д., И решил Stapling которая позволяет форматировать XSLT для структур данных JSON. Не наука о ракетах - это просто JSON, анализируемый XML, а затем отформатированный с помощью документа XSLT. Это тоже быстро, не так быстро, как JavaScript-шаблоны в Chrome, но в большинстве других браузеров он, по крайней мере, так же быстро, как альтернатива JS-движка для больших структур данных.


Для рабочего doodle / доказательства концепции подхода к использованию чистого JavaScript, а также знакомого и декларативного шаблона подгоняющих выражений XSLT и рекурсивных шаблонов см. https://gist.github.com/brettz9/0e661b3093764f496e36

(Аналогичный подход может быть применен для JSON.)

Обратите внимание, что демо также полагается на закрытие эксплойтов JavaScript 1.8 для удобства отображения шаблонов в Firefox (по крайней мере, до тех пор, пока не будет реализована краткая форма ES6 для методов).

Отказ от ответственности: Это мой собственный код.


Интересная идея. Некоторые поиски в Google произвели несколько интересующих страниц, в том числе:

Надеюсь это поможет.


Говорить, что недостаток инструментов предполагает отсутствие необходимости, это просто вопрос вопроса. То же самое можно было бы применить для поддержки 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. Бросьте мне письмо, если вы хотите принять участие.


Я использую маршрут Camel umarshal (xmljson) -> to (xlst) -> marshal (xmljson). Достаточно эффективный (хотя и не 100% идеальный), но простой, если вы уже используете Camel.


Еще один новый ответ на старый вопрос, я бы предложил посмотреть на 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>

Не слишком уверен, что в этом есть необходимость, и для меня нехватка инструментов говорит о необходимости. JSON лучше всего обрабатывать как объекты (как это делается в JS в любом случае), и вы обычно используете язык самих объектов для выполнения преобразований (Java-объекты Java, созданные из JSON, то же самое для Perl, Python, Perl, c #, PHP и т. Д. на). Просто с обычными назначениями (или набором, get), циклом и т. Д.

Я имею в виду, что XSLT - это еще один язык, и одна из причин, по которой это необходимо, заключается в том, что XML не является объектной нотацией, и поэтому объекты языков программирования не являются точными (импеданс между иерархической xml-моделью и объектами / структурами).


Вам необходимо установить тип контента для приложения / json. Но -d отправляет application/x-www-form-urlencoded Content-Type application/x-www-form-urlencoded , которое не принимается со стороны Spring.

Глядя на страницу curl man , я думаю, вы можете использовать -H :

-H "Content-Type: application/json"

Полный пример:

curl --header "Content-Type: application/json" \
  --request POST \
  --data '{"username":"xyz","password":"xyz"}' \
  http://localhost:3000/api/login

( -H является коротким для --header , -d для --data )

Обратите внимание, что -request POST является необязательным, если вы используете -d , поскольку флаг -d подразумевает запрос POST.

В Windows все немного отличается. См. Комментарий.







json xslt equivalent