Почему JSON важный?

JSON получил широкое распространение прежде всего потому, что он предлагает способ обойти политику того же происхождения, которая используется в веб-браузерах, и тем самым разрешить гибридные приложения.

Допустим, вы пишете веб-сервис в домене A. Вы не можете загружать XML-данные из домена B и анализировать их, потому что единственный способ сделать это - XMLHttpRequest, а XMLHttpRequest изначально был ограничен тем же источником политика обращения только к URL-адресам в том же домене, что и содержащая страница.

Оказывается, по ряду причин вам разрешено запросить < script > теги по происхождению. Умные люди поняли, что это хороший способ обойти ограничение с XMLHttpRequest. Вместо того чтобы сервер возвращал XML, он может возвращать серию литералов объектов и массивов JavaScript.

(бонусный вопрос оставлен читателю в качестве упражнения: почему < script src = "..." > разрешен для доменов без согласия сервера, а XHR - нет?)

Конечно, возвращая < скрипт > который состоит только из объектных литералов и не полезен, потому что, не присваивая значения какой-либо переменной, вы ничего не можете с этим сделать. Таким образом, большинство служб используют вариант JSON, называемый JSONP ( http://bob.pythonmac.org/archives/2005/12/05/remote-json-jsonp/ ).

С ростом популярности гибридных приложений люди поняли, что JSON является удобным форматом обмена данными в целом, особенно когда JavaScript является одним из концов канала. Например, JSON широко используется в Chromium даже в тех случаях, когда C ++ находится на обеих сторонах. Это просто удобный способ представления простых данных, для которых существуют хорошие парсеры во многих языках.

Забавно, используя < script > теги для создания гибридных приложений невероятно небезопасны, потому что они, по сути, специально предназначены для XSS. Таким образом, родной JSON ( http://ejohn.org/blog/native-json-support-is-required/ ) должен был быть представлен, что устраняет первоначальные преимущества формата. Но к тому времени это было уже супер популярно :)

Это зависит от того, что вы собираетесь делать. Здесь много ответов, которые предпочитают JSON XML. Если вы посмотрите глубже, то большой разницы не будет.

Если у вас есть дерево объектов, вы получаете только дерево объектов JavaScript. Если вы посмотрите на напряжение, чтобы использовать доступ в стиле ООП, то снова оборачивается. Предположим, у вас есть объект типа A, B, C, который построен в дереве. Вы можете легко включить их сериализацию в JSON. Если вы прочитаете их обратно, вы получите только дерево объектов javascript. Чтобы восстановить ваши A, B, C, вы должны вручную сложить значения в созданные вручную объекты, или вы делаете некоторые хаки. Похоже на разбор XML и создание объектов? Ну да:)

В настоящее время только новейшие браузеры поставляются с встроенной поддержкой JSON. Для поддержки большего количества браузеров у вас есть два варианта: а) вы загружаете javasser в javascript, который поможет вам в разборе. Итак, как жир это звучит в отношении жирности? Другой вариант, как я часто вижу, это eval. Вы можете просто выполнить eval () для строки JSON, чтобы получить объекты. Но это вводит совершенно новый набор проблем безопасности. JSON указан, поэтому он не может содержать функции. Если вы не проверяете объекты на функцию, кто-то может легко отправить вам исполняемый код.

Так что это может зависеть от того, что вам нравится больше: JSON или XML. Самое большое различие - это, вероятно, способы доступа к вещам, будь то теги сценария XMLHTTPRequest ... Я бы определился с этим, что использовать. По моему мнению, если бы в браузерах была надлежащая поддержка XPATH, я бы часто решал использовать XML. Но мода направлена ​​на json и загрузку дополнительных парсеров json в javascript.

Если вы не можете решить и знаете, что вам нужно что-то действительно мощное, вам стоит взглянуть на YAML. Читать о YAML очень интересно, чтобы лучше понять эту тему. Но это действительно зависит от того, что вы пытаетесь сделать.

JSON - это текстовый формат сериализации объектов, более легкий, чем XML, который напрямую интегрируется с объектной моделью JavaScript. Это большинство его преимуществ прямо здесь.

Его недостатки (по сравнению с XML) примерно таковы: меньше доступных инструментов (забудьте о стандартной проверке и / или преобразовании, не говоря уже о выделении синтаксиса или проверке правильности в большинстве редакторов), с меньшей вероятностью удобочитаемы для человека. (Существуют огромные различия в удобочитаемости как JSON, так и XML, так что это обязательно нечеткое утверждение), тесная интеграция с JavaScript делает не очень тесную интеграцию с другими средами.

If you are working in Javascript, it is much easier to us JSON. This is because JSON can be directly evaluated into a Javascript object, which is much easier to work with than the DOM.

Borrowing and slightly altering the XML and JSON from above

XML:

<person>
    <name>John Doe</name>
    <tag>friend</tag>
    <tag>male</tag>
</person>

JSON:

{ person: {"name": "John Doe", "tag": ["friend", "male"]} }

If you wanted to get the second tag object with XML, you'd need to use the powerful but verbose DOM apis:

var tag2=xmlObj.getElementsByTagName("person")[0].getElementsByTagName("tag")[1];

Whereas with a Javascript object that came in via JSON, you could simply use:

var tag2=jsonObj.person.tag[1];

Of course, Jquery makes the DOM example much simpler:

var tag2=$("person tag",xmlObj).get(1);

However, JSON just "fits" in a Javascript world. If you work with it for a while, you will find that you have much less mental overhead than involving XML based data.

All the above examples ignore the possibility that one or more nodes are available, duplicated, or the possibility that the node has just one or no children. However, to illustrate the native-ness of JSON, to do this with the jsonObj, you'd just have to:

var tag2=(jsonObj.person && jsonObj.person.tags && jsonObj.person.tags.sort && jsonObj.person.tags.length==2 ? jsonObj.person.tags[1] : null);

(some people might not like that long of ternary, but it works). But XML would be (in my opinion) nastier (I don't think you'd want to go the ternary approach because you'd keep calling the dom methods which may have to do the work over again depending on implementation):

var tag2=null;
var persons=xmlObj.getElementsByTagName("person");
if(persons.length==1) {
    var tags=persons[0].getElementsByTagName("tag");
    if(tags.length==2) { tag2=tags[1]; }
}

Jquery (untested):

var tag2=$("person:only-child tag:nth-child(1)",xmlObj).get(0);

У XML есть несколько недостатков:

• Он тяжелый!
• Он обеспечивает иерархическое представление контента, которое не совсем совпадает (но в значительной степени похоже на) объектную модель Javascript.
• Javascript доступен везде. Без каких-либо внешних анализаторов вы можете обрабатывать JSON напрямую с помощью интерпретатора JS.

Очевидно, что он не предназначен для полной замены XML. Его преимущества могут быть полезны для веб-приложений на основе JS.

JSON, как правило, намного меньше, чем его XML-эквивалент. Меньшая передача означает более быструю передачу, что приводит к улучшению взаимодействия с пользователем.

JSON - это способ сериализации данных в объектах Javascript. Синтаксис взят из языка, поэтому он должен быть знаком разработчику, работающему с Javascript, и - будучи строковой структурой объекта - это более естественный метод сериализации для взаимодействия в браузере, чем полноценная производная XML (со всеми произвольными проектными решениями, которые это подразумевает).

Это легко и интуитивно понятно.

JSON гораздо более лаконичен. XML:

<person>
    <name>John Doe</name>
    <tags>
        <tag>friend</tag>
        <tag>male</tag>
   </tags>
</person>

JSON:

{"name": "John Doe", "tags": ["friend", "male"]}

Также есть меньше перекрывающихся функций. Например, в XML существует противоречие между выбором использования элементов (как указано выше) и атрибутов ( ).

Дело не в том, что это лучше, а в том, что он может связывать многие вещи вместе, чтобы обеспечить беспрепятственную передачу данных без анализа вручную!

Для пример javascript -> веб-служба C # -> javascript

JSON обычно меньше, чем эквивалент XML. Меньший размер передачи означает более быструю передачу, что улучшает взаимодействие с пользователем.