Por que todos estão escolhendo JSON sobre XML para jQuery? [fechadas]

Eu pensei que o XML é altamente portátil e pode ser usado como um mini banco de dados. Eu vi o XML usado em todos os lugares. Eu até vejo grandes empresas migrando para o JSON . Até a Microsoft tem suporte integrado para JSON. Qual é todo o hype sobre JSON?

Basicamente, porque o JSON é reconhecido nativamente pelo JavaScript, é realmente leve, minimalista e altamente portátil, porque conta apenas com duas estruturas fundamentais:

• Uma coleção de pares nome / valor. Em vários idiomas, isso é realizado como um objeto, registro, estrutura, dicionário, tabela de hash, lista de chaves ou matriz associativa.
• Uma lista ordenada de valores. Na maioria dos idiomas, isso é realizado como uma matriz, vetor, lista ou sequência.

O XML realmente não começa a brilhar até você começar a misturar diferentes esquemas no espaço de nome. Então você vê o JSON começar a cair, mas se você só precisa de um formato de serialização para seus dados, o JSON é menor, mais leve, mais legível por humanos e geralmente mais rápido que XML.

Acho que um grande benefício do JSON sobre XML é que não preciso decidir como formatar os dados. Como alguns demonstraram, existem inúmeras maneiras de criar estruturas de dados simples em XML - como elementos, como valores de atributos etc. Então você precisa documentá-lo, escrever XML Schema ou Relax NG ou alguma outra porcaria ... uma bagunça.

O XML pode ter seus méritos, mas para o intercâmbio básico de dados, o JSON é muito mais compacto e direto. Como desenvolvedor de Python, não há incompatibilidade de impedância entre os tipos de dados simples no JSON e no Python. Portanto, se eu estivesse escrevendo um manipulador do lado do servidor para uma consulta AJAX que perguntasse sobre as condições de neve de um resort de esqui em particular, criaria um dicionário da seguinte maneira:

conditions = {
    'new_snow_24': 5.0,
    'new_snow_48': 8.5,
    'base_depth': 88.0,
    'comments': 'Deep and steep!',
    'chains_required': True,
}
return simplejson.dumps(conditions)   # Encode and dump `conditions` as a JSON string

Quando traduzida através do JSON (usando uma biblioteca como 'simplejson' para Python), a estrutura JSON resultante parece quase idêntica (exceto no JSON, os booleanos são minúsculos).

A decodificação dessa estrutura requer apenas um analisador JSON, seja para Javascript ou Objective-C para um aplicativo nativo do iPhone ou C # ou um cliente Python. Os carros alegóricos seriam interpretados como carros alegóricos, as cadeias como cadeias e os booleanos como booleanos. Usando a biblioteca 'simplejson' em Python, uma simplejson.loads(some_json_string)declaração me devolveria uma estrutura de dados completa, como acabei de criar no exemplo acima.

Se eu escrevesse XML, teria que decidir se faria elementos ou atributos. Ambos os seguintes são válidos:

<conditions>
    <new-snow-24>5</new-snow-24>
    <new-snow-48>8.5</new-snow-48>
    <chains-required>yes</chains-required>
    <comments>deep and steep!</comments>
</conditions>

<conditions newSnow24="5" newSnow48="8.5" chainsRequired="yes">
   <comments>deep and steep!</comments>
</conditions>

Portanto, não apenas tenho que pensar nos dados que posso enviar para o cliente, mas também em como formatá-los. O XML, embora seja mais simples que o SGML simples por ser mais rigoroso com suas regras, ainda oferece muitas maneiras de pensar sobre esses dados. Então eu teria que continuar gerando. Eu não poderia simplesmente pegar um dicionário Python (ou outra estrutura de dados simples) e dizer "vá se transformar no meu XML". Não pude receber um documento XML e dizer imediatamente "vá se transformar em objetos e estruturas de dados" sem escrever um analisador personalizado ou sem exigir a sobrecarga adicional do XML Schema / Relax NG e de outros problemas.

A questão é que é muito mais fácil e muito mais direto codificar e decodificar dados para JSON, especialmente para trocas rápidas. Isso pode se aplicar mais a pessoas provenientes de uma linguagem dinâmica, pois os tipos de dados básicos (listas, dicionários etc.) incorporados ao JavaScript / JSON são diretamente mapeados para os mesmos tipos de dados ou similares em Python, Perl, Ruby, etc.

O desempenho do JSON não é muito diferente do XML na maioria dos casos de uso, o JSON não é adequado e legível para estruturas profundamente aninhadas ... você encontrará]]]}], o que dificulta a depuração

É leve comparado ao XML. Se você precisar escalar, reduza os requisitos de largura de banda!

Compare JSON

 [
      {
           color: "red",
           value: "#f00"
      },
      {
           color: "green",
           value: "#0f0"
      },
      {
           color: "blue",
           value: "#00f"
      },
      {
           color: "cyan",
           value: "#0ff"
      },
      {
           color: "magenta",
           value: "#f0f"
      },
      {
           color: "yellow",
           value: "#ff0"
      },
      {
           color: "black",
           value: "#000"
      }
 ]

para XML:

 <colors>
      <color >
           <name>red</name>
           <value>#f00</value>
      </color>
      <color >
           <name>green</name>
           <value>#0f0</value>
      </color>
      <color >
           <name>blue</name>
           <value>#00f</value>
      </color>
      <color >
           <name>cyan</name>
           <value>#0ff</value>
      </color>
      <color >
           <name>magenta</name>
           <value>#f0f</value>
      </color>
      <color >
           <name>yellow</name>
           <value>#ff0</value>
      </color>
      <color >
           <name>black</name>
           <value>#000</value>
      </color>
 </colors>

Apenas uma anedota de minha própria experiência pessoal:

Escrevi um pequeno diretório Javascript, primeiro com os dados em XML, e depois o adaptei para usar JSON, para que eu pudesse executá-los lado a lado e comparar as velocidades com o Firebug. O JSON acabou sendo aproximadamente três vezes mais rápido (350-400 ms vs. 1200-1300 ms para exibir todos os dados). Além disso, como outros observaram, o JSON é muito mais fácil para os olhos e o tamanho do arquivo foi 25% menor devido à marcação mais enxuta.

 <colors>
      <color name='red'     value='#f00'/>
      <color name='green'   value='#0f0'/>
      <color name='blue'    value='#00f'/>
      <color name='cyan'    value='#0ff'/>
      <color name='magenta' value='#f0f'/>
      <color name='yellow'  value='#ff0'/>
      <color name='black'   value='#000'/>
 </colors>

Com atributos, XML é bom. Mas, por alguma razão, o XML caseiro é geralmente 100% feito de elementos e feio.

O fácil consumo por JavaScript pode ser um dos motivos.

O JSON é melhor para o consumo de dados em aplicativos da web de serviços da web por seu tamanho e facilidade de uso, principalmente devido ao suporte interno ao JavaScript . Imagine a sobrecarga de computação para analisar um fragmento xml em comparação com a pesquisa instantânea em JSON.

Um exemplo muito bom é o JSON-P. Você pode recuperar dados de um serviço da Web envolvido em uma chamada de função de retorno de chamada, como my_callback({"color": "blue", "shape":"square"});dentro de uma <script>tag gerada dinamicamente, para que os dados possam ser consumidos diretamente na função my_callback(). Não há como chegar nem perto dessa conveniência usando XML.

XML seria o formato de escolha para documentos grandes, em que você possui uma estrutura de renderização de páginas de dados em vários formatos usando XSLT. O XML também pode ser usado com arquivos de configuração de aplicativos para facilitar a leitura entre muitos outros usos.

Ninguém aqui mencionou a principal vantagem do XML: regras de validação (DTD, XSD). Minhas conclusões, tendo usado ambos:

• JSON é perfeito para ajax, especialmente se você desenvolver o lado do servidor e do cliente. Você basicamente cria objetos js diretamente no script do servidor!
• O XML brilha em ambientes corporativos, quando você precisa definir padrões de troca de dados entre grandes organizações burocráticas. Freqüentemente, uma parte desenvolve sua parte meses antes da outra, por isso realmente se beneficia da validação de suas solicitações contra XSD acordado. Além disso, nas grandes empresas, a transferência de dados é frequentemente traduzida entre diferentes sistemas. Essa também é a força do XML, pense no XSLT. Exemplo: conversão sem código em JSON: p

Obviamente, o json-schema está sendo desenvolvido, mas você não encontrará suporte interno para ele em nenhum lugar.

Sou fã de ambos, eles têm forças diferentes.

Agora que existem codificadores e decodificadores JSON para a maioria dos idiomas, não há razão para NÃO usar o JSON para usos onde isso faz sentido (e isso é provavelmente 90% dos casos de uso para XML).

Eu até ouvi falar de seqüências de caracteres JSON sendo usadas em grandes bancos de dados SQL para facilitar as alterações de esquema.

Honestamente, não existe muita diferença entre JSON e XML no fato de que eles podem representar todos os tipos de dados. No entanto, o XML é sintaticamente maior que o JSON e isso o torna mais pesado que o JSON.

O JSON não possui incompatibilidade de impedância com a programação JavaScript. JSON pode conter números inteiros, seqüências de caracteres, listas, matrizes. XML é apenas elementos e nós que precisam ser analisados ​​em números inteiros e assim por diante antes de serem consumidos.

Ambos são ótimos e muito portáteis. No entanto, o JSON vem ganhando popularidade, pois na maioria dos casos, na maioria dos casos, serializa-se em menos caracteres (o que se traduz em um tempo de entrega mais rápido) e, como corresponde à sintaxe do objeto JavaScript, ele pode ser traduzido diretamente em um objeto na memória que facilita muito o Ajax. implemento.

XML ainda é ótimo. JSON é apenas o "melhor e mais recente" comparado ao XML.

Facilmente analisado por JavaScript e é leve (um documento em JSON é menor que um documento XML que contém os mesmos dados.)

JSON é efetivamente serializado JavaScript, pois é possível avaliar (aJsonString) diretamente em um objeto JavaScript. Dentro de um navegador, o JSON é fácil de usar e é perfeitamente adequado para JavaScript. Ao mesmo tempo, o JavaScript é uma linguagem dinâmica de tipo muito fraco e não pode tirar vantagem nativa de todas as informações de tipo específicas disponíveis contidas em um documento Xml / Xsd. Esses metadados extras (que são ótimos para interoperabilidade) são um obstáculo no JavaScript, tornando-o mais tedioso e incômodo de se trabalhar.

Tamanho vs desempenho

Se você estiver em um navegador, o JSON é mais rápido para serializar / desserializar, pois é mais simples, compacto e com suporte nativo mais importante. Eu tenho alguns benchmarks de banco de dados Northwind disponíveis comparando o tamanho e a velocidade entre os diferentes serializadores disponíveis. Na biblioteca de classes base, o serializador XML DataContract da Microsoft é 30% mais rápido que o JSON. Embora isso tem mais a ver com o esforço Microsoft colocar em seu serializador XML como eu era capaz de desenvolver uma JsonSerializer que é mais do que 2,6 vezes mais rápido do que o seu único XML. Quanto às cargas úteis baseadas nos benchmarks, parece que o XML é aproximadamente mais do que 2xo tamanho do JSON. No entanto, isso pode explodir rapidamente se a carga útil do XML usar muitos namespaces diferentes no mesmo documento.

XML é óleo de cobra inchado na maioria das situações. O JSON oferece a maioria dos benefícios sem o inchaço.

Uma grande vantagem, além das mencionadas aqui. Para os mesmos dados, existem várias maneiras de representá-lo como um arquivo XML, mas apenas uma maneira com o JSON, remove a ambiguidade :)

De longe, não sou especialista, mas, das várias empresas em que trabalhei, geralmente usamos XML em pequenos ambientes de dados ou valores de configuração (web.config é um ótimo exemplo).

Quando você tem grandes quantidades de dados, geralmente, você deseja relatar esses dados. E o XML não é uma ótima fonte de geração de relatórios. No grande esquema das coisas, parece que um banco de dados transacional é mais fácil de relatar / pesquisar do que XML.

Isso faz sentido? Como eu disse acima, não sou especialista, mas, pela minha experiência, esse parece ser o caso. Além disso, acredito que a Microsoft integrou o suporte JSON devido à onda de desenvolvedores que passaram para ações do script ou do lado do cliente para aprimorar o visual da interface do usuário ( Ajax ) e o Ajax da Microsoft não foi usado tanto quanto outras bibliotecas como jQuery e MooTools ( A YUI do Yahoo também está nesse mix) devido à sua bela integração de objetos serializáveis ​​usando JSON.

Encontro-me escrevendo código agora implementando o serializador JSON no meu código VB. É MUITO fácil e do ponto de vista de atualização / modificação, você não pode vencê-lo. É a maneira da Microsoft de nos manter viciados em VS, eu acho. Recentemente, converti um aplicativo corporativo no Ajax (via jQuery) e no formato JSON. Demorou aproximadamente 2 semanas para fazer isso. Na verdade, agradeço à Microsoft por integrá-lo porque, sem ele, eu teria que escrever um pouco de código extra.