Houve uma discussão
interessante no JSMentors.com sobre JSONP e como deixá-lo mais
seguro. Foi uma boa experiência,
principalmente porque me forçou a examinar o assunto com profundidade e
a apresentar uma contraproposta própria.

Começaremos com um resumo dos
fundamentos do JSON, incluindo a API EcmaScript5JSON, e depois discutiremos a recuperação de domínio cruzado do JSON via
JSONP. Finalmente, introduzirei um framework JSONP simples e relativamente
seguro e mostrarei como usá-lo para buscar tweets na database do Twitter.

O que é JSON?

JSON (JavaScript Object
Notation) é um formato leve de intercâmbio de dados baseado na representação
literal de Objetos, Arrays, Strings, Números e Booleans do JavaScript. Uma variação do JSON é suportada pela maioria
das linguagens modernas, e agora compete com o XML como
protocolo de dados para serviços web, http e configuração de sistemas.

O JSON foi formalizado e
popularizado por volta de 2001 por Douglas
Crockford. A
especificação é descrita no rfc4627

OK, OK, posso obter
isso na Wikipedia. Queremos exemplos.

OK – aqui estão
alguns cookies (dos bons) expressos em JSON…

01	{
02	    "cookies": {
03	        "oatmeal": {
04	            "ingredients": [
05	                "flour",
06	                "sugar",
07	                "oats",
08	                "butter"
09	            ],
10	            "calories": 430,
11	            "eatBy": "2010-12-05",
12	            "kosher": true
13	        },
14	        "chocolate": {
15	            "ingredients": [
16	                "flour",
17	                "sugar",
18	                "butter",
19	                "chocolate"
20	            ],
21	            "calories": 510,
22	            "eatBy": "2010-12-03",
23	            "kosher": true
24	        }
25	    }
26	}

…isso é equivalente à seguinte expressão xml…

01	<cookies>
02	    <oatmeal>
03	         <ingredients>flour</ingredients>
04	         <ingredients>sugar</ingredients>
05	         <ingredients>oats</ingredients>
06	         <ingredients>butter</ingredients>
07	         <calories>430</calories>
08	         <eatBy>2010-12-05</eatBy>
09	         <kosher>true</kosher>
10	    </oatmeal>
11	    <chocolate>
12	         <ingredients>flour</ingredients>
13	         <ingredients>sugar</ingredients>
14	         <ingredients>butter</ingredients>
15	         <ingredients>chocolate</ingredients>
16	         <calories>510</calories>
17	         <eatBy>2010-12-03</eatBy>
18	         <kosher>true</kosher>
19	    </chocolate>
20	</cookies>

Então JSON é como
JavaScript?

Não exatamente. Embora o JSON
se pareça com o JavaScript, tem as seguintes regras restritivas:

• O JSON
  representa seis tipos de valores: objetos, arrays, números, strings,
  booleans e o null literal.
• Datas não são
  reconhecidas como um tipo de valor único
• O conceito de um
  identificador JavaScript não é compreendido pelo JSON. Todos os nomes-chave têm que ser strings JSON
• Strings JSON têm
  que estar entre aspas
• Números JSON não
  podem ter zeros à esquerda

Além do mais, como o JSON tem
a intenção de ser uma linguagem independente, os objetos JSON devem ser
considerados como strings genéricos, e não objetos JavaScript.

Usando JSON no
JavaScript

JSON é um formato
útil para receber respostas do servidor para solicitações XHR. Aparentemente,
essa resposta será na forma de uma string. Uma forma de converter uma string
JSON em um objeto JavaScript é alimentá-la com um argumento para a função eval:

1	var myCookies = eval('(' + cookieJSON + ')');
2	myCookies.cookies.chocolate.ingredients[1]; //"sugar"

(Os parênteses extras são
necessários por causa da ambiguidade com que o JavaScript interpreta uma chave)

Transações XHR comuns estão
sujeitas às mesmas restrições de domínio, de forma que você pode ficar razoavelmente
seguro de que a resposta vem do seu próprio servidor. Entretanto, os paranóicos
entre nós vão se preocupar com as consequências de um erro do servidor, ou um
redirecionamento malicioso, e realmente um eval cego de um gremlin qualquer
enviado por seu servidor pode colocar você em dificuldades um dia.

Felizmente, o ES5 (pdf) está tomando conta de você.

JSON.parse e
JSON.stringify

O ES5 especifica um novo
objeto incorporado chamado JSON com duas funções úteis baseadas em uma API
originalmente desenvolvida por Douglas Crockford.

O JSON.parse realiza um eval seguro de supostas strings
JSON (presumivelmente através de uma expressão regular). Se a string não for um
JSON válido, uma exceção SintaxError é disparada e o eval não é chamado. Há um
segundo argumento opcional, reviver,
uma função com dois parâmetros (key e value). Se fornecida, a função reviver é aplicada a todo par key/value
produzido pelo parse, o que pode fazer com que certos valores sejam modificados
de acordo com a lógica da função. Um uso típico do reviver é na reconstituição de valores de datas de strings (embora
não tenha valor o ES5 também especificar uma função Date.prototype.toJSON).

01	function dateReviver(key, value) {
02	    if (typeof value === 'string') {
03	        var a = /^(d{4})-(d{2})-(d{2})$/.exec(value);
04	        if (a) {
05	            return new Date(Date.UTC(+a[1], +a[2] - 1, +a[3]));
06	        }
07	    }
08	    return value;
09	};
10	 
11	var myCookies = JSON.parse(cookieJSON, dateReviver);
12	myCookies.cookies.oatmeal.eatBy; //Sat Dec 04 2010 16:00:00 GMT-0800 (Pacific Standard Time)

O JSON.stringify faz o oposto. O argumento value é requerido e pode ser qualquer objeto
JavaScript (embora tipicamente seja um objeto em um array). O resultado da
invocação do stringify é uma string JSON. Também há dois argumentos opcionais,
replacer e space. Quando replacer é uma função, funciona basicamente como um inverso do reviver; contudo pode ser
também um array, quando funciona como uma lista em branco de propriedades do
objeto a ser serializado.

O argumento space é usado para formatação e seu valor pode ser tanto um número quanto uma string. Se um número é fornecido, ele representa o número de espaços em branco
com os quais identar cada nível. Se o argumento é uma string (por
exemplo ‘t’),  então o texto é identado utilizando os caracteres
contidos na string.

01	JSON.stringify(cookies, ['cookies','oatmeal','chocolate','calories'], 't')
02	/*
03	'{
04	    "cookies":{
05	        "oatmeal":{
06	            "calories":430
07	        },
08	        "chocolate":{
09	            "calories":510
10	        }
11	    }
12	}'
13	*/

Ambas funções são implementadas em todos browsers modernos (mas não no
IE7). Asen Bozhilov compilou uma tabela de compatibilidade
que mostra as diferenças com que os fornecedores interpretam o JSON.parse.

?

Texto original disponível em http://javascriptweblog.wordpress.com/2010/11/29/json-and-jsonp/