Ich habe es nur in der JavaScript-Konsole von Firefox versucht, aber keine der folgenden Anweisungen gibt true zurück:

parseFloat('geoff') == NaN;

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

Versuchen Sie diesen Code:

isNaN(parseFloat("geoff"))

Hier erfahren Sie, ob ein Wert NaN ist und nicht nur Zahlen: Wie testen Sie NaN in Javascript?

Ich bin gerade auf diese Technik in dem Buch Effective JavaScript gestoßen , das ziemlich einfach ist:

Da NaN der einzige JavaScript-Wert ist, der als ungleich zu sich selbst behandelt wird, können Sie jederzeit testen, ob ein Wert NaN ist, indem Sie ihn auf Gleichheit mit sich selbst überprüfen:

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

Ich habe dies erst erkannt, als @allsyed einen Kommentar abgegeben hat, aber dies steht in der ECMA-Spezifikation: https://tc39.github.io/ecma262/#sec-isnan-number

Verwenden Sie diesen Code:

isNaN('geoff');

Siehe isNaN()Dokumente zu MDN .

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

Soweit ein Wert vom Typ Number geprüft werden soll, ob es sich um einen Wert handelt NaNoder nicht, erledigt die globale Funktion isNaNdie Arbeit

isNaN(any-Number);

Für einen generischen Ansatz, der für alle Typen in JS funktioniert, können wir eine der folgenden Methoden verwenden:

Für ECMAScript-5-Benutzer:

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

Für Benutzer von ECMAScript-6:

#2
Number.isNaN(x);

Aus Konsistenzgründen in ECMAScript 5 und 6 können wir diese Polyfüllung auch für Number.isNan verwenden

#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;
}

Bitte überprüfen Sie diese Antwort für weitere Details.

NaN ist ein spezieller Wert, der so nicht getestet werden kann. Eine interessante Sache, die ich nur teilen wollte, ist diese

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

Dies gibt nur für NaN-Werte true zurück und ist eine sichere Methode zum Testen. Sollte definitiv in eine Funktion eingeschlossen oder zumindest kommentiert werden, da es offensichtlich nicht viel Sinn macht zu testen, ob dieselbe Variable nicht gleich ist, hehe.

Sie sollten den globalen isNaN(value)Funktionsaufruf verwenden, weil:

• Es wird browserübergreifend unterstützt
• Dokumentation finden Sie unter isNaN

Beispiele:

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

Ich hoffe, dies wird dir helfen.

Ab ES6 , Object.is(..)ist ein neues Dienstprogramm , das verwendet werden kann , zwei Werte für absolute Gleichheit zu testen:

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

'1.2geoff'Verwenden Sie Number()stattdessen einfach den Parser, um das Problem zu beheben, bei dem eine Analyse durchgeführt wird .

Also eher als das:

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

Mach das:

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

EDIT: Ich habe gerade ein anderes Problem bemerkt ... falsche Werte (und wahr als echter Boolescher Wert) wurden Number()als zurückgegeben zurückgegeben 0! In diesem Fall ... funktioniert parseFloat stattdessen jedes Mal. Also greifen Sie darauf zurück:

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

Und das deckt scheinbar alles ab. Ich habe es mit 90% langsamer als das von lodash bewertet, _.isNaNaber dann deckt man nicht alle NaNs ab:

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

Um ganz klar zu sein, meine kümmert sich um die menschliche wörtliche Interpretation von etwas, das "keine Zahl" ist, und lodashs kümmert sich um die Computer-wörtliche Interpretation der Überprüfung, ob etwas "NaN" ist.

Während @chiborgs Antwort korrekt ist, sollte noch mehr beachtet werden:

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

Wenn Sie diese Methode zur Validierung der Eingabe verwenden, ist das Ergebnis eher liberal.

Also, ja, Sie können verwenden parseFloat(string)(oder im Fall von vollständigen Zahlen parseInt(string, radix)) und diese anschließend mit umschließen isNaN(), aber beachten Sie die Gotcha mit Zahlen, die mit zusätzlichen nicht numerischen Zeichen verflochten sind.

Einfache Lösung!

Wirklich super einfach! Hier! Haben Sie diese Methode!

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

Verwenden Sie so einfach wie:

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

Siehe Leistungstesthere mit dieser Funktion vs.selected answer

Außerdem: Im folgenden ersten Beispiel finden Sie einige alternative Implementierungen.

Beispiel:

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>

Es gibt einige alternative Pfade, die Sie für die Implementierung verwenden, wenn Sie keine Methode mit alternativem Namen verwenden möchten und sicherstellen möchten, dass sie globaler verfügbar ist. Warnung Diese Lösungen umfassen das Ändern nativer Objekte und sind möglicherweise nicht die beste Lösung. Seien Sie immer vorsichtig und beachten Sie, dass andere Bibliotheken, die Sie möglicherweise verwenden, von nativem Code oder ähnlichen Änderungen abhängen können.

Alternative Implementierung 1: Native ersetzen isNaN Methode.

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

Alternative Implementierung 2: An Zahlenobjekt anhängen
^{* Vorgeschlagen, da es sich auch um eine Polyfüllung für ECMA 5 bis 6 handelt}

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

Alternative Lösung _{, wenn leer}

Eine einfache Fenstermethode Ich habe diesen Test geschrieben, wenn das Objekt leer ist . Es ist insofern etwas anders, als es nicht gibt, ob der Gegenstand "genau" NaN ist , aber ich dachte, ich würde ihn hochwerfen, da er auch nützlich sein kann, wenn nach leeren Gegenständen gesucht wird.

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

Beispiel:

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

Extrem tief prüfen, ob es leer ist

Letzteres geht ein bisschen tief und prüft sogar, ob ein Objekt voller leerer Objekte ist. Ich bin sicher, es gibt Raum für Verbesserungen und mögliche Gruben, aber bisher scheint es fast alles zu fangen.

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>

Ich möchte nur eine andere Alternative teilen, sie ist nicht unbedingt besser als andere hier, aber ich denke, es lohnt sich, sie sich anzusehen:

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

Die Logik dahinter ist, dass jede Zahl außer 0und NaNgegossen wird true.

Ich habe einen Schnelltest durchgeführt, und er funktioniert so gut wie Number.isNaNund prüft sich selbst auf falsch. Alle drei schneiden besser ab alsisNan

Die Ergebnisse

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

Kann nützlich sein, wenn Sie die isNaNFunktionsstörung vermeiden möchten .

Wenn Ihre Umgebung ECMAScript 2015 unterstützt , möchten Sie möglicherweise verwenden Number.isNaN, um sicherzustellen, dass der Wert wirklich ist NaN.

Das Problem mit isNaNist, wenn Sie das mit nicht numerischen Daten verwenden, werden nur wenige verwirrende Regeln (gemäß MDN) angewendet. Zum Beispiel,

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

In von ECMA Script 2015 unterstützten Umgebungen möchten Sie möglicherweise verwenden

Number.isNaN(parseFloat('geoff'))

NaN in JavaScript steht für "Not A Number", obwohl der Typ tatsächlich "number" ist.

typeof(NaN) // "number"

Um zu überprüfen, ob eine Variable den Wert NaN hat, können wir die Funktion isNaN () nicht einfach verwenden, da isNaN () das folgende Problem aufweist (siehe unten):

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

Was hier wirklich passiert, ist, dass myVar implizit zu einer Zahl gezwungen wird:

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

Es macht tatsächlich Sinn, weil "A" eigentlich keine Zahl ist. Was wir aber wirklich überprüfen möchten, ist, ob myVar genau den Wert NaN hat.

IsNaN () kann also nicht helfen. Was sollen wir dann stattdessen tun?

In Anbetracht dessen, dass NaN der einzige JavaScript-Wert ist, der ungleich sich selbst behandelt wird, können wir mit! == überprüfen, ob er sich selbst gleich ist

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

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

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

So zu schließen , wenn es wahr ist , dass eine Variable == selbst, dann ist diese Variable genau der Wert NaN:

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

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

Ich benutze dieisNaN Funktion des Unterstrichs, weil in JavaScript:

isNaN(undefined) 
-> true

Sei dir zumindest dieser Gotcha bewusst.

Vielleicht auch das:

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

Es scheint, dass isNaN () in Node.js nicht sofort unterstützt wird.
Ich habe mit gearbeitet

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

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

Der Gleichheitsoperator (== und ===) kann nicht zum Testen eines Werts gegen NaN verwendet werden.

Siehe Mozilla-Dokumentation Die globale NaN-Eigenschaft ist ein Wert, der Not-A-Numbe darstellt

Der beste Weg ist die Verwendung von 'isNaN ()', einer eingebauten Funktion zur Überprüfung von NaN. Alle Browser unterstützen den Weg ..

Die Regel lautet:

NaN != NaN

Das Problem der Funktion isNaN () besteht darin, dass in einigen Fällen ein unerwartetes Ergebnis zurückgegeben werden kann:

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

Ein besserer Weg, um zu überprüfen, ob der Wert wirklich NaN ist, ist:

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

is_nan(parseFloat("geoff"))

Gemäß IEEE 754 werden alle Beziehungen, an denen NaN beteiligt ist, mit Ausnahme von! = Als falsch bewertet. So ist beispielsweise (A> = B) = falsch und (A <= B) = falsch, wenn A oder B oder beide NaN sind / sind.

Ich habe diese Antwort auf eine andere Frage in StackOverflow geschrieben, bei der eine andere prüft, wann, NaN == nullaber dann wurde sie als doppelt markiert, damit ich meinen Job nicht verschwenden möchte.

Schauen Sie sich Mozilla Developer Network an NaN.

Kurze Antwort

Verwenden distance || 0Sie diese Option nur, wenn Sie sicherstellen möchten, dass Ihr Wert eine richtige Zahl ist, oder isNaN()überprüfen Sie sie.

Lange Antwort

Das NaN (Not-a-Number) ist ein seltsames globales Objekt in Javascript, das häufig zurückgegeben wird, wenn eine mathematische Operation fehlschlägt.

Sie wollten überprüfen, ob NaN == nullwelche Ergebnisse vorliegen false. Hovewer NaN == NaNergibt sogar mit false.

Ein einfacher Weg, um herauszufinden, ob eine Variable NaNeine globale Funktion ist isNaN().

Ein anderer ist x !== x die nur wahr ist, wenn x NaN ist. (danke für die Erinnerung an @ raphael-schweikert)

Aber warum hat die kurze Antwort funktioniert?

Lass es uns herausfinden.

Wenn Sie NaN == falsedas Ergebnis aufrufen, ist das falsegleiche mit NaN == true.

Irgendwo in den Spezifikationen hat JavaScript einen Datensatz mit immer falschen Werten, der Folgendes umfasst:

• NaN - Keine Nummer
• "" - leerer String
• false - ein boolescher Fehler
• null - Nullobjekt
• undefined - undefinierte Variablen
• 0 - numerische 0, einschließlich +0 und -0

Eine andere Lösung wird auf der parseFloat-Seite von MDN erwähnt

Es bietet eine Filterfunktion für striktes Parsen

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

Und dann können Sie isNaNüberprüfen, ob dies der Fall istNaN

Der genaue Weg zu überprüfen ist:

//takes care of boolen, undefined and empty

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

Ich habe diese kleine Funktion erstellt, die wie ein Zauber wirkt. Anstatt nach NaN zu suchen, was nicht intuitiv zu sein scheint, suchen Sie nach einer Nummer. Ich bin mir ziemlich sicher, dass ich nicht der erste bin, der das so macht, aber ich dachte, ich würde es teilen.

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

    return retval;
}

Einen anderen Weg gefunden, nur zum Spaß.

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

Die Antwort von marksyzm funktioniert gut, gibt aber nicht false zurück, Infinityda Infinity technisch gesehen keine Zahl ist.

Ich isNumberhabe mir eine Funktion ausgedacht, die prüft, ob es sich um eine Zahl handelt.

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: Ich habe festgestellt, dass dieser Code für einige Parameter fehlschlägt, also habe ich ihn verbessert.

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

Das ist nicht elegant. aber nachdem ich isNAN () ausprobiert hatte, kam ich zu dieser Lösung, die eine andere Alternative darstellt. In diesem Beispiel habe ich auch '.' weil ich für float maskiere. Sie können dies auch umkehren, um sicherzustellen, dass keine Zahlen verwendet werden.

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

Dies ist eine Einzelzeichenauswertung, aber Sie können auch eine Zeichenfolge durchlaufen, um nach Zahlen zu suchen.

Sie können NaN mit der Javascript-Funktion isNaN überprüfen. Übergeben Sie einfach die Zahl oder den Wert an die Funktion 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

Konvertieren Sie einfach das Ergebnis in String und vergleichen Sie es mit 'NaN'.

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

Ist (NaN> = 0) ? ...... " Ich weiß nicht ".

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

Bedingungen werden nur ausgeführt, wenn TRUE .

Nicht auf FALSE .

Nicht auf " Ich weiß nicht ".