Wie überprüft man in JavaScript, ob eine Zahl NaN ist?

Question

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;

Answer 1

Ab dem ES6 , Object.is(..) ist ein neues Dienstprogramm, mit dem man zwei Werte auf absolute Gleichheit prüfen kann:

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

Answer 2

NaN ist ein spezieller Wert, der nicht auf diese Weise getestet werden kann. Eine interessante Sache, die ich Ihnen mitteilen wollte, ist dies

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

Dies ergibt true nur für NaN-Werte und ist eine sichere Methode zum Testen. Sollte auf jeden Fall in eine Funktion verpackt oder zumindest kommentiert werden, weil es offensichtlich nicht viel Sinn macht, zu testen, wenn die gleiche Variable nicht gleich ist, hehe.

Answer 3

NaN steht in JavaScript für "Not A Number", obwohl der Typ eigentlich eine Zahl ist.

typeof(NaN) // "number"

Um zu prüfen, ob eine Variable den Wert NaN hat, können wir nicht einfach die Funktion isNaN() verwenden, denn isNaN() hat das folgende Problem, 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

Das macht eigentlich Sinn, denn "A" ist eigentlich keine Zahl. Aber was wir wirklich prüfen wollen, ist, ob myVar genau den Wert NaN hat.

isNaN() kann also nicht helfen. Was sollten wir dann stattdessen tun?

Angesichts der Tatsache, dass NaN der einzige JavaScript-Wert ist, der ungleich sich selbst behandelt wird, können wir seine Gleichheit mit sich selbst mit !== überprüfen

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

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

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

Zum Schluss Wenn es wahr ist, dass eine Variable !== sich selbst ist, dann hat diese Variable genau den Wert NaN:

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

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

Answer 4

Um das Problem zu beheben, bei dem '1.2geoff' geparst wird, verwenden Sie einfach die Number() stattdessen den Parser.

Also eher als dies:

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

Tun Sie dies:

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

EDIT: Ich habe gerade bemerkt, ein anderes Problem von diesem obwohl... falsche Werte (und wahr als eine echte boolesche) übergeben in Number() zurückkehren als 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 einen Benchmark durchgeführt, der 90% langsamer als der von lodash ist. _.isNaN aber das deckt nicht alle NaN's ab:

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

Nur um das klarzustellen: Meiner kümmert sich um die menschliche wörtliche Interpretation von etwas, das "keine Zahl" ist, und der von lodash kümmert sich um die wörtliche Interpretation des Computers, um zu prüfen, ob etwas "NaN" ist.

Answer 5

Die Regel lautet:

NaN != NaN

Das Problem der Funktion isNaN() ist, dass sie in manchen Fällen ein unerwartetes Ergebnis liefert:

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

Eine bessere Möglichkeit zu prüfen, ob der Wert wirklich NaN ist, ist:

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

is_nan(parseFloat("geoff"))