JSON mengabaikan Infinity dan NaN; Status JSON dalam ECMAScript?

Tahu mengapa JSON mengabaikan NaN dan +/- Infinity? Ini menempatkan Javascript dalam situasi aneh di mana objek yang seharusnya serializable, tidak, jika mereka berisi nilai infinity NaN atau +/-.

Sepertinya ini telah dilemparkan ke batu: lihat RFC4627 dan ECMA-262 (bagian 24.5.2, JSON.stringify, CATATAN 4, halaman 683 dari ECMA-262 pdf pada edit terakhir):

Nomor-nomor yang terbatas dirangkai seolah-olah dengan menelepon ToString(number). NaN dan Infinity terlepas dari tanda diwakili sebagai String null.

Infinitydan NaNbukan kata kunci atau sesuatu yang istimewa, itu hanya properti pada objek global (apa adanya undefined) dan karenanya dapat diubah. Karena alasan itulah JSON tidak memasukkannya ke dalam spec - pada intinya string JSON yang sebenarnya harus memiliki hasil yang sama dalam EcmaScript jika Anda melakukannya eval(jsonString)atau JSON.parse(jsonString).

Jika diizinkan maka seseorang dapat menyuntikkan kode serupa

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

ke dalam forum (atau apa pun) dan kemudian penggunaan json di situs itu dapat dikompromikan.

Pada pertanyaan awal: Saya setuju dengan pengguna "cbare" karena ini merupakan kelalaian yang tidak menguntungkan di JSON. IEEE754 mendefinisikan ini sebagai tiga nilai khusus dari angka floating point. Jadi JSON tidak dapat sepenuhnya mewakili angka floating point IEEE754. Bahkan lebih buruk lagi, karena JSON sebagaimana didefinisikan dalam ECMA262 5.1 bahkan tidak menentukan apakah angka-angkanya didasarkan pada IEEE754. Karena aliran desain yang dideskripsikan untuk fungsi stringify () di ECMA262 tidak menyebutkan tiga nilai IEEE khusus, orang dapat menduga bahwa maksudnya sebenarnya adalah untuk mendukung angka-angka floating point IEEE754.

Sebagai satu titik data lainnya, tidak terkait dengan pertanyaan: XML tipe data xs: float dan xs: dobel menyatakan bahwa mereka didasarkan pada angka-angka floating point IEEE754, dan mereka mendukung representasi dari tiga nilai khusus ini (Lihat W3C XSD 1.0 Bagian 2 , Datatypes).

Bisakah Anda mengadaptasi pola objek nol, dan di JSON Anda mewakili nilai-nilai seperti

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

Kemudian saat memeriksa, Anda dapat memeriksa jenisnya

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

Saya tahu di Java Anda bisa mengganti metode serialisasi untuk mengimplementasikan hal seperti itu. Tidak yakin dari mana asal serialisasi Anda, jadi saya tidak bisa memberikan detail tentang bagaimana menerapkannya dalam metode serialisasi.

String "Infinity", "-Infinity", dan "NaN" semuanya memaksa ke nilai yang diharapkan di JS. Jadi saya berpendapat cara yang tepat untuk mewakili nilai-nilai ini di JSON adalah sebagai string.

> +"Infinity"
Infinity

> +"-Infinity"
-Infinity

> +"NaN"
NaN

Sayang JSON.stringify tidak melakukan ini secara default. Tapi ada caranya:

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

Jika Anda memiliki akses ke kode serialisasi, Anda mungkin mewakili Infinity sebagai 1.0e + 1024. Eksponen terlalu besar untuk diwakili dalam dobel dan ketika deserialized ini diwakili sebagai Infinity. Bekerja di webkit, tidak yakin tentang parser json lainnya!

IEEE Std 754-2008 saat ini mencakup definisi untuk dua representasi titik-mengambang 64-bit yang berbeda: tipe titik-floating-point 64-bit desimal dan tipe-titik floating-point biner 64-bit.

Setelah pembulatan string .99999990000000006adalah sama seperti .9999999dalam representasi 64-bit biner IEEE tetapi TIDAK sama dengan .9999999representasi 64-bit desimal IEEE. Dalam 64-bit IEEE desimal, floating-point .99999990000000006rounds ke nilai .9999999000000001yang tidak sama dengan nilai desimal .9999999.

Karena JSON hanya memperlakukan nilai numerik sebagai string numerik digit desimal, tidak ada cara untuk sistem yang mendukung representasi titik-biner IEEE dan floating-point desimal (seperti IBM Power) untuk menentukan yang mana dari dua kemungkinan nilai-nilai titik angka numerik IEEE yang mungkin. dimaksudkan.

Potensi penyelesaian untuk kasus-kasus seperti {"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;
   });

Gagasan umum adalah mengganti kemunculan nilai yang tidak valid dengan string yang akan kami kenali saat mengurai dan menggantinya kembali dengan representasi JavaScript yang sesuai.

Alasannya dinyatakan pada halaman ii dalam Standard ECMA-404 JSON Data Interchange Syntax, 1st Edition

JSON agnostik tentang angka. Dalam bahasa pemrograman apa pun, bisa ada berbagai jenis nomor dari berbagai kapasitas dan komplemen, tetap atau mengambang, biner atau desimal. Itu dapat membuat pertukaran antar bahasa pemrograman yang berbeda menjadi sulit. JSON sebagai gantinya hanya menawarkan representasi angka yang digunakan manusia: urutan digit. Semua bahasa pemrograman tahu bagaimana memahami urutan digit meskipun mereka tidak setuju pada representasi internal. Itu cukup untuk memungkinkan pertukaran.

Alasannya bukan, seperti yang banyak diklaim, karena representasi NaNdan Infinityskrip ECMA. Kesederhanaan adalah prinsip desain inti JSON.

Karena sangat sederhana, tidak diharapkan bahwa tata bahasa JSON akan pernah berubah. Ini memberi JSON, sebagai notasi dasar, stabilitas luar biasa

Jika seperti saya Anda tidak memiliki kendali atas kode serialisasi, Anda dapat menangani nilai NaN dengan menggantinya dengan nol atau nilai lain sebagai sedikit peretasan sebagai berikut:

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

Intinya, .fail akan dipanggil ketika parser json asli mendeteksi token yang tidak valid. Kemudian ganti string digunakan untuk mengganti token yang tidak valid. Dalam kasus saya ini adalah pengecualian untuk serialiser untuk mengembalikan nilai NaN sehingga metode ini adalah pendekatan terbaik. Jika hasil biasanya berisi token yang tidak valid Anda akan lebih baik untuk tidak menggunakan $ .get tetapi untuk secara manual mengambil hasil JSON dan selalu menjalankan penggantian string.