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

Die Antwort von @chiborg ist zwar richtig, aber es gibt noch mehr, was zu beachten ist:

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

Der Punkt ist, wenn Sie diese Methode für die Validierung von Eingaben verwenden, wird das Ergebnis ziemlich liberal sein.

Also, ja, Sie können parseFloat(string) (oder im Fall von vollen Zahlen parseInt(string, radix) ' und verpacken dies anschließend mit isNaN() Beachten Sie jedoch, dass Zahlen, die mit zusätzlichen nicht-numerischen Zeichen verflochten sind, ein Problem darstellen.

Answer 2

function isNotANumber(n) {
  if (typeof n !== 'number') {
    return true;
  } 
  return n !== n;
}

Answer 3

Wenn Ihre Umgebung ECMAScript 2015 unterstützt verwenden, dann sollten Sie vielleicht Number.isNaN um sicherzustellen, dass der Wert wirklich NaN .

Das Problem mit isNaN ist, Wenn Sie das mit nicht-numerischen Daten verwenden, werden einige verwirrende Regeln (gemäß MDN) angewendet. Zum Beispiel,

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

In Umgebungen, die von ECMA Script 2015 unterstützt werden, können Sie also Folgendes verwenden

Number.isNaN(parseFloat('geoff'))

Answer 4

Einfache Lösung!

WIRKLICH super einfach! Hier! Nimm diese Methode!

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

Verwenden Sie so einfach wie:

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

Siehe Leistungstest here mit dieser Funktion gegen selected answer

Auch: Siehe unten 1. Beispiel für eine Reihe alternativer Implementierungen.

---

Exemple :

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 Wege für die Implementierung, wenn Sie keine alternativ benannte Methode verwenden wollen und sicherstellen möchten, dass diese global verfügbar ist. Warnung Diese Lösungen beinhalten die Änderung von nativen Objekten und sind möglicherweise nicht die beste Lösung. Seien Sie immer vorsichtig und seien Sie sich bewusst, dass andere Bibliotheken, die Sie verwenden, von nativem Code oder ähnlichen Änderungen abhängen können.

Alternative Implementierung 1: Ersetzen der einheimischen isNaN Methode.

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

Alternative Implementierung 2: Anhängen an Zahlenobjekt

*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 _{Test, ob leer}

Ich habe eine einfache Fenstermethode geschrieben, die prüft, ob das Objekt Leere . Es ist ein wenig anders, da es nicht angibt, ob der Gegenstand "genau" NaN aber ich dachte mir, ich werfe das mal hoch, da es auch bei der Suche nach leeren Gegenständen nützlich sein kann.

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

Exemple :

;(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 Sie, ob es leer ist

Letzteres geht ein wenig in die Tiefe und prüft sogar, ob ein Objekt voll von leeren Objekten ist. Ich bin sicher, dass es Raum für Verbesserungen und mögliche Löcher hat, aber bis jetzt scheint es fast alles zu erfassen.

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>

Answer 5

Ich benutze Unterstreichungen isNaN Funktion, weil in JavaScript:

isNaN(undefined) 
-> true

Seien Sie sich zumindest dieser Gefahr bewusst.