L'ho provato solo nella console JavaScript di Firefox, ma nessuna delle seguenti affermazioni è vera:

parseFloat('geoff') == NaN;

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

Prova questo codice:

isNaN(parseFloat("geoff"))

Per verificare se un valore è NaN, anziché solo numeri, vedere qui: Come si esegue il test per NaN in Javascript?

Ho appena scoperto questa tecnica nel libro Effective JavaScript che è abbastanza semplice:

Poiché NaN è l'unico valore JavaScript che viene considerato ineguale, è sempre possibile verificare se un valore è NaN verificandone l'uguaglianza con se stesso:

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

Non me ne sono reso conto fino a quando @allsyed non ha commentato, ma questo è nelle specifiche ECMA: https://tc39.github.io/ecma262/#sec-isnan-number

Usa questo codice:

isNaN('geoff');

Consulta i isNaN()documenti su MDN .

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

Per quanto riguarda un valore di tipo Numero da testare indipendentemente dal fatto che sia una funzione NaNo no, la funzione globale isNaNfarà il lavoro

isNaN(any-Number);

Per un approccio generico che funziona per tutti i tipi in JS, possiamo usare uno dei seguenti:

Per utenti ECMAScript-5:

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

Per le persone che utilizzano ECMAScript-6:

#2
Number.isNaN(x);

E ai fini della coerenza tra ECMAScript 5 e 6 entrambi, possiamo anche usare questo polyfill per 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;
}

controlla questa risposta per maggiori dettagli.

NaN è un valore speciale che non può essere testato in questo modo. Una cosa interessante che volevo solo condividere è questa

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

Ciò ritorna vero solo per i valori NaN ed è un modo sicuro di testare. Dovrebbe sicuramente essere racchiuso in una funzione o almeno commentato, perché ovviamente non ha molto senso verificare se la stessa variabile non è uguale l'una all'altra, hehe.

È necessario utilizzare la isNaN(value)chiamata di funzione globale , perché:

• È supportato su più browser
• Vedi isNaN per la documentazione

Esempi:

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

Spero che questo ti possa aiutare.

A partire da ES6 , Object.is(..)è una nuova utility che può essere utilizzata per testare due valori per l'uguaglianza assoluta:

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

Per risolvere il problema in cui '1.2geoff'viene analizzato, utilizzare Number()invece il parser.

Quindi piuttosto che questo:

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

Fai questo:

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

EDIT: Ho appena notato un altro problema da questo ... falsi valori (e vero come un vero booleano) sono passati in Number()cambio come 0! Nel qual caso ... parseFloat funziona ogni volta invece. Quindi ricadere su quello:

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

E questo copre apparentemente tutto. L'ho confrontato al 90% più lentamente di quello di lodash_.isNaN ma poi quello non copre tutti i NaN:

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

Per essere chiari, il mio si occupa dell'interpretazione letterale umana di qualcosa che è "Not a Number" e Lodash's si occupa dell'interpretazione letterale al computer di verificare se qualcosa è "NaN".

Mentre la risposta di @chiborg È corretta, c'è altro da notare:

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

Il punto è che, se stai usando questo metodo per la validazione dell'input, il risultato sarà piuttosto liberale.

Quindi, sì, puoi usare parseFloat(string)(o nel caso di numeri interi parseInt(string, radix)'e successivamente avvolgerlo con isNaN(), ma fai attenzione al gotcha con numeri intrecciati con caratteri non numerici aggiuntivi.

Soluzione semplice!

Davvero super semplice! Qui! Avere questo metodo!

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

Usa semplice come:

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

Vedi test delle prestazionihere usando questa funzione vsselected answer

Inoltre: vedi sotto il primo esempio per un paio di implementazioni alternative.

Esempio:

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>

Ci sono un paio di percorsi alternativi che prendi per implementaion, se non vuoi usare un metodo con nome alternativo e vuoi assicurarti che sia più disponibile a livello globale. avvertimento Queste soluzioni comportano la modifica di oggetti nativi e potrebbero non essere la soluzione migliore. Prestare sempre attenzione e tenere presente che le altre librerie che è possibile utilizzare potrebbero dipendere da codice nativo o alterazioni simili.

Implementazione alternativa 1: sostituire il isNaNmetodo nativo .

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

Implementazione alternativa 2: Aggiungi all'oggetto numero
^{* Consigliato in quanto è anche un riempimento poligonale per ECMA da 5 a 6}

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

_Test soluzione alternativa _{se vuoto}

Un semplice metodo finestra ho scritto quel test se l'oggetto è vuoto . È un po 'diverso in quanto non dà se l'oggetto è "esattamente" NaN , ma ho pensato che avrei vomitato perché potrebbe essere utile anche quando si cercano oggetti vuoti.

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

Esempio:

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

Controllo estremamente approfondito se è vuoto

Quest'ultimo va un po 'in profondità, anche controllando se un oggetto è pieno di oggetti vuoti. Sono sicuro che abbia margini di miglioramento e possibili fosse, ma finora sembra catturare quasi tutto.

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>

Voglio solo condividere un'altra alternativa, non è necessariamente migliore di altre qui, ma penso che valga la pena guardare:

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

La logica dietro questo è che ogni numero tranne 0e NaNsono espressitrue .

Ho fatto un test rapido e funziona altrettanto bene Number.isNaN e controllando se stesso per falso. Tutti e tre funzionano meglio diisNan

I risultati

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

Può essere utile se si desidera evitare la isNaNfunzione non funzionante.

Se il tuo ambiente supporta ECMAScript 2015 , potresti voler utilizzare Number.isNaNper assicurarti che il valore sia realeNaN .

Il problema isNaNè che se si utilizza che con dati non numerici vengono applicate poche regole confuse (come da MDN). Per esempio,

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

Pertanto, negli ambienti supportati da ECMA Script 2015, potresti voler utilizzare

Number.isNaN(parseFloat('geoff'))

NaN in JavaScript sta per "Not A Number", sebbene il suo tipo sia in realtà il numero.

typeof(NaN) // "number"

Per verificare se una variabile ha valore NaN, non possiamo semplicemente usare la funzione isNaN (), poiché isNaN () presenta il seguente problema, vedere di seguito:

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

Quello che succede davvero qui è che myVar è implicitamente costretto a un numero:

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

In realtà ha senso, perché "A" non è in realtà un numero. Ma ciò che vogliamo davvero verificare è se myVar ha esattamente valore NaN.

Quindi isNaN () non può essere d'aiuto. Allora cosa dovremmo fare invece?

Alla luce del fatto che NaN è l'unico valore JavaScript trattato in modo ineguale rispetto a se stesso, in modo da poterne verificare l'uguaglianza con se stesso utilizzando! ==

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

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

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

Quindi, per concludere , se è vero che una variabile! == stessa, allora questa variabile ha esattamente valore NaN:

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

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

Uso laisNaN funzione di sottolineatura perché in JavaScript:

isNaN(undefined) 
-> true

Almeno, sii consapevole di quel gotcha.

Forse anche questo:

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

Sembra che isNaN () non sia supportato in Node.js immediatamente.
Ho lavorato con

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

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

L'operatore di uguaglianza (== e ===) non può essere utilizzato per testare un valore su NaN.

Guarda la documentazione di Mozilla La proprietà NaN globale è un valore che rappresenta Not-A-Numbe

Il modo migliore è usare 'isNaN ()' che è la funzione di buit-in per controllare NaN. Tutti i browser supportano il modo in cui ..

La regola è:

NaN != NaN

Il problema della funzione isNaN () è che in alcuni casi potrebbe restituire risultati imprevisti:

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

Un modo migliore per verificare se il valore è davvero NaN è:

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

is_nan(parseFloat("geoff"))

Secondo IEEE 754, tutte le relazioni che coinvolgono NaN vengono considerate false tranne! =. Pertanto, ad esempio, (A> = B) = false e (A <= B) = false se A o B o entrambi sono / sono NaN.

Ho scritto questa risposta a un'altra domanda su StackOverflow in cui un altro controlla quando NaN == nullma poi è stato contrassegnato come duplicato, quindi non voglio sprecare il mio lavoro.

Guarda su Mozilla Developer Network su NaN.

Risposta breve

Usa solo distance || 0quando vuoi essere sicuro che il valore sia un numero corretto o isNaN()per controllarlo.

Risposta lunga

Il NaN (Not-a-Number) è uno strano oggetto globale in javascript spesso restituito quando alcune operazioni matematiche falliscono.

Volevi verificare se NaN == nullquali risultati false. Hovewer NaN == NaNrisulta anche con false.

Un modo semplice per scoprire se la variabile NaNè una funzione globaleisNaN() .

Un altro è x !== x che è vero solo quando x è NaN. (grazie per ricordare a @ raphael-schweikert)

Ma perché la risposta breve ha funzionato?

Scopriamolo.

Quando chiami NaN == falseil risultato è false, lo stesso con NaN == true.

Da qualche parte nelle specifiche JavaScript ha un record con valori sempre falsi, che include:

• NaN - Non un numero
• "" - stringa vuota
• false - un falso booleano
• null - oggetto null
• undefined - variabili non definite
• 0 - 0 numerici, compresi +0 e -0

Un'altra soluzione è menzionata nella pagina parseFloat di MDN

Fornisce una funzione di filtro per eseguire analisi rigorose

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

E poi puoi usare isNaNper verificare se lo èNaN

Il modo esatto per verificare è:

//takes care of boolen, undefined and empty

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

Ho creato questa piccola funzione che funziona come un fascino. Invece di verificare la presenza di NaN, che sembra essere contro intuitivo, si controlla un numero. Sono abbastanza sicuro di non essere il primo a farlo in questo modo, ma ho pensato di condividere.

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

    return retval;
}

Trovato un altro modo, solo per divertimento.

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

La risposta di MarkSzm funziona bene, ma non restituisce false Infinitypoiché Infinity non è tecnicamente un numero.

mi è venuta in mente una isNumberfunzione che verificherà se si tratta di un numero.

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

AGGIORNAMENTO: ho notato che questo codice non riesce per alcuni parametri, quindi l'ho reso migliore.

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

Questo non è elegante. ma dopo aver provato isNAN () sono arrivato a questa soluzione che è un'altra alternativa. In questo esempio ho anche permesso '.' perché sto mascherando il galleggiante. È inoltre possibile invertire ciò per assicurarsi che non vengano utilizzati numeri.

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

Questa è una valutazione a carattere singolo, ma puoi anche scorrere una stringa per verificare la presenza di numeri.

Puoi controllare NaN usando la funzione javascript isNaN. Basta passare il numero o il valore alla funzione 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

Converti semplicemente il risultato in String e confrontalo con 'NaN'.

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

È (NaN> = 0) ? ...... " Non lo so ".

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

Le condizioni vengono eseguite solo se VERO .

Non su FALSO .

Non su " Non lo so ".