Próbowałem tylko w konsoli JavaScript Firefoksa, ale żadne z poniższych stwierdzeń nie jest prawdziwe:

parseFloat('geoff') == NaN;

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

Wypróbuj ten kod:

isNaN(parseFloat("geoff"))

Aby sprawdzić, czy jakakolwiek wartość to NaN, a nie tylko liczby, zobacz tutaj: Jak testujesz NaN w JavaScript?

Właśnie natrafiłem na tę technikę w książce Skuteczne JavaScript, która jest dość prosta:

Ponieważ NaN jest jedyną wartością JavaScript, która jest traktowana jako nierówna w stosunku do siebie, zawsze możesz sprawdzić, czy wartość jest NaN, sprawdzając, czy jest równa:

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

Nie zdawałem sobie z tego sprawy, dopóki @allsyed nie skomentował, ale jest to w specyfikacji ECMA: https://tc39.github.io/ecma262/#sec-isnan-number

Użyj tego kodu:

isNaN('geoff');

Zobacz isNaN()dokumenty w MDN .

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

Jeśli chodzi o wartość typu Number, która ma zostać przetestowana, czy jest to, NaNczy nie, funkcja globalna isNaNwykona pracę

isNaN(any-Number);

Aby uzyskać ogólne podejście, które działa dla wszystkich typów w JS, możemy użyć dowolnego z poniższych:

Dla użytkowników ECMAScript-5:

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

Dla osób używających ECMAScript-6:

#2
Number.isNaN(x);

Aby uzyskać spójność w ECMAScript 5 i 6, możemy również użyć tego wypełnienia dla 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;
}

proszę sprawdzić tę odpowiedź, aby uzyskać więcej informacji.

NaN to specjalna wartość, której nie można tak przetestować. Interesującą rzeczą, którą chciałem się tylko podzielić, jest to

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

Zwraca wartość true tylko dla wartości NaN i jest bezpiecznym sposobem testowania. Zdecydowanie powinien być zawinięty w funkcję lub przynajmniej skomentowany, ponieważ oczywiście nie ma sensu testowanie, czy ta sama zmienna nie jest sobie równa, hehe.

Powinieneś użyć globalnego isNaN(value)wywołania funkcji, ponieważ:

• Jest obsługiwany w różnych przeglądarkach
• Zobacz isNaN dokumentacji

Przykłady:

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

Mam nadzieję, że to Ci pomoże.

Począwszy od ES6 , Object.is(..)jest nowym narzędziem, które można wykorzystać do testowania dwóch wartości absolutnej równości:

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

Aby naprawić problem '1.2geoff'polegający na Number()analizie składni , po prostu użyj parsera.

Więc raczej niż to:

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

Zrób to:

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

EDYCJA: Właśnie zauważyłem inny problem z tego powodu ... fałszywe wartości (i prawdziwe jak prawdziwy boolean) zostały Number()zwrócone jako 0! W takim przypadku ... parseFloat działa za każdym razem. Wróćmy więc do tego:

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

I to obejmuje na pozór wszystko. Testowałem go o 90% wolniej niż lodash, _.isNaNale to nie obejmuje wszystkich NaN:

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

Żeby było jasne, moje zajmuje się dosłowną ludzką interpretacją czegoś, co nie jest „liczbą”, a lodash zajmuje się dosłowną komputerową interpretacją sprawdzania, czy coś jest „NaN”.

Chociaż odpowiedź @chiborga JEST poprawna, należy zwrócić uwagę na jeszcze więcej:

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

Chodzi o to, że jeśli używasz tej metody do sprawdzania poprawności danych wejściowych, wynik będzie raczej liberalny.

Tak, więc możesz użyć parseFloat(string)(lub w przypadku liczb pełnych parseInt(string, radix)”, a następnie owinąć je isNaN(), ale pamiętaj o gotcha z liczbami splecionymi z dodatkowymi znakami nienumerycznymi.

Proste rozwiązanie!

NAPRAWDĘ super proste! Tutaj! Miej tę metodę!

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

Użyj tak prostego jak:

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

Zobacz test wydajnościhere za pomocą tego func vsselected answer

Ponadto: patrz poniżej 1. przykład kilku alternatywnych implementacji.

Przykład:

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>

Istnieje kilka alternatywnych ścieżek, które wybierasz do implementacji, jeśli nie chcesz używać metody o alternatywnej nazwie i chciałbyś upewnić się, że jest ona bardziej dostępna na całym świecie. Ostrzeżenie Te rozwiązania obejmują modyfikowanie obiektów rodzimych i mogą nie być najlepszym rozwiązaniem. Zawsze zachowaj ostrożność i pamiętaj, że inne biblioteki, których możesz użyć, mogą zależeć od kodu natywnego lub podobnych zmian.

Alternatywna implementacja 1: Zastąp isNaNmetodę rodzimą .

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

Alternatywne wdrożenie 2: Dołącz do obiektu liczbowego
^{* Sugerowane, ponieważ jest to również wielokrotne wypełnienie dla ECMA od 5 do 6}

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

_Test rozwiązania alternatywnego, _{jeśli jest pusty}

Prostą metodę okna napisałem ten test, jeśli obiekt jest Pusty . Jest trochę inny w tym, że nie daje, jeśli przedmiot jest „dokładnie” NaN , ale pomyślałem, że zwymiotuję, ponieważ może to być przydatne, gdy szukam pustych przedmiotów.

/** 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);
})();

Przykład:

;(function() {
   function isEmpty(a) { return !a || void 0 === a || a !== a || 0 >= a || "object" == typeof a && /\{\}|\[(null(,)*)*\]/.test(JSON.stringify(a)); };
   window.hasOwnProperty("empty")||(window.empty=isEmpty);
})();

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': new Array(),
    'an empty Array w/ 9 len': new Array(9),
    '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 = empty(example[x]),
		strAnswer = answer.toString();
	$("#t1").append(
		$("<tr />", { "class": strAnswer }).append(
			$("<th />", { html: x }),
			$("<td />", { html: strAnswer.toUpperCase() })
		)
	)
};


function isReallyNaN(a) { return a !== a; };
for(x in example){var answer=isReallyNaN(example[x]),strAnswer=answer.toString();$("#t2").append($("<tr />",{"class":strAnswer}).append($("<th />",{html:x}),$("<td />",{html:strAnswer.toUpperCase()})))};

table { border-collapse: collapse; float: left; }
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 id="t1"><thead><tr><th colspan="2">isEmpty()</th></tr></thead><thead><tr><th>Value Type</th><th>Bool Return</th></tr></thead></table>
<table id="t2"><thead><tr><th colspan="2">isReallyNaN()</th></tr></thead><thead><tr><th>Value Type</th><th>Bool Return</th></tr></thead></table>

Bardzo dokładne sprawdzenie, czy jest puste

Ten ostatni jest nieco głęboki, nawet sprawdzając, czy obiekt jest pełen pustych obiektów. Jestem pewien, że ma miejsce na ulepszenia i możliwe doły, ale jak dotąd wydaje się, że łapie większość wszystkiego.

function isEmpty(a) {
	if (!a || 0 >= a) return !0;
	if ("object" == typeof a) {
		var b = JSON.stringify(a).replace(/"[^"]*":(0|"0*"|false|null|\{\}|\[(null(,)?)*\]),?/g, '').replace(/"[^"]*":\{\},?/g, '');
		if ( /^$|\{\}|\[\]/.test(b) ) return !0;
		else if (a instanceof Array)  {
			b = b.replace(/(0|"0*"|false|null|\{\}|\[(null(,)?)*\]),?/g, '');
			if ( /^$|\{\}|\[\]/.test(b) ) return !0;
		}
	}
	return false;
}
window.hasOwnProperty("empty")||(window.empty=isEmpty);

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': new Array(),
    'an empty Array w/ 9 len': new Array(9),
    'a semi-passed parse': parseInt('5a5'),
    'a non-empty Array': [ 'a', 'b', 'c' ],
    'Math to NaN': Math.log(-1),
    'an undefined object': undefined,
    'Object Full of Empty Items': { 1: '', 2: [], 3: {}, 4: false, 5:new Array(3), 6: NaN, 7: null, 8: void 0, 9: 0, 10: '0', 11: { 6: NaN, 7: null, 8: void 0 } },
    'Array Full of Empty Items': ["",[],{},false,[null,null,null],null,null,null,0,"0",{"6":null,"7":null}]
  }

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


function isReallyNaN(a) { return a !== a; };
for(x in example){var answer=isReallyNaN(example[x]),strAnswer=answer.toString();$("#t2").append($("<tr />",{"class":strAnswer}).append($("<th />",{html:x}),$("<td />",{html:strAnswer.toUpperCase()})))};

table { border-collapse: collapse; float: left; }
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 id="t1"><thead><tr><th colspan="2">isEmpty()</th></tr></thead><thead><tr><th>Value Type</th><th>Bool Return</th></tr></thead></table>
<table id="t2"><thead><tr><th colspan="2">isReallyNaN()</th></tr></thead><thead><tr><th>Value Type</th><th>Bool Return</th></tr></thead></table>

Chcę tylko podzielić się inną alternatywą, niekoniecznie jest lepsza niż inne tutaj, ale myślę, że warto spojrzeć na:

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

Logika tego polega na tym, że każda liczba oprócz 0 i NaNjest obsadzona true.

Zrobiłem szybki test, który Number.isNaNsprawdza się zarówno pod względem fałszowania, jak i sprawdzania. Wszystkie trzy działają lepiej niżisNan

Wyniki

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

Może się przydać, jeśli chcesz uniknąć zepsutej isNaNfunkcji.

Jeśli twoje środowisko obsługuje ECMAScript 2015 , możesz użyć Number.isNaNtego, aby upewnić się, że wartość jest naprawdę NaN.

Problem isNaNpolega na tym, że jeśli używasz tego z danymi nienumerycznymi, stosuje się niewiele mylących reguł (zgodnie z MDN). Na przykład,

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

Tak więc w środowiskach obsługiwanych przez ECMA Script 2015 możesz chcieć użyć

Number.isNaN(parseFloat('geoff'))

NaN w JavaScript oznacza „Not A Number”, chociaż jego typ to w rzeczywistości liczba.

typeof(NaN) // "number"

Aby sprawdzić, czy zmienna ma wartość NaN, nie możemy po prostu użyć funkcji isNaN (), ponieważ isNaN () ma następujący problem, patrz poniżej:

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

To, co się naprawdę dzieje, to fakt, że myVar jest domyślnie przymuszany do pewnej liczby:

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

To ma sens, ponieważ „A” w rzeczywistości nie jest liczbą. Ale tak naprawdę chcemy sprawdzić, czy myVar ma dokładnie wartość NaN.

Więc isNaN () nie może pomóc. Co zatem powinniśmy zrobić?

W świetle tego, że NaN jest jedyną wartością JavaScript, która jest traktowana nierówno względem siebie, więc możemy sprawdzić jej równość względem siebie za pomocą! ==

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

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

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

Podsumowując , jeśli prawdą jest, że sama zmienna! ==, to ta zmienna ma dokładnie wartość NaN:

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

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

Korzystam zisNaN funkcji podkreślenia, ponieważ w JavaScript:

isNaN(undefined) 
-> true

Przynajmniej bądź świadomy tej gotcha.

Może także to:

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

Wygląda na to, że isNaN () nie jest obsługiwany w Node.js po wyjęciu z pudełka.
Pracowałem z

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

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

Operator równości (== i ===) nie może być używany do testowania wartości względem NaN.

Spójrz na dokumentację Mozilli Globalna właściwość NaN jest wartością reprezentującą Not-A-Numbe

Najlepszym sposobem jest użycie „isNaN ()”, która jest wbudowaną funkcją sprawdzania NaN. Wszystkie przeglądarki obsługują sposób ..

Reguła jest następująca:

NaN != NaN

Problemem funkcji isNaN () jest to, że w niektórych przypadkach może zwrócić nieoczekiwany wynik:

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

Lepszym sposobem sprawdzenia, czy naprawdę jest NaN, jest:

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

is_nan(parseFloat("geoff"))

Według IEEE 754 wszystkie relacje z udziałem NaN są oceniane jako fałszywe, z wyjątkiem! =. Zatem na przykład (A> = B) = fałsz i (A <= B) = fałsz, jeśli A lub B lub oba są / są NaN.

Napisałem tę odpowiedź na inne pytanie na StackOverflow, gdzie inna sprawdza kiedy, NaN == nullale potem została oznaczona jako duplikat, więc nie chcę marnować pracy.

Spójrz na Mozilla Developer Network o NaN.

Krótka odpowiedź

Po prostu użyj, distance || 0jeśli chcesz mieć pewność, że cenisz właściwy numer lub isNaN()go sprawdzić.

Długa odpowiedź

NaN (Not-a-Number) to dziwny obiekt globalny w javascript, często zwracany w przypadku niepowodzenia niektórych operacji matematycznych.

Chciałeś sprawdzić, NaN == nullktóre wyniki false. Hovewer nawet NaN == NaNwyniki zfalse .

Prosty sposób na sprawdzenie, czy zmienna jest NaN funkcją globalną isNaN().

Innym jest x !== x prawdą tylko wtedy, gdy x jest NaN. (dzięki za przypomnienie @ raphael-schweikert)

Ale dlaczego krótka odpowiedź zadziałała?

Dowiedzmy Się.

Po wywołaniu NaN == falsewynik jest falsetaki sam jakNaN == true .

Gdzieś w specyfikacjach JavaScript ma rekord z zawsze fałszywymi wartościami, który obejmuje:

• NaN - Brak numeru
• "" - pusta struna
• false - boolean false
• null - zerowy obiekt
• undefined - niezdefiniowane zmienne
• 0 - numerycznie 0, w tym +0 i -0

Inne rozwiązanie wspomniane jest na stronie parseFloat w MDN

Zapewnia funkcję filtrowania do dokładnego analizowania

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

A potem możesz użyć, isNaNaby sprawdzić, czy tak jestNaN

Dokładny sposób sprawdzenia to:

//takes care of boolen, undefined and empty

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

Stworzyłem tę małą funkcję, która działa jak urok. Zamiast sprawdzania NaN, który wydaje się sprzeczny z intuicją, sprawdzasz liczbę. Jestem pewien, że nie jestem pierwszym, który zrobił to w ten sposób, ale pomyślałem, że się podzielę.

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

    return retval;
}

Znalazłem inny sposób, dla zabawy.

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

Odpowiedź markyzm działa dobrze, ale nie zwraca fałszu, Infinityponieważ Infinity technicznie nie jest liczbą.

wymyśliłem isNumberfunkcję, która sprawdzi, czy jest to liczba.

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"));

AKTUALIZACJA: zauważyłem, że ten kod zawodzi w przypadku niektórych parametrów, więc poprawiłem go.

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);

To nie jest eleganckie. ale po wypróbowaniu isNAN () doszedłem do tego rozwiązania, które jest kolejną alternatywą. W tym przykładzie zezwoliłem również na „.” ponieważ maskuję za float. Możesz to również odwrócić, aby upewnić się, że nie są używane żadne liczby.

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

Jest to ocena jednoznakowa, ale można również zapętlić ciąg znaków, aby sprawdzić dowolne liczby.

Możesz sprawdzić NaN za pomocą funkcji javascript isNaN. Tylko przekazanie liczby lub wartości do funkcji 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

Po prostu przekonwertuj wynik na String i porównaj z „NaN”.

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

Czy (NaN> = 0) ? ...... „ Nie wiem ”.

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

Warunki są wykonywane tylko wtedy, gdy PRAWDA .

Nie na FAŁSZ .

Nie w „ Nie wiem ”.