JSON a omis Infinity et NaN; Statut JSON dans ECMAScript?

Une idée pourquoi JSON a omis NaN et +/- Infinity? Cela met Javascript dans la situation étrange où les objets qui seraient autrement sérialisables, ne le sont pas, s'ils contiennent des valeurs NaN ou +/- infini.

On dirait que cela a été coulé dans la pierre: voir RFC4627 et ECMA-262 (section 24.5.2, JSON.stringify, NOTE 4, page 683 du pdf ECMA-262 lors de la dernière édition):

Les nombres finis sont stringifiés comme en appelant ToString(number). NaN et Infinity, quel que soit le signe, sont représentés par la chaîne null.

Infinityet NaNne sont pas des mots clés ou quoi que ce soit de spécial, ce ne sont que des propriétés sur l'objet global (tel quel undefined) et peuvent donc être modifiées. C'est pour cette raison que JSON ne les inclut pas dans la spécification - en substance, toute vraie chaîne JSON devrait avoir le même résultat dans EcmaScript si vous le faites eval(jsonString)ou JSON.parse(jsonString).

Si cela était autorisé, quelqu'un pourrait injecter du code semblable à

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

dans un forum (ou autre) et toute utilisation de json sur ce site pourrait être compromise.

Sur la question d'origine: je suis d'accord avec l'utilisateur "cbare" en ce sens qu'il s'agit d'une omission malheureuse dans JSON. IEEE754 les définit comme trois valeurs spéciales d'un nombre à virgule flottante. Ainsi, JSON ne peut pas représenter entièrement les nombres à virgule flottante IEEE754. C'est en fait encore pire, puisque JSON tel que défini dans ECMA262 5.1 ne définit même pas si ses nombres sont basés sur IEEE754. Puisque le flux de conception décrit pour la fonction stringify () dans ECMA262 mentionne les trois valeurs spéciales IEEE, on peut soupçonner que l'intention était en fait de prendre en charge les nombres à virgule flottante IEEE754.

Comme un autre point de données, sans rapport avec la question: les types de données XML xs: float et xs: double indiquent qu'ils sont basés sur des nombres à virgule flottante IEEE754, et qu'ils prennent en charge la représentation de ces trois valeurs spéciales (voir W3C XSD 1.0 Partie 2 , Types de données).

Pourriez-vous adapter le modèle d'objet nul et représenter dans votre JSON des valeurs telles que

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

Ensuite, lors de la vérification, vous pouvez vérifier le type

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

Je sais qu'en Java, vous pouvez remplacer les méthodes de sérialisation afin de mettre en œuvre une telle chose. Je ne sais pas d'où vient votre sérialisation, donc je ne peux pas donner de détails sur la façon de l'implémenter dans les méthodes de sérialisation.

Les chaînes "Infinity", "-Infinity" et "NaN" contraignent toutes les valeurs attendues dans JS. Je dirais donc que la bonne façon de représenter ces valeurs dans JSON est sous forme de chaînes.

> +"Infinity"
Infinity

> +"-Infinity"
-Infinity

> +"NaN"
NaN

C'est juste dommage que JSON.stringify ne le fasse pas par défaut. Mais il y a un moyen:

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

Si vous avez accès au code de sérialisation, vous pouvez représenter Infinity comme 1.0e + 1024. L'exposant est trop grand pour être représenté dans un double et lorsqu'il est désérialisé, il est représenté par Infinity. Fonctionne sur webkit, pas sûr des autres analyseurs json!

La norme IEEE Std 754-2008 actuelle inclut des définitions pour deux représentations à virgule flottante 64 bits différentes: un type à virgule flottante décimal 64 bits et un type à virgule flottante 64 bits binaire.

Après avoir arrondi, la chaîne .99999990000000006est la même que .9999999dans la représentation binaire 64 bits IEEE, mais ce n'est PAS la même que .9999999dans la représentation décimale 64 bits IEEE. Dans les arrondis à virgule flottante décimale IEEE 64 bits .99999990000000006à la valeur .9999999000000001qui n'est pas la même que la .9999999valeur décimale .

Étant donné que JSON ne traite que les valeurs numériques comme des chaînes numériques de chiffres décimaux, il n'y a aucun moyen pour un système qui prend en charge les représentations à virgule flottante binaire et décimale IEEE (comme IBM Power) de déterminer laquelle des deux valeurs numériques à virgule flottante IEEE possibles est prévu.

Solution de contournement potentielle pour des cas tels que {"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;
   });

L'idée générale est de remplacer les occurrences de valeurs invalides par une chaîne que nous reconnaîtrons lors de l'analyse et de la remplacer par la représentation JavaScript appropriée.

La raison est indiquée à la page ii de la norme ECMA-404 La syntaxe d'échange de données JSON, 1ère édition

JSON est indépendant des nombres. Dans n'importe quel langage de programmation, il peut y avoir une variété de types de nombres de différentes capacités et compléments, fixes ou flottants, binaires ou décimaux. Cela peut rendre difficile l'échange entre différents langages de programmation. JSON offre à la place uniquement la représentation des nombres que les humains utilisent: une séquence de chiffres. Tous les langages de programmation savent comment donner un sens aux séquences de chiffres même s'ils ne sont pas d'accord sur les représentations internes. Cela suffit pour permettre l'échange.

La raison n'est pas, comme beaucoup l'ont prétendu, due aux représentations NaNet au Infinityscript ECMA. La simplicité est un principe de conception de base de JSON.

Parce que c'est si simple, on ne s'attend pas à ce que la grammaire JSON change un jour. Cela donne à JSON, en tant que notation fondamentale, une stabilité énorme

Si comme moi vous n'avez aucun contrôle sur le code de sérialisation, vous pouvez traiter les valeurs NaN en les remplaçant par null ou toute autre valeur comme un petit hack comme suit:

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

En substance, .fail sera appelé lorsque l'analyseur json d'origine détecte un jeton invalide. Ensuite, une chaîne de remplacement est utilisée pour remplacer les jetons non valides. Dans mon cas, c'est une exception pour le sérialiseur de renvoyer des valeurs NaN, donc cette méthode est la meilleure approche. Si les résultats contiennent normalement un jeton non valide, vous feriez mieux de ne pas utiliser $ .get mais plutôt de récupérer manuellement le résultat JSON et d'exécuter toujours le remplacement de chaîne.