L'ho provato solo nella console JavaScript di Firefox, ma nessuna delle seguenti affermazioni è vera:
parseFloat('geoff') == NaN;
parseFloat('geoff') == Number.NaN;
L'ho provato solo nella console JavaScript di Firefox, ma nessuna delle seguenti affermazioni è vera:
parseFloat('geoff') == NaN;
parseFloat('geoff') == Number.NaN;
Risposte:
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?
NaN
, quindi sì. (Non sto dicendo che lo faresti sempre.)
isNaN(parseFloat("geoff")) // true
isNaN(parseFloat("10geo")) // false
Come è utile?
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
var value = 0/0;
e var value2= String("123 131");
creare valori NaN e qualcosa del genere var value3 = "abcd";
è anche un valore NaN.
Per quanto riguarda un valore di tipo Numero da testare indipendentemente dal fatto che sia una funzione NaN
o no, la funzione globale isNaN
farà 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.
isNaN
converte prima l'argomento in un valore numerico.
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é:
Esempi:
isNaN('geoff'); // true
isNaN('3'); // false
Spero che questo ti possa aiutare.
isNaN('') //false
ma parseInt('') //NaN
. Lo stesso si può dire per null
.
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.
parseFloat('test1.2')
tornerà NaN
.
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.
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.
isNaN
metodo nativo .// Extremely simple. Just simply write the method.
window.isNaN = function(a) { return a !==a; }
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);
})();
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.
isNaN
NON è affidabile. Sono stato commentato lì e mi è stato detto che questa domanda sarebbe più adatta alla mia risposta, spostandola così qui. Basta solo mettendo qualcosa di utile / utile là fuori in relazione a questo problema che si aprirà su una ricerca di Google del problema a portata di mano, is it NaN?
. Nota a margine, la mia risposta sarebbe più accurata più spesso della risposta selezionata.
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 0
e NaN
sono 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 isNaN
funzione non funzionante.
Se il tuo ambiente supporta ECMAScript 2015 , potresti voler utilizzare Number.isNaN
per 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'))
isNaN
potresti metterti nei guai e ricordati di usarlo Number.isNaN
negli ambienti ECMAScript 2015 :-)
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.
undefined
sarebbe un comportamento errato? È vero che undefined
non è un numero, non è vero?
undefined
potrebbe essere qualcosa di diverso rispetto a NaN
, tuttavia non è ancora un numero, quindi isNaN(undefined)
dovrebbe essere (ed è)true
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);
function isNotANumber(n) {
if (typeof n !== 'number') {
return true;
}
return n !== n;
}
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 == null
ma poi è stato contrassegnato come duplicato, quindi non voglio sprecare il mio lavoro.
Guarda su Mozilla Developer Network su NaN
.
Usa solo distance || 0
quando vuoi essere sicuro che il valore sia un numero corretto o isNaN()
per controllarlo.
Il NaN (Not-a-Number) è uno strano oggetto globale in javascript spesso restituito quando alcune operazioni matematiche falliscono.
Volevi verificare se NaN == null
quali risultati false
. Hovewer NaN == NaN
risulta 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)
Scopriamolo.
Quando chiami NaN == false
il 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 vuotafalse
- un falso booleanonull
- oggetto nullundefined
- variabili non definite0
- 0 numerici, compresi +0 e -0var xIsNaN = x !== x;
questo diventa vero solo se x lo è NaN
.
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 isNaN
per 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 Infinity
poiché Infinity non è tecnicamente un numero.
mi è venuta in mente una isNumber
funzione 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 ".