Cara menggunakan mengatasi nan pada javascript

Saya hanya mencobanya di konsol JavaScript Firefox, tetapi tidak satu pun dari pernyataan berikut yang menghasilkan true:

parseFloat('geoff') == NaN;

parseFloat('geoff') == Number.NaN;

Saya baru saja menemukan teknik ini dalam buku JavaScript Efektif yang cukup sederhana:

Karena NaN adalah satu-satunya nilai JavaScript yang diperlakukan sebagai tidak sama dengan dirinya sendiri, Anda selalu dapat menguji apakah suatu nilai adalah NaN dengan mengeceknya untuk persamaan dengan dirinya sendiri:

var a = NaN;
a !== a; // true 

var b = "foo";
b !== b; // false 

var c = undefined; 
c !== c; // false

var d = {};
d !== d; // false

var e = { valueOf: "foo" }; 
e !== e; // false

Tidak menyadarinya sampai @allsyed berkomentar, tetapi ini ada dalam spesifikasi ECMA: https://tc39.github.io/ecma262/#sec-isnan-number

Gunakan kode ini:

isNaN('geoff');

Lihat isNaN()dokumen di MDN .

alert ( isNaN('abcd'));  // alerts true
alert ( isNaN('2.0'));  // alerts false
alert ( isNaN(2.0));  // alerts false

Sejauh nilai tipe Number harus diuji apakah itu a NaNatau tidak, fungsi global isNaNakan melakukan pekerjaan itu

isNaN(any-Number);

Untuk pendekatan generik yang bekerja untuk semua jenis di JS, kita bisa menggunakan salah satu dari yang berikut:

Untuk Pengguna ECMAScript-5:

#1
if(x !== x) {
    console.info('x is NaN.');
}
else {
    console.info('x is NOT a NaN.');
}

Untuk orang yang menggunakan ECMAScript-6:

#2
Number.isNaN(x);

Dan Untuk tujuan konsistensi di ECMAScript 5 & 6 keduanya, kita juga dapat menggunakan polyfill ini untuk Number.isNan

#3
//Polyfill from MDN
Number.isNaN = Number.isNaN || function(value) {
    return typeof value === "number" && isNaN(value);
}
// Or
Number.isNaN = Number.isNaN || function(value) {     
    return value !== value;
}

silakan periksa Jawaban Ini untuk lebih jelasnya.

NaN adalah nilai khusus yang tidak dapat diuji seperti itu. Suatu hal yang menarik yang ingin saya bagikan adalah ini

var nanValue = NaN;
if(nanValue !== nanValue) // Returns true!
    alert('nanValue is NaN');

Ini mengembalikan nilai true hanya untuk nilai-nilai NaN dan Merupakan cara aman untuk pengujian. Harus jelas dibungkus dalam suatu fungsi atau minimal berkomentar, karena itu tidak masuk akal jelas untuk menguji apakah variabel yang sama tidak sama satu sama lain, hehe.

Anda harus menggunakan isNaN(value)panggilan fungsi global , karena:

• Ini didukung lintas browser
• Lihat isNaN untuk dokumentasi

Contoh:

 isNaN('geoff'); // true
 isNaN('3'); // false

Saya harap ini akan membantu Anda.

Pada ES6 , Object.is(..)adalah utilitas baru yang dapat digunakan untuk menguji dua nilai untuk kesetaraan absolut:

var a = 3 / 'bar';
Object.is(a, NaN); // true

Untuk memperbaiki masalah di mana '1.2geoff'menjadi diuraikan, cukup gunakanNumber() pengurai.

Jadi daripada ini:

parseFloat('1.2geoff'); // => 1.2
isNaN(parseFloat('1.2geoff')); // => false
isNaN(parseFloat('.2geoff')); // => false
isNaN(parseFloat('geoff')); // => true

Melakukan hal ini:

Number('1.2geoff'); // => NaN
isNaN(Number('1.2geoff')); // => true
isNaN(Number('.2geoff')); // => true
isNaN(Number('geoff')); // => true

EDIT: Saya baru saja melihat masalah lain dari ini ... nilai-nilai salah (dan benar sebagai boolean nyata) Number()dikembalikan sebagai 0! Dalam hal ini ... parseFloat berfungsi setiap saat sebagai gantinya. Jadi kembali ke itu:

function definitelyNaN (val) {
    return isNaN(val && val !== true ? Number(val) : parseFloat(val));
}

Dan itu tampaknya mencakup segalanya. Saya membandingkannya pada 90% lebih lambat dari pada Lodash _.isNaNtetapi kemudian yang satu tidak mencakup semua NaN:

http://jsperf.com/own-isnan-vs-underscore-lodash-isnan

Untuk lebih jelasnya, saya menangani interpretasi literal manusia dari sesuatu yang "Bukan Angka" dan lodash mengurus interpretasi literal komputer untuk memeriksa apakah ada sesuatu yang "NaN".

Meskipun jawaban @ chiborg benar, ada hal lain yang harus diperhatikan:

parseFloat('1.2geoff'); // => 1.2
isNaN(parseFloat('1.2geoff')); // => false
isNaN(parseFloat('.2geoff')); // => false
isNaN(parseFloat('geoff')); // => true

Intinya, jika Anda menggunakan metode ini untuk validasi input, hasilnya akan agak liberal.

Jadi, ya Anda dapat menggunakan parseFloat(string)(atau dalam kasus angka penuh parseInt(string, radix)'dan kemudian membungkusnya dengan isNaN(), tetapi berhati-hatilah dengan gotcha dengan angka yang terkait dengan karakter non-numerik tambahan.

Solusi Sederhana!

BENAR-BENAR super sederhana! Sini! Dapatkan metode ini!

function isReallyNaN(a) { return a !== a; };

Gunakan sesederhana:

if (!isReallyNaN(value)) { return doingStuff; }

Lihat tes kinerjahere menggunakan func vs iniselected answer

Juga: Lihat contoh di bawah 1 untuk beberapa implementasi alternatif.

Contoh:

function isReallyNaN(a) { return a !== a; };

var example = {
    'NaN': NaN,
    'an empty Objet': {},
    'a parse to NaN': parseFloat('$5.32'),
    'a non-empty Objet': { a: 1, b: 2 },
    'an empty Array': [],
    'a semi-passed parse': parseInt('5a5'),
    'a non-empty Array': [ 'a', 'b', 'c' ],
    'Math to NaN': Math.log(-1),
    'an undefined object': undefined
  }

for (x in example) {
    var answer = isReallyNaN(example[x]),
        strAnswer = answer.toString();
    $("table").append($("<tr />", { "class": strAnswer }).append($("<th />", {
        html: x
    }), $("<td />", {
        html: strAnswer
    })))
};

table { border-collapse: collapse; }
th, td { border: 1px solid; padding: 2px 5px; }
.true { color: red; }
.false { color: green; }

<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js"></script>
<table></table>

Ada beberapa jalur alternatif yang Anda ambil untuk implementasi, jika Anda tidak ingin menggunakan metode berganti nama, dan ingin memastikan itu lebih tersedia secara global. Peringatan Solusi ini melibatkan pengubahan objek asli, dan mungkin bukan solusi terbaik Anda. Selalu gunakan hati-hati dan sadar bahwa Perpustakaan lain yang mungkin Anda gunakan mungkin bergantung pada kode asli atau perubahan serupa.

Implementasi Alternatif 1: Ganti isNaNmetode Asli .

//  Extremely simple. Just simply write the method.
window.isNaN = function(a) { return a !==a; }

Implementasi Alternatif 2: Tambahkan ke Objek Nomor * Disarankan karena juga merupakan poly-fill untuk ECMA 5 hingga 6

Number['isNaN'] || (Number.isNaN = function(a) { return a !== a });
//  Use as simple as
Number.isNaN(NaN)

Tes solusi alternatif jika kosong

Metode jendela sederhana yang saya tulis tes itu jika objek kosong . Ini sedikit berbeda karena tidak memberikan jika item "persis" NaN , tapi saya pikir saya akan membuang ini karena mungkin juga berguna ketika mencari barang kosong.

/** isEmpty(varried)
 *  Simple method for testing if item is "empty"
 **/
;(function() {
   function isEmpty(a) { return (!a || 0 >= a) || ("object" == typeof a && /\{\}|\[(null(,)*)*\]/.test(JSON.stringify(a))); };
   window.hasOwnProperty("empty")||(window.empty=isEmpty);
})();

Contoh:

Periksa Sangat Dalam, Apakah Kosong

Yang terakhir ini berjalan agak dalam, bahkan memeriksa apakah suatu Obyek penuh dengan Objek kosong. Saya yakin itu memiliki ruang untuk perbaikan dan kemungkinan lubang, tetapi sejauh ini, tampaknya menangkap sebagian besar segalanya.

Saya hanya ingin berbagi alternatif lain, ini belum tentu lebih baik daripada yang lain di sini, tapi saya pikir itu layak untuk dilihat:

function customIsNaN(x) { return (typeof x == 'number' && x != 0 && !x); }

Logika di balik ini adalah bahwa setiap angka kecuali 0dan NaNdilemparkan ketrue .

Saya telah melakukan tes cepat, dan kinerjanya sebagus Number.isNaNdan memeriksa dirinya sendiri untuk salah. Ketiganya berkinerja lebih baik daripadaisNan

Hasil

customIsNaN(NaN);            // true
customIsNaN(0/0);            // true
customIsNaN(+new Date('?')); // true

customIsNaN(0);          // false
customIsNaN(false);      // false
customIsNaN(null);       // false
customIsNaN(undefined);  // false
customIsNaN({});         // false
customIsNaN('');         // false

Semoga bermanfaat jika Anda ingin menghindari isNaNfungsi yang rusak .

NaN dalam JavaScript adalah singkatan dari "Not A Number", meskipun jenisnya sebenarnya adalah angka.

typeof(NaN) // "number"

Untuk memeriksa apakah suatu variabel bernilai NaN, kita tidak bisa hanya menggunakan fungsi isNaN (), karena isNaN () memiliki masalah berikut, lihat di bawah:

var myVar = "A";
isNaN(myVar) // true, although "A" is not really of value NaN

Apa yang sebenarnya terjadi di sini adalah bahwa myVar secara implisit dipaksa ke nomor:

var myVar = "A";
isNaN(Number(myVar)) // true. Number(myVar) is NaN here in fact

Ini sebenarnya masuk akal, karena "A" sebenarnya bukan angka. Tapi yang ingin kita periksa adalah apakah myVar benar-benar bernilai NaN.

Jadi isNaN () tidak dapat membantu. Lalu apa yang harus kita lakukan?

Mengingat NaN adalah satu-satunya nilai JavaScript yang diperlakukan tidak setara dengan dirinya sendiri, jadi kami dapat memeriksa kesetaraannya dengan menggunakan sendiri! ==

var myVar; // undefined
myVar !== myVar // false

var myVar = "A";
myVar !== myVar // false

var myVar = NaN
myVar !== myVar // true

Jadi untuk menyimpulkan , jika benar bahwa variabel! == itu sendiri, maka variabel ini persis bernilai NaN:

function isOfValueNaN(v) {
    return v !== v;
}

var myVar = "A";
isNaN(myVar); // true
isOfValueNaN(myVar); // false

Saya menggunakan fungsi garis bawahisNaN karena dalam JavaScript:

isNaN(undefined) 
-> true

Paling tidak, waspadai gotcha itu.

Mungkin juga ini:

function isNaNCustom(value){
    return value.toString() === 'NaN' && 
           typeof value !== 'string' && 
           typeof value === 'number'
}

Tampaknya isNaN () tidak didukung di Node.js di luar kotak.
Saya bekerja dengan

var value = 1;
if (parseFloat(stringValue)+"" !== "NaN") value = parseFloat(stringValue);

function isNotANumber(n) {
  if (typeof n !== 'number') {
    return true;
  } 
  return n !== n;
}

NaN === NaN;        // false
Number.NaN === NaN; // false
isNaN(NaN);         // true
isNaN(Number.NaN);  // true

Operator kesetaraan (== dan ===) tidak dapat digunakan untuk menguji nilai terhadap NaN.

Lihatlah Dokumentasi Mozilla Properti NaN global adalah nilai yang mewakili Not-A-Numbe

Cara terbaik adalah menggunakan 'isNaN ()' yang merupakan fungsi buit-in untuk memeriksa NaN. Semua browser mendukung cara ..

Aturannya adalah:

NaN != NaN

Masalah fungsi isNaN () adalah bahwa ia dapat mengembalikan hasil yang tidak terduga dalam beberapa kasus:

isNaN('Hello')      //true
isNaN('2005/12/12') //true
isNaN(undefined)    //true
isNaN('NaN')        //true
isNaN(NaN)          //true
isNaN(0 / 0)        //true

Cara yang lebih baik untuk memeriksa apakah nilainya benar-benar NaN adalah:

function is_nan(value) {
    return value != value
}

is_nan(parseFloat("geoff"))

Menurut IEEE 754, semua hubungan yang melibatkan NaN dievaluasi sebagai false kecuali! =. Jadi, misalnya, (A> = B) = false dan (A <= B) = false jika A atau B atau keduanya adalah / adalah NaN.

Saya menulis jawaban ini untuk pertanyaan lain tentang StackOverflow di mana orang lain memeriksa kapan NaN == nulltapi kemudian ditandai sebagai duplikat jadi saya tidak ingin menyia-nyiakan pekerjaan saya.

Lihatlah Jaringan Pengembang Mozilla tentang NaN.

Jawaban singkat

Cukup gunakan distance || 0ketika Anda ingin memastikan nilai Anda adalah angka yang tepat atau isNaN()untuk memeriksanya.

Jawaban panjang

NaN (Not-a-Number) adalah Benda Global aneh di javascript yang sering dikembalikan ketika beberapa operasi matematika gagal.

Anda ingin memeriksa apakah NaN == nullhasilnya false. Hovewer bahkan NaN == NaNmenghasilkan false.

Cara sederhana untuk mengetahui apakah variabel adalah NaNfungsi global isNaN().

Yang lain adalah x !== x yang hanya benar ketika x adalah NaN. (terima kasih sudah mengingatkan @ raphael-schweikert)

Tetapi mengapa jawaban singkatnya berhasil?

Ayo cari tahu.

Ketika Anda memanggil NaN == falsehasilnya false, sama dengan NaN == true.

Di suatu tempat di spesifikasi JavaScript memiliki catatan dengan nilai selalu salah, yang meliputi:

• NaN - Bukan-Jumlah
• "" - string kosong
• false - palsu boolean
• null - objek nol
• undefined - variabel tidak terdefinisi
• 0 - numerik 0, termasuk +0 dan -0

Solusi lain disebutkan di halaman parseFloat MDN

Ini menyediakan fungsi filter untuk melakukan parsing ketat

var filterFloat = function (value) {
    if(/^(\-|\+)?([0-9]+(\.[0-9]+)?|Infinity)$/
      .test(value))
      return Number(value);
  return NaN;
}


console.log(filterFloat('421'));               // 421
console.log(filterFloat('-421'));              // -421
console.log(filterFloat('+421'));              // 421
console.log(filterFloat('Infinity'));          // Infinity
console.log(filterFloat('1.61803398875'));     // 1.61803398875
console.log(filterFloat('421e+0'));            // NaN
console.log(filterFloat('421hop'));            // NaN
console.log(filterFloat('hop1.61803398875'));  // NaN

Dan kemudian Anda dapat menggunakannya isNaNuntuk memeriksa apakah ituNaN

Cara yang tepat untuk memeriksa adalah:

//takes care of boolen, undefined and empty

isNaN(x) || typeof(x) ==='boolean' || typeof(x) !=='undefined' || x!=='' ? 'is really a nan' : 'is a number'

Saya telah membuat fungsi kecil ini yang berfungsi seperti pesona. Alih-alih memeriksa NaN yang tampaknya kontra intuitif, Anda memeriksa nomor. Saya cukup yakin saya bukan yang pertama melakukannya dengan cara ini, tetapi saya pikir saya akan berbagi.

function isNum(val){
    var absVal = Math.abs(val);
    var retval = false;
    if((absVal-absVal) == 0){
        retval = true
    }

    return retval;
}

Menemukan cara lain, hanya untuk bersenang-senang.

function IsActuallyNaN(obj) {
  return [obj].includes(NaN);  
}

Jawaban markyzm bekerja dengan baik, tetapi tidak mengembalikan false karena InfinityInfinity secara teknis bukan angka.

saya datang dengan isNumberfungsi yang akan memeriksa apakah itu angka.

function isNumber(i) {
    return !isNaN(i && i !== true ? Number(i) : parseFloat(i)) && [Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY].indexOf(i) === -1;
}

console.log(isNumber(Infinity));
console.log(isNumber("asdf"));
console.log(isNumber(1.4));
console.log(isNumber(NaN));
console.log(isNumber(Number.MAX_VALUE));
console.log(isNumber("1.68"));

UPDATE: saya perhatikan bahwa kode ini gagal untuk beberapa parameter, jadi saya membuatnya lebih baik.

function isNumber(i) {//function for checking if parameter is number
if(!arguments.length) {
throw new SyntaxError("not enough arguments.");
	} else if(arguments.length > 1) {
throw new SyntaxError("too many arguments.");
	} else if([Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY].indexOf(i) !== -1) {
throw new RangeError("number cannot be \xB1infinity.");
	} else if(typeof i === "object" && !(i instanceof RegExp) && !(i instanceof Number) && !(i === null)) {
throw new TypeError("parameter cannot be object/array.");
	} else if(i instanceof RegExp) {
throw new TypeError("parameter cannot be RegExp.");
	} else if(i == null || i === undefined) {
throw new ReferenceError("parameter is null or undefined.");
	} else {
return !isNaN(i && i !== true ? Number(i) : parseFloat(i)) && (i === i);
	}
}
console.log(isNumber(Infinity));
console.log(isNumber(this));
console.log(isNumber(/./ig));
console.log(isNumber(null));

alert("1234567890.".indexOf(String.fromCharCode(mycharacter))>-1);

Ini tidak elegan. tetapi setelah mencoba isNAN () saya sampai pada solusi ini yang merupakan alternatif lain. Dalam contoh ini saya juga mengizinkan '.' karena saya menutupi float. Anda juga bisa membalikkan ini untuk memastikan tidak ada angka yang digunakan.

("1234567890".indexOf(String.fromCharCode(mycharacter))==-1)

Ini adalah evaluasi karakter tunggal tetapi Anda juga dapat mengulangi string untuk memeriksa angka apa pun.

Anda dapat memeriksa NaN menggunakan fungsi javascript isNaN. Hanya meneruskan angka atau nilai ke fungsi isNaN

isNaN(123) //false
isNaN(-1.23) //false
isNaN(5-2) //false
isNaN(0) //false
isNaN('123') //false
isNaN('Hello') //true
isNaN('2005/12/12') //true
isNaN('') //false
isNaN(true) //false
isNaN(undefined) //true
isNaN('NaN') //true
isNaN(NaN) //true
isNaN(0 / 0) //true

Cukup konversikan hasilnya ke String dan bandingkan dengan 'NaN'.

var val = Number("test");
if(String(val) === 'NaN') {
   console.log("true");
}

Apakah (NaN> = 0) ? ...... " Saya tidak tahu ".

function IsNotNumber( i ){
    if( i >= 0 ){ return false; }
    if( i <= 0 ){ return false; }
    return true;
}

Kondisi hanya dijalankan jika BENAR .

Bukan pada SALAH .

Bukan pada " Aku Tidak Tahu ".