Ik heb het alleen geprobeerd in de JavaScript-console van Firefox, maar geen van de volgende uitspraken is waar:

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

Antwoord 1, autoriteit 100%

Probeer deze code:

isNaN(parseFloat("geoff"))

Voor het controleren of eenwaarde NaN is, in plaats van alleen getallen, zie hier: Hoe test u NaN in Javascript?

Antwoord 2, autoriteit 25%

Ik kwam deze techniek net tegen in het boek Effectief JavaScriptdat mooi is eenvoudig:

Aangezien NaN de enige JavaScript-waarde is die als ongelijk aan zichzelf wordt beschouwd, kunt u altijd testen of een waarde NaN is door deze te controleren op gelijkheid met zichzelf:

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

Ik realiseerde me dit pas toen @allsyed een opmerking maakte, maar dit staat in de ECMA-specificatie: https://tc39.github.io/ecma262/#sec-isnan-nummer

Antwoord 3, autoriteit 9%

Gebruik deze code:

isNaN('geoff');

Zie isNaN()documenten op MDN.

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

Antwoord 4, autoriteit 8%

Voor zover een waarde van het type Numbermoet worden getest of het een NaNof niet, de globale functie isNaNzal het werk doen

isNaN(any-Number);

Voor een generieke aanpak die voor alle typen in JS werkt, kunnen we een van de volgende gebruiken:

Voor ECMAScript-5-gebruikers:

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

Voor mensen die ECMAScript-6 gebruiken:

#2
Number.isNaN(x);

En voor consistentie in ECMAScript 5 & 6 beide, kunnen we ook deze polyfill gebruiken voor 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;
}

controleer Dit antwoordvoor meer details.

Antwoord 5, Autoriteit 3%

Vanaf ES6 , Object.is(..)is een nieuw hulpprogramma dat kan worden gebruikt om twee waarden te testen voor absolute gelijkheid:

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

Antwoord 6, Autoriteit 3%

NAN is een speciale waarde die niet zo kan worden getest. Een interessant iets dat ik gewoon wilde delen, is dit

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

Hierdoor wordt er opzicht geretourneerd alleen voor NAN-waarden en is een veilige manier van testen. Moet zeker worden gewikkeld in een functie of tenminste, omdat het niet veel logisch is om te testen als dezelfde variabele niet gelijk is aan elkaar, hehe.

Antwoord 7, Autoriteit 2%

U moet de GLOBALE isNaN(value)FUNCTION-oproep gebruiken, omdat:

• Het is ondersteund Cross-Browser
• Zie isnan voor documentatie

Voorbeelden:

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

Ik hoop dat dit u zal helpen.

Antwoord 8, Autoriteit 2%

Om het probleem op te lossen waarbij '1.2geoff'wordt geparseerd, gebruik dan gewoon de Number()parser in plaats daarvan.

dus in plaats van dit:

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

Doe dit:

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

EDIT: ik heb hier zojuist een ander probleem opgemerkt… valse waarden (en waar als een echte boolean) doorgegeven aan Number()return als 0! In dat geval… werkt parseFloat in plaats daarvan elke keer. Dus val daarop terug:

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

En dat dekt schijnbaar alles. Ik heb het vergeleken met 90% langzamer dan _.isNaNvan lodash, maar die dekt niet alle NaN’s:

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

Voor alle duidelijkheid, de mijne zorgt voor de menselijke letterlijke interpretatie van iets dat “Geen Nummer” is en die van Lodash zorgt voor de computer letterlijke interpretatie van het controleren of iets “NaN” is.

Antwoord 9

Hoewel het antwoord van @chiborg klopt, is er meer dat moet worden opgemerkt:

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

Het punt is dat als je deze methode gebruikt voor het valideren van invoer, het resultaat nogal liberaal zal zijn.

Dus, ja, u kunt parseFloat(string)(of in het geval van volledige nummers parseInt(string, radix)‘gebruiken en vervolgens dat met isNaN(), maar wees op de hoogte van de GOTCHA met nummers met elkaar verweven met extra niet-numerieke tekens.

Antwoord 10

NAN in JavaScript staat voor “Geen nummer”, hoewel het type eigenlijk nummer is.

typeof(NaN) // "number"

Controleer of een variabele van waarde NAN is, kunnen we niet simpelweg de functie-ISNAN () gebruiken, omdat ISNAN () het volgende probleem heeft, zie hieronder:

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

Wat hier echt gebeurt, is dat Myvar impliciet wordt gedwongen tot een nummer:

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

Het is eigenlijk logisch, omdat “A” eigenlijk geen nummer is. Maar wat we echt willen controleren, is of Myvar precies van waarde Nan is.

Zo is NAN () kan niet helpen. Wat moeten we dan doen?

In het licht dat NAN de enige JavaScript-waarde is die ongelijk op zichzelf wordt behandeld, zodat we kunnen controleren op zijn gelijkheid om te gebruiken! ==

var myVar; // undefined
myVar !== myVar // false
var myVar = "A";
myVar !== myVar // false
var myVar = NaN
myVar !== myVar // true

Dus om te sluiten, als het waar is dat een variabele! == zelf, dan is deze variabele precies van waarde Nan:

function isOfValueNaN(v) {
    return v !== v;
}
var myVar = "A";
isNaN(myVar); // true
isOfValueNaN(myVar); // false

Antwoord 11

Als uw omgeving ECMAScript 2015 ondersteunt, wilt u misschien Number.isNaNom er zeker van te zijn dat de waarde echt NaNis.

Het probleem met isNaNis, als u gebruik dat bij niet-numerieke gegevens er weinig verwarrende regels (volgens MDN) worden toegepast.Bijvoorbeeld,

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

Dus, in door ECMA Script 2015 ondersteunde omgevingen, wil je misschien

. gebruiken

Number.isNaN(parseFloat('geoff'))

Antwoord 12

Eenvoudige oplossing!

ECHT supereenvoudig! Hier! Gebruik deze methode!

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

Gebruik zo simpel als:

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

Bekijk de prestatietest hiermet deze functie versus geselecteerd antwoord< /kbd>

Ook: zie hieronder het eerste voorbeeld voor een paar alternatieve implementaties.

Voorbeeld:

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>

isNaN(undefined) 
-> true

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

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

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

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

NaN != NaN

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

function is_nan(value) {
    return value != value
}
is_nan(parseFloat("geoff"))

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

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

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

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

//takes care of boolen, undefined and empty
isNaN(x) || typeof(x) ==='boolean' || typeof(x) !=='undefined' || x!=='' ? 'is really a nan' : 'is a number'

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

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

alert("1234567890.".indexOf(String.fromCharCode(mycharacter))>-1);

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

Number('hello').toString() === 'NaN' // true
Number(undefined).toString() === 'NaN' // true
Number('12345').toString() === 'NaN' // false  
// These all evaluate to 0 which is a number
Number('').toString() === 'NaN' // false // 0
Number('0').toString() === 'NaN' // false // 0
Number().toString() === 'NaN' // false // 0
// These all evaluate to 0 and 1 which is a number
Number(false).toString() === 'NaN' // false // 0
Number(true).toString() === 'NaN' // false // 1

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

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