isNaN()

Fungsi isNaN() menentukan apakah nilai adalah sebuah NaN atau bukan. Catatan: pemaksaan pada fungsi isNaN memiliki aturan yang menarik. Anda mungkin ingin menggunakan Number.isNaN(), seperti yang didefinisikan dalam ECMAScript 2015.

isNaN(value)

value

Nilai yang akan di uji.

true Jika nilai yang di uji adalah NaN; jika tidak, false.

Mungkin tidak seperti nilai lainnya dalam javascript, Ini tidak memungkinkan untuk mengandalkan operator persamaan (== dan ===) untuk menentukan bahwa nilai adalah NaN atau bukan, karena NaN == NaN dan NaN === NaN mengevaluasi ke false. Oleh karena itu, diperlukan adanya fungsi isNaN.

NilaiNaN dihasilkan saat operasi aritmatika menghasilkan nilai undefined atau unrepresentable. Nilai tersebut tidak harus mewakili kondisi overflow.  NaN juga dihasilkan dari percobaan pemaksaan ke nilai numerik dari nilai non-numerik yang tidak memiliki nilai numerik primitif yang tersedia.

Misalnya, membagi nol dengan nol menghasilkan sebuah NaN — namun membagi angka lain dengan nol tidak menghasilkan sebuah NaN.

Karena versi paling awal dari spesifikasi fungsi isNaN , perilaku untuk argumen non-numerik menjadi membingungkan. Ketika argumen ke fungsi isNaN bukan bertipe Number, Nilainya akan dipaksakan terlebih dahulu ke tipe Number. Nilai yang dihasilkan kemudian diuji untuk menentukan apakah itu NaN. Jadi untuk non-angka yang jika dipaksakan pada hasil numerik menghasilkan nilai numerik non-NaN (terutama string kosong dan primitif boolean, yang jika dipaksakan memberi nilai numerik nol atau satu), nilai pengembalian "false" mungkin tidak terduga; String kosong, misalnya, pastinya "not a number". Kebingungan itu berawal dari kenyataan bahwa istilah "not a number", memiliki arti khusus untuk angka yang diwakili sebagai nilai floating-point IEEE-754. Fungsi harus diinterpretasikan sebagai penjawab pertanyaan, "apakah nilai ini, jika dipaksakan pada nilai numerik, nilai IEEE-754 'Not A Number'?"

Versi terbaru dari ECMAScript (ES2015) berisi fungsi Number.isNaN(). Number.isNaN(x) akan menjadi cara yang andal untuk menguji apakah x adalah NaN atau bukan. Bahkan dengan Number.isNaN, namun arti NaN tetap merupakan makna numerik yang tepat, dan bukan sekadar, "not a number". Sebagai alternatif, untuk ketidakhadiran Number.isNaN, ekspresi (x != x) adalah cara yang lebih dapat diandalkan untuk menguji apakah variabel x adalah NaN atau bukan, karena hasilnya tidak sesuai dengan false positive yang membuat isNaN tidak dapat diandalkan.

Anda bisa memikirkan isNaN sebagai:

var isNaN = function(value) {
    return Number.isNaN(Number(value));
}

isNaN(NaN);       // true
isNaN(undefined); // true
isNaN({});        // true

isNaN(true);      // false
isNaN(null);      // false
isNaN(37);        // false

// strings
isNaN('37');      // false: "37" dikonversi ke nomor 37 yang mana bukan NaN
isNaN('37.37');   // false: "37.37" dikonversi ke nomor 37.37 yang mana bukan NaN
isNaN('123ABC');  // true:  parseInt("123ABC") adalah 123 namun Number("123ABC") adalah NaN
isNaN('');        // false: string kosing dikonversi ke 0 yang mana bukan NaN
isNaN(' ');       // false: string dengan spasi dikonversi ke 0 yang mana bukan NaN

// dates
isNaN(new Date());                // false
isNaN(new Date().toString());     // true

// Ini adalah false positif dan alasan mengapa NaN tidak sepenuhnya dapat diandalkan
isNaN('blabla');   // true: "blabla" dikonversi ke nomor.
                   // Parsing ini sebagai nomor gagal dan mengembalikan NaN

Ada cara penggunaan yang lebih berorientasi untuk memikirkan isNaN isNaN(): Jika isNaN(x) mengembalikan false, anda bisa menggunakan x dalam ekspresi aritmatika tidak membuat ekspresi mengembalikan NaN. Jika itu mengembalikantrue, x akan membuat setiap ekspresi aritmatika mengembalikan NaN. Ini berarti bahwa dalam JavaScript, isNaN(x) == true setara dengan x - 0 mengembalikan NaN (meskipun di JavaScript x - 0 == NaN selalu mengembalikan false, jadi anda tidak bisa mengujinya). Sebenarnya, isNaN(x), isNaN(x - 0), isNaN(Number(x)), Number.isNaN(x - 0), dan Number.isNaN(Number(x)) selalu kembali sama dan di JavaScriptisNaN(x) hanya bentuk sesingkat mungkin untuk mengungkapkan masing-masing istilah ini.

Anda dapat menggunakan ini, misalnya, untuk menguji apakah sebuah argumen terhadap suatu fungsi secara aritmatika dapat diolah (dapat digunakan "seperti" angka), atau jika tidak dan Anda harus memberikan nilai default atau yang lainnya. Dengan cara ini Anda dapat memiliki fungsi yang memanfaatkan fleksibilitas penuh JavaScript yang disediakan oleh nilai konversi secara implisit bergantung pada konteks.

function increment(x) {
  if (isNaN(x)) x = 0;
  return x + 1;
}

// Efek yang sama dengan Number.isNaN():
function increment(x) {
  if (Number.isNaN(Number(x))) x = 0;
  return x + 1;
}

// Dalam kasus berikut untuk argumen fungsi x,
// isNaN(x)selalu salah, meski x memang bukan sebuah
// nomor, namun bisa digunakan seperti itu dalam ekspresi
// aritmatika
increment('');            // 1: "" dikonversi ke 0
increment(new String());  // 1: Objek String yang mewakili string kosong dikonversi menjadi 0
increment([]);            // 1: [] dikonversi ke 0
increment(new Array());   // 1: Objek array yang mewakili sebuah array kosong dikonversi menjadi 0
increment('0');           // 1: "0" dikonversi ke 0
increment('1');           // 2: "1" dikonversi ke 1
increment('0.1');         // 1.1: "0.1" dikonversi ke 0.1
increment('Infinity');    // Infinity: "Infinity" dikonversi ke Infinity
increment(null);          // 1: null dikonversi ke 0
increment(false);         // 1: false dikonversi ke 0
increment(true);          // 2: true dikonversi ke 1
increment(new Date());    // mengembalikan tanggal/waktu sekarang dalam milidetik ditambah 1

// Dalam kasus berikut untuk argumen fungsi x,
// isNaN(x) selalu false dan x memang angka
increment(-1);            // 0
increment(-0.1);          // 0.9
increment(0);             // 1
increment(1);             // 2
increment(2);             // 3
// ... dan seterusnya ...
increment(Infinity);      // Infinity

// Dalam kasus berikut untuk argumen fungsi x,
// isNaN(x) selalu true dan x benar-benar bukan angka,
// sehingga fungsi tersebut menggantikannya dengan 0 dan mengembalikan 1
increment(String);            // 1
increment(Array);             // 1
increment('blabla');          // 1
increment('-blabla');         // 1
increment(0 / 0);               // 1
increment('0 / 0');             // 1
increment(Infinity / Infinity); // 1
increment(NaN);               // 1
increment(undefined);         // 1
increment();                  // 1

// isNaN(x) selalu sama dengan isNaN(Number(x)),
// namun kehadirannya x adalah wajib disini!
isNaN(x) == isNaN(Number(x)); // true untuk setiap nilai x, termasuk x == undefined,
                              // karena isNaN(undefined) == true dan Number(undefined) mengembalikan NaN,
                              // namun ...
isNaN() == isNaN(Number());   // false, karena isNaN() == true dan Number() == 0

• NaN
• Number.isNaN()