JSON deixou de fora Infinity e NaN; Status JSON no ECMAScript?

Alguma idéia de por que o JSON deixou de fora o NaN e o +/- Infinity? Ele coloca o Javascript na estranha situação em que os objetos que seriam serializáveis ​​não são, se eles contêm NaN ou +/- valores infinitos.

Parece que isso foi feito em pedra: consulte RFC4627 e ECMA-262 (seção 24.5.2, JSON.stringify, NOTA 4, página 683 do ECMA-262 em última edição):

Os números finitos são especificados como se fossem chamados ToString(number). NaN e Infinity, independentemente do sinal, são representados como a String null.

Infinitye NaNnão são palavras-chave ou nada de especial, são apenas propriedades no objeto global (como estão undefined) e, como tal, podem ser alteradas. É por esse motivo que o JSON não os inclui na especificação - em essência, qualquer string JSON verdadeira deve ter o mesmo resultado no EcmaScript se você tiver eval(jsonString)ouJSON.parse(jsonString) .

Se fosse permitido, alguém poderia injetar código semelhante ao

NaN={valueOf:function(){ do evil }};
Infinity={valueOf:function(){ do evil }};

em um fórum (ou o que seja) e, em seguida, qualquer uso de json nesse site poderá ser comprometido.

Sobre a questão original: concordo com o usuário "cbare", pois é uma omissão infeliz no JSON. IEEE754 define esses três valores especiais de um número de ponto flutuante. Portanto, o JSON não pode representar totalmente os números de ponto flutuante IEEE754. Na verdade, é ainda pior, pois o JSON, conforme definido no ECMA262 5.1, nem mesmo define se seus números são baseados no IEEE754. Como o fluxo de projeto descrito para a função stringify () no ECMA262 menciona os três valores IEEE especiais, pode-se suspeitar que a intenção era de fato suportar números de ponto flutuante IEEE754.

Como outro ponto de dados, não relacionado à pergunta: tipos de dados XML xs: float e xs: double afirmam que são baseados nos números de ponto flutuante IEEE754 e suportam a representação desses três valores especiais (consulte W3C XSD 1.0 Parte 2 , Tipos de dados).

Você poderia adaptar o padrão de objeto nulo e, em seu JSON, representar valores como

"myNum" : {
   "isNaN" :false,
   "isInfinity" :true
}

Então, ao verificar, você pode verificar o tipo

if (typeof(myObj.myNum) == 'number') {/* do this */}
else if (myObj.myNum.isNaN) {/* do that*/}
else if (myObj.myNum.isInfinity) {/* Do another thing */}

Eu sei que em Java você pode substituir os métodos de serialização para implementar uma coisa dessas. Não sei de onde você está serializando, então não posso fornecer detalhes sobre como implementá-lo nos métodos de serialização.

As cadeias "Infinity", "-Infinity" e "NaN" são coerentes com os valores esperados em JS. Então, eu argumentaria que a maneira correta de representar esses valores no JSON é como strings.

> +"Infinity"
Infinity

> +"-Infinity"
-Infinity

> +"NaN"
NaN

É uma pena que o JSON.stringify não faça isso por padrão. Mas, existe um jeito:

> JSON.stringify({ x: Infinity }, function (k,v) { return v === Infinity ? "Infinity" : v; })
"{"x":"Infinity"}"

Se você tiver acesso ao código de serialização, poderá representar o Infinito como 1.0e + 1024. O expoente é muito grande para representar em dobro e, quando desserializado, é representado como Infinito. Funciona no webkit, inseguro sobre outros analisadores de json!

O atual IEEE Std 754-2008 inclui definições para duas representações de ponto flutuante de 64 bits diferentes: um tipo de ponto flutuante decimal de 64 bits e um tipo de ponto flutuante binário de 64 bits.

Após o arredondamento, a sequência .99999990000000006é a mesma que .9999999na representação binária de 64 bits do IEEE, mas NÃO é a mesma que .9999999na representação decimal de 64 bits do IEEE. No ponto IEEE decimal de 64 bits, o ponto flutuante .99999990000000006arredonda para o valor .9999999000000001que não é igual ao .9999999valor decimal .

Como o JSON trata apenas valores numéricos como sequências numéricas de dígitos decimais, não há como um sistema que suporte representações de ponto flutuante decimal e binário IEEE (como IBM Power) determinar qual dos dois possíveis valores numéricos de ponto flutuante IEEE é pretendido.

Solução alternativa em potencial para casos como {"key": Infinity}:

JSON.parse(theString.replace(/":(Infinity|-IsNaN)/g, '":"{{$1}}"'), function(k, v) {
   if (v === '{{Infinity}}') return Infinity;
   else if (v === '{{-Infinity}}') return -Infinity;
   else if (v === '{{NaN}}') return NaN;
   return v;
   });

A idéia geral é substituir ocorrências de valores inválidos por uma sequência que reconheceremos ao analisar e substituí-la novamente pela representação JavaScript apropriada.

O motivo está indicado na página ii no Padrão ECMA-404 A Sintaxe de Intercâmbio de Dados JSON, 1ª Edição

JSON é independente de números. Em qualquer linguagem de programação, pode haver vários tipos de números de várias capacidades e complementos, fixos ou flutuantes, binários ou decimais. Isso pode dificultar o intercâmbio entre diferentes linguagens de programação. Em vez disso, o JSON oferece apenas a representação dos números que os humanos usam: uma sequência de dígitos. Todas as linguagens de programação sabem entender as seqüências de dígitos, mesmo que discordem das representações internas. Isso é suficiente para permitir o intercâmbio.

O motivo não é, como muitos afirmaram, devido às representações NaNe ao Infinityscript ECMA. A simplicidade é um princípio básico de design do JSON.

Por ser tão simples, não é esperado que a gramática JSON mude. Isso dá ao JSON, como notação fundamental, uma tremenda estabilidade

Se, como eu, você não tiver controle sobre o código de serialização, poderá lidar com os valores de NaN, substituindo-os por nulos ou qualquer outro valor como um hack, como segue:

$.get("file.json", theCallback)
.fail(function(data) {
  theCallback(JSON.parse(data.responseText.replace(/NaN/g,'null'))); 
} );

Em essência, .fail será chamado quando o analisador json original detectar um token inválido. Em seguida, uma sequência de substituição é usada para substituir os tokens inválidos. No meu caso, é uma exceção o serializador retornar valores NaN, portanto esse método é a melhor abordagem. Se os resultados normalmente contiverem token inválido, é melhor não usar $ .get, mas recuperar manualmente o resultado JSON e sempre executar a substituição da cadeia.