isNaN()

isNaN() bir değerin NaN olup olmadığını belirler. Not: isNaN işlevi içindeki zorlamanın ilginç kuralları vardır; alternatif olarak ECMAScript 2015'te tanımlandığı gibi Number.isNaN() yöntemini kullanmak isteyebilirsiniz.

isNaN(deger)

değer

Test edilecek değer.

Verilen değer NaN ise true; değilse false.

JavaScript'teki diğer tüm olası değerlerden farklı olarak, bir değerin NaN olup olmadığını belirlemek için eşitlik operatörlerine (== ve ===) güvenmek mümkün değildir, çünkü NaN == NaN ve NaN === NaN false olarak değerlendirilir. BU yüzden isNaN işlevi.

NaN değerleri, aritmetik işlemler tanımsız (undefined) veya tekrarlanamayan değerlerle sonuçlandığında üretilir. Bu tür değerler mutlaka taşma koşullarını temsil etmez. NaN ayrıca, ilkel sayısal değerin bulunmadığı sayısal olmayan değerlerin sayısal değerlerine zorlama girişiminden de kaynaklanır.

Örneğin, sıfıra sıfıra bölmek bir NaN ile sonuçlanır - ancak diğer sayıları sıfıra bölmek olmaz.

İsNaN işlev belirtiminin en eski sürümleri olduğundan, sayısal olmayan bağımsız değişkenler için davranışı kafa karıştırıcı olur. İsNaN işlevinin bağımsız değişkeni Number türünde değilse, değer önce bir Number öğesine zorlanır. Dağa sonra elde edilen değer daha sonra NaN olup olmadığını belirlemek için test edilir. Bu nedenle, sayısal tipe zorlandığında, geçerli bir NaN olmayan sayısal değerle sonuçlanan sayılar için (özellikle boş dize ve boolean ilkelleri, zorlandığında sayısal değerler sıfır veya bir verir), "false" döndürülen değer beklenmedik olabilir; örneğin, boş dize mutlaka "bir sayı değildir". Karışıklık, "sayı değil" teriminin IEEE-754 kayan nokta değerleri olarak gösterilen sayılar için özel bir anlamı olduğu gerçeğinden kaynaklanmaktadır. İşlev, "bu değer, sayısal değere zorlandığında IEEE-754 'Sayı Değil' değeri mi?" Sorusunu yanıtlıyor olarak yorumlanmalıdır.

ECMAScript 2015, Number.isNaN () işlevini içerir. Number.isNaN(x), x'in NaN olup olmadığını test etmenin güvenilir bir yoludur. Bununla birlikte, Number.isNaN ile bile, NaN'nin anlamı, basitçe "bir sayı değil", kesin sayısal anlam olarak kalır. Alternatif olarak, Number.isNaN yokluğunda, (x != x) ifadesi, x değişkeninin NaN olup olmadığını test etmenin daha güvenilir bir yoludur, çünkü sonuç isNaN'yi güvenilir olmayan sahte pozitiflere tabi değildir.

isNaN için bir çoklu dolgu (çoklu dolgu, NaN'nin kendine özgü asla eşit olmayan özelliğini kullanır):

var isNaN = function(deger) {
    var n = Number(deger);
    return n !== n;
};

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

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

// strings
isNaN('37');      // false: "37", NaN olmayan 37 sayısına dönüştürülür
isNaN('37.37');   // false: "37.37", NaN olmayan 37.37 sayısına dönüştürülür
isNaN("37,5");    // true
isNaN('123ABC');  // true:  parseInt("123ABC") 123, ancak Number("123ABC")
isNaN('');        // false: boş dize, NaN olmayan 0'a dönüştürülür
isNaN(' ');       // false: boşluklu bir dize, NaN olmayan 0'a dönüştürülür

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

// Bu yanlış bir pozitiftir ve isNaN'ın tamamen güvenilir olmamasının nedenidir
isNaN('blabla');   // true: "blabla" bir sayıya dönüştürülür.
                   // Bunu bir sayı olarak ayrıştırma başarısız olur ve NaN döndürür

İsNaN() yöntemini düşünmek için daha çok kullanıma yönelik bir yol vardır: isNaN(x) false değerini döndürürse, ifadeyi NaN döndürmeyen bir aritmetik ifadede x kullanabilirsiniz. true değerini döndürürse, x her aritmetik ifadeyi NaN döndürür. Bu, JavaScript'te, isNaN(x) == true değerinin, NaN döndüren x - 0'a eşdeğer olduğu anlamına gelir (JavaScript x - 0 == NaN'de her zaman false döndürür, bu nedenle test edemezsiniz). Aslında, isNaN(x), isNaN(x - 0), isNaN(Number(x)), Number.isNaN(x - 0) ve Number.isNaN(Number(x)) her zaman aynı döndürür ve JavaScript isNaN(x) bu terimlerin her birini ifade etmek için mümkün olan en kısa biçimdir.

Örneğin, bir işleve ait bir argümanın aritmetik olarak işlenebilir (bir sayı gibi "kullanılabilir") veya değilse ve varsayılan bir değer veya başka bir şey sağlamanız gerekip gerekmediğini test etmek için kullanabilirsiniz. Bu şekilde, içeriğe bağlı olarak değerleri dolaylı olarak dönüştürerek JavaScript'in sağladığı çok yönlülüğü kullanan bir işleve sahip olabilirsiniz.

function artım(x) {
  if (isNaN(x)) x = 0;
  return x + 1;
}

// Number.isNaN() ile aynı etki:
function artım(x) {
  if (Number.isNaN(Number(x))) x = 0;
  return x + 1;
}

// Aşağıdaki durumlarda işlevin x argümanı için,
// isNaN(x) her zaman yanlıştır, ancak x gerçekten bir
// ancak aritmetik olarak kullanılabilir
// ifadeler
increment('');            // 1: "", 0'a dönüştürülür
increment(new String());  // 1: Boş bir dizeyi temsil eden dize nesnesi 0'a dönüştürülür
increment([]);            // 1: [], 0'a dönüştürülür
increment(new Array());   // 1: Boş bir diziyi temsil eden dizi nesnesi 0'a dönüştürülür
increment('0');           // 1: "0", 0'a dönüştürülür
increment('1');           // 2: "1", 1'e dönüştürülür
increment('0.1');         // 1.1: "0.1", 0.1'a dönüştürülür.
increment('Infinity');    // Infinity: "Infinity", Infinity dönüştürülür
increment(null);          // 1: null değeri 0'a dönüştürülür
increment(false);         // 1: false değeri 0'a dönüştürülür
increment(true);          // 2: true değeri 1'e dönüştürülür
increment(new Date());    // milisaniye cinsinden geçerli tarih/saati döndürür artı 1

// Aşağıdaki durumlarda işlevin x argümanı için,
// isNaN (x) her zaman falsetır ve x gerçekten bir sayıdır.
increment(-1);            // 0
increment(-0.1);          // 0.9
increment(0);             // 1
increment(1);             // 2
increment(2);             // 3
// ...ve bunun gibi...
increment(Infinity);      // Infinity

// Aşağıdaki durumlarda işlevin x argümanı için,
// isNaN(x) her zaman doğrudur ve x gerçekten bir sayı değildir,
// böylece fonksiyon 0 ile değiştirilir ve 1 döndürür
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) her zaman isNaN(Number(x)) ile aynıdır,
// ama x'in varlığı burada zorunludur!
isNaN(x) == isNaN(Number(x)); // x == undefined dahil, x'in her değeri için true,
                              // çünkü isNaN(undefined) == true ve Number(undefined) NaN değerini döndürür,
                              // ama...
isNaN() == isNaN(Number());   // false, çünküisNaN() == true ve Number() == 0

• NaN
• Number.isNaN()