JavaScript Object Notation

**JavaScript Object Notation** (**JSON**) é un formato lixeiro para o intercambio de datos. É un subconxunto da notación literal de obxectos de JavaScript que non require o uso de XML.
## Características
A simplicidade de JSON deu lugar á xeneralización do seu uso, especialmente como alternativa a XML en AJAX. Unha das supostas vantaxes de JSON sobre XML como formato de intercambio de datos neste contexto é a maior simplicidade  á hora de desenvolver un analizador sintáctico (parser) de JSON. En JavaScript, un texto JSON pódese analizar facilmente usando o procedemento `eval()`, o cal foi fundamental para que JSON fose aceptado por parte da comunidade de desenvolvedores AJAX, debido á ubicuidade de JavaScript en case calquera navegador web.

Na práctica, os argumentos a favor da facilidade de desenvolvemento de analizadores ou do rendemento dos mesmos son pouco relevantes, debido ás cuestións de seguridade que expón o uso de `eval()` e o auxe do procesamento nativo de XML incorporado nos navegadores modernos. Por esa razón, JSON emprégase habitualmente en contornas onde o tamaño do fluxo de datos entre cliente e servidor é de vital importancia (de aquí o seu uso por Yahoo, Google etc, que atenden a millóns de usuarios) cando a fonte de datos é explicitamente de fiar e onde non é importante o non dispor de procesamento XSLT para manipular os datos no cliente.

## Uso de JSON 
En teoría, é trivial analizar JSON en JavaScript usando a función `eval()` incorporada na linguaxe. Por exemplo:

```javascript
meuObxecto = eval('(' + json_datos + ')');
```

Na práctica, as consideracións de seguridade polo xeral recomendan non usar *eval* sobre datos crus e debería usarse un analizador JavaScript distinto para garantir a seguridade. O analizador proporcionado por JSON.org usa `eval()` na súa función de análise, protexéndoa cunha expresión regular de forma que a función só ve expresións seguras.

Un exemplo de acceso a datos JSON usando XMLHttpRequest é:

```javascript
var http_request = new XMLHttpRequest();
var url = "http://example.net/jsondata.php"; // Esta URL debería devolver datos JSON
 
// Descarga os datos JSON do servidor.
http_request.onreadystatechange = handle_json;
http_request.open("GET", url, true);
http_request.send(null);
 
function handle_json() {
  if (http_request.readyState == 4) {
    if (http_request.status == 200) {
      var json_data = http_request.responseText; 
      var the_object = eval("(" + json_data + ")");
    } else {
      alert("Ocurreu un problema coa URL.");
    }
    http_request = null;
  }
}
```

Obsérvese que o uso de XMLHttpRequest neste exemplo non é compatible con tódolos navegadores, aínda que existen variacións sintácticas para Internet Explorer, Opera, Safari, e navegadores baseados en Mozilla.

Tamén é posible usar elementos  ocultos para solicitar os datos de maneira asíncrona, ou usar peticións . Estes métodos foran os máis habituais antes da chegada do uso xeneralizado de XMLHttpRequest.

Hai unha biblioteca para o framework .NET que exporta clases .NET coa sintaxe de JSON para a comunicación entre cliente e servidor, en ámbolos sentidos.

## Exemplo de JSON 
A continuación móstrase un exemplo simple de definición de barra de menús usando JSON e XML.

JSON:

```javascript
{"menu": {
   "id": "file",
   "value": "File",
   "popup": {
     "menuitem": [
       {"value": "New", "onclick": "CreateNewDoc()"},
       {"value": "Open", "onclick": "OpenDoc()"},
       {"value": "Close", "onclick": "CloseDoc()"}
     ]
   }
 }}
```

XML:

```xml

  
    
    
    
  

```

Aínda que os defensores de JSON a miúdo notan que este é máis abreviado que XML, obsérvese que os dous exemplos teñen uns 190 caracteres cando se eliminan os espazos en branco. Ademais, o uso de compresión GZIP para enviar os datos ao navegador pode reducir a diferenza de tamaños entre ámbolos formatos. De feito, cando se usa GZIP sobre os exemplos anteriores o exemplo en XML é máis pequeno por 6 bytes. Aínda que isto non é concluínte, mostra que é necesario experimentar co conxunto de datos a tratar para determinar que formato será máis eficiente en termos de tamaño. JSON non é sempre máis pequeno que XML.

O beneficio de JSON, entón, non é que sexa máis pequeno á hora de transmitir, senón que representa mellor a estrutura dos datos e require menos codificación e procesamento.

## Comparación con XML e outras linguaxes de marcado 
XML goza de maior soporte e ofrece moitas máis ferramentas de desenvolvemento (tanto no lado do cliente como no lado do servidor). Hai moitos analizadores JSON no lado do servidor, existindo polo menos un analizador para a maioría das contornas. Nalgunhas linguaxes, como Xava ou PHP, hai diferentes implantacións onde escoller. En JavaScript, a análise é posible de maneira nativa coa función `eval()`. Ámbolos formatos carecen dun mecanismo para representar grandes obxectos binarios.

Con independencia da comparación con XML, JSON pode ser moi compacto e eficiente se se usa de maneira efectiva. Por exemplo, a aplicación DHTML de procura en BarracudaDrive recibe as listaxes de directorio como JSON dende o servidor. Esta aplicación de procura está permanentemente consultando ó servidor por novos directorios, e é notablemente rápida, mesmo sobre unha conexión lenta.

As contornas no servidor normalmente requiren que se incorpore unha función ou obxecto analizador de JSON. Algúns programadores, especialmente os familiarizados coa linguaxe C, atopan JSON máis natural que XML, pero outros desenvolvedores atopan a súa concisa notación algo confusa, especialmente cando se trata de datos fortemente xerarquizados ou aniñados moi profundamente.

Hai máis comparacións entre JSON e XML nesta páxina de exemplo (en inglés).

YAML é un superconxunto de JSON que trata de superar algunhas das limitacións deste. Aínda que é bastante máis complexo (https://web.archive.org/web/20120214050054/http://bob.pythonmac.org/archives/2005/07/19/what-happened-to-yaml/), aínda pode considerarse como lixeiro. A linguaxe de programación Ruby utiliza YAML como o formato de serialización por defecto. Así pois, é posible manexar JSON con bastante sinxeleza.

## Notas 
## Véxase tamén 
### Outros artigos 
*XML
*YAML