У меня есть приложение, которое работает немного медленнее в Интернете из-за причин пропускной способности. Я включил GZip, который улучшил время загрузки значительным amout, но я также рассматривал возможность перехода от XML к JSON, чтобы выжать этот последний бит производительности. Использует ли JSON размер сообщения значительно меньше или немного меньше? Скажем, мы говорим о 250 КБ данных XML (который сжимается до 30 КБ).
Как JSON сравнивается с XML с точки зрения размера файла и времени сериализации/десериализации?
Ответ 1
Не ответ, а скорее предложение изучить ваши предположения.
Чем меньше JSON?
JSON:
"person":{"firstname":"Fred",
"lastname":"Flintstone",
"age":38,
"spouse":"Wilma" }
XML:
<person firstname='Fred'
lastname='Flintstone'
age='38'
spouse='Wilma'/>
Я просто не понимаю, как, в общем, выражение JSON будет на 30% меньше, чем "эквивалентный" XML. Даже когда вы увеличиваете сложность этих вещей, с вложенными структурами и массивами, это не будет 30% -ной разницей. Это примерно эквивалентно, поскольку json получает преимущество, потому что конечный тег вложенной структуры - это}, в то время как XML получает преимущество, потому что ему не нужно указывать имена полей.
Если вы заставили меня использовать XML-элементы, например:
<person>
<firstname>Fred<firstname>
<lastname>Flintstone<lastname>
<age>38</age>
<spouse>Wilma</spouse>
</person>
... конечно, полученный XML больше, чем предыдущий JSON. Но это похоже на обман.
Теперь может случиться так, что способ форматирования вашего XML в настоящее время использует элементы для всего, и что есть возможность соответственно сократить полезную нагрузку. Но это не обязательно означает JSON. Если у вас есть инструменты и библиотеки, которые обрабатывают XML, вы можете сохранить XML и сжать.
Ответ 2
В терминах сериализации объектов JSON обычно будет более компактным (даже при сжатии). Например:
Я сериализовал один и тот же экземпляр объекта в XML и JSON и получил следующее:
JSON
{
"Account": "2222",
"Login": "124235",
"SalesId": null,
"CustomerReference": "9652358474",
"Status": null,
"DropShip": 0,
"PromoCode": null,
"Notes": "For the truck",
"Errors": null,
"ReferenceId": null,
"PaymentMethod": "CKPhone",
"CheckPayment": {
"Name": "Simon Riggs",
"CompanyName": "Darth Inc",
"AccountNumber": "565555555",
"RoutingNumber": "222224455116",
"CheckNumber": "32",
"Address": {
"Attention": null,
"Street1": "555 W Portebello Rd",
"Street2": null,
"City": "London",
"State": "Texas",
"Zipcode": "45217",
"Country": null,
"ReferenceId": null,
"GetAxType": 2
},
"ReferenceId": null,
"GetAxType": 2
},
"CreditCardPayment": {
"Name": "Simon Riggs",
"CardNumber": "1111222233334444",
"Cvv2": "546",
"Month": 10,
"Year": 2018,
"Address": {
"Attention": null,
"Street1": "555 W Portebello Rd",
"Street2": null,
"City": "London",
"State": "Texas",
"Zipcode": "45217",
"Country": null,
"ReferenceId": null,
"GetAxType": 2
},
"ReferenceId": "0",
"GetAxType": 2
},
"ShippingAddress": {
"Attention": "Simon Riggs",
"Street1": "555 W Portebello Rd",
"Street2": null,
"City": "London",
"State": "Texas",
"Zipcode": "45217",
"Country": null,
"ReferenceId": null,
"GetAxType": 2
},
"Totals": {
"SubTotal": 25.0,
"TotalTax": 5.0,
"ShippingTotal": 10.0,
"ShippingTax": 1.5,
"GrandTotal": 35.0
},
"Lines": [{
"SKU": "1442-4521",
"LineNum": 0.0,
"Qty": 2.0,
"Price": 72.95,
"ShippingClass": "Ground",
"ReferenceId": null,
"GetAxType": 2
},
{
"SKU": "1212-5549",
"LineNum": 0.0,
"Qty": 1.0,
"Price": 31.15,
"ShippingClass": "Ground",
"ReferenceId": null,
"GetAxType": 2
}],
"GetAxType": 2
}
XML
<?xml version="1.0" encoding="utf-16"?>
<SalesOrder xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<Account>2222</Account>
<Login>124235</Login>
<CustomerReference>9652358474</CustomerReference>
<DropShip>0</DropShip>
<Notes>For the truck</Notes>
<PaymentMethod>CKPhone</PaymentMethod>
<CheckPayment>
<Name>Simon Riggs</Name>
<CompanyName>Darth Inc</CompanyName>
<AccountNumber>565555555</AccountNumber>
<RoutingNumber>222224455116</RoutingNumber>
<CheckNumber>32</CheckNumber>
<Address>
<Street1>555 W Portebello Rd</Street1>
<City>London</City>
<State>Texas</State>
<Zipcode>45217</Zipcode>
</Address>
</CheckPayment>
<CreditCardPayment>
<Name>Simon Riggs</Name>
<CardNumber>1111222233334444</CardNumber>
<Cvv2>546</Cvv2>
<Month>10</Month>
<Year>2018</Year>
<Address>
<Street1>555 W Portebello Rd</Street1>
<City>London</City>
<State>Texas</State>
<Zipcode>45217</Zipcode>
</Address>
<ReferenceId>0</ReferenceId>
</CreditCardPayment>
<ShippingAddress>
<Attention>Simon Riggs</Attention>
<Street1>555 W Portebello Rd</Street1>
<City>London</City>
<State>Texas</State>
<Zipcode>45217</Zipcode>
</ShippingAddress>
<Totals>
<SubTotal>25</SubTotal>
<TotalTax>5</TotalTax>
<ShippingTotal>10</ShippingTotal>
<ShippingTax>1.5</ShippingTax>
<GrandTotal>35</GrandTotal>
</Totals>
<Lines>
<SalesLine>
<SKU>1442-4521</SKU>
<LineNum>0</LineNum>
<Qty>2</Qty>
<Price>72.95</Price>
<ShippingClass>Ground</ShippingClass>
</SalesLine>
<SalesLine>
<SKU>1212-5549</SKU>
<LineNum>0</LineNum>
<Qty>1</Qty>
<Price>31.15</Price>
<ShippingClass>Ground</ShippingClass>
</SalesLine>
</Lines>
</SalesOrder>
При кодировании в ASCII JSON составляет 1422 байта, а XML - 1954 байта. После сжатия их с помощью GZipStream разница меньше, но все еще довольно ясна. JSON сжимает до 524 байта, в то время как XML сжимает до 695 байт.
Время сериализации/десериализации будет зависеть от реализации (и аппаратного обеспечения, конечно), но я сериализовал и десериализовал указанные выше JSON и XML 100 000 раз в цикле и получил общее количество накоплений:
JSON Сериализация: 5258 мс, Сериализация XML: 3266 мс
JSON Deserialization: 9582 мс, XML Deserialization: 4604 мс
Итак, XML сериализуется и десериализуется быстрее, используя библиотеки, которые я использую (см. ниже), но со средними значениями за сотые миллисекунды я бы сказал, что пропускная способность сети и время передачи более значимы.
(Примечание: я сделал это на С#, используя классы Microsoft System.Xml.Serialization.XmlSerializer и JSON.Net Newtonsoft.Json.JsonConvert)
Ответ 3
на самом деле это сложнее ответить тогда, кажется,
несколько лет назад json был "быстрее", но различия между ними стали более тонкими.
то, что я наблюдал,
- xml сжимается лучше с помощью gzip, тогда json.. время, сохраненное в загрузке, может компенсировать другие компоненты.
- XML-анализ/запрос в raw js примерно равен json
- XML-парсинг/запрос в jquery намного медленнее... Я не буду жалеть разработчиков jQuery, чтобы сосредоточиться на json
В целом технология, которая ускоряет работу с современными браузерами, также относится и к обработке XML.
вообще, всякий раз, когда я слышу, как json рекламируется как альтернатива "lowfat" для XML, я задаюсь вопросом, не является ли его не какая-то подсознательная навязчивая идея с весом... вот в мои пессимистические дни;
основное правило, которым я придерживаюсь,
разметка хорошая для документов json подходит для данных
и двигаться дальше... ничего не увидеть здесь
Ответ 4
Лучший способ ответить на этот вопрос - проверить его самостоятельно, поскольку задействовано сжатие. Вы также аккуратно избегаете священной войны XML против JSON путем объективного ответа!
Поскольку это просто тест и на самом деле не нужно работать, вы можете просто написать XML-конвертер json в javascript, который прошел дерево XML DOM и скопировал его в структуру вложенных массивов/объектов, а затем передал его JSON.stringify(). Единственный сложный бит будет решать, что станет массивом, и что станет объектом.
Найдите репрезентативную выборку (или несколько) отправляемых данных, конвертируйте ее в JSON с помощью своего инструмента, gzip и оригинального XML и сравните размеры.
Примечание. Я искал онлайн-конвертер XML- > JSON, и все они были ужасны - пропуски copius вне кавычек (незаконные в JSON, изменяют размер) и некорректные имена ключей (ditto). Не используйте их для теста, или вы получите плохие данные.
Ответ 5
Да JSON будет примерно на 30% быстрее, чем меньше символов, проходящих по линии, и очень быстро разобрать.
Ypu также может взглянуть на "YAML", который отправляет абсолютное минимальное количество метаданных в сообщении.
Ответ 6
Вообще говоря, JSON намного быстрее и меньше, чем эквивалентный XML. XML богаче тем, что вы можете хранить метаданные (атрибуты) и контент отдельно, но то же самое может быть достигнуто в JSON с соответствующими соглашениями о структурировании.
Ответ 7
Существуют различные способы представления JSON, такие как BSON и CBOR, которые уменьшают его размер.
Ответ 8
<person firstname='Fred'
lastname='Flintstone'
age='38'
spouse='Wilma'/>
"person":{"firstname":"Fred",
"lastname":"Flintstone",
"age":38,
"spouse":"Wilma" }
XML: 80 символов
JSON: 92 символа.
XML - это 13% более тонкий победитель, который подумал бы обо всех фиктивных претензиях?
[Пример, взятый из Cheeso выше. Обратите внимание, что типы возврата каретки изменяют размер, но одинаково для обоих. Без каких-либо возвратов в этом отношении отношение равно XML: 74, JSON: 86, разница 14%]
Кто-то утверждал в этом обсуждении, что "использование атрибутов для контента обманывает" (цитируя [this] [1]).
1) Молитесь, как хорошо сформированный XML "обманывает"? Если он не обманывает (очень длинную) спецификацию, то пусть, пожалуйста, справитесь с этим. Действителен..
2) В этом случае ASP.NET web.config является "обманом", среди тысячи других примеров больших собак.
<forms loginUrl="~/Home/Login"
defaultUrl="~/Home"
timeout="2880"
requireSSL="false"
slidingExpiration="true" />
Чтобы быть справедливым, есть те, кто имеет тенденцию иметь раздутый XML-менталитет в том, как они образуют XML.
Но не следует сказать, что 13% тонкое XML-сорт не так важен. И, таким образом, он даже превосходит JSON (по размеру).
[1]: http://www.ibm.com/developerworks/xml/library/x-eleatt/index.html [статья 2004 года, заметьте]