Come si controlla che un numero sia NaN in JavaScript?


415

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

parseFloat('geoff') == NaN;

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

5
vale la pena leggere se il tuo vero obiettivo è controllare i numeri: stackoverflow.com/questions/18082/…
Paul


1
@Goto: certo, ma ho chiesto come verificare che un numero sia NaN, al contrario di qualsiasi valore.
Paul D. Waite,

3
@ PaulD.Waite Sì, ma molte persone vengono qui quando cercano su Google qualcosa come "come verificare se una variabile è nan in javascript".
Michał Perłakowski l'

PaulD.Waite Sono d'accordo con te, ma ho la stessa preoccupazione di @Gothdo. Molte persone affrontano questa domanda con l'intenzione di "Come verificare se un valore in JS è NaN". Puoi controllare il commento di mjohnsonengr sulla stessa risposta . A proposito, anch'io ho segnalato questa domanda per l'attenzione dei moderatori.
dopeddude

Risposte:


582

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?


8
C'è bisogno di paseFloat?
rahul,

23
Se si desidera interpretare una stringa vuota come NaN, quindi sì. (Non sto dicendo che lo faresti sempre.)
Paul D. Waite,

1
Se fossi in te lo assegnerei a una variabile e, utilizzare la variabile condition! == variabile. Come indicato nelle specifiche tc39.github.io/ecma262/#sec-isnan-number
allsyed

3
isNaN(parseFloat("geoff")) // true isNaN(parseFloat("10geo")) // false Come è utile?
Prashanth,

Questo potrebbe anche essere utile per provare w3schools.com/jsref/jsref_isnan.asp
Srijan Chaudhary

146

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


27
Efficace ma controintuitivo. Non vorrei mantenere questo tipo di codice.
osa,

35
Non è il codice che è controintuitivo, è NaN.
Jazzy,

20
@DanM Non è un bug, è il comportamento IEE754 standard di NaN. È il modo in cui è implementato nelle CPU, ed è il comportamento previsto in ogni linguaggio di programmazione nel mondo che utilizza i float.
Tarmil,

4
@Tarmil debitamente notato! Questo è davvero molto interessante; Ho sempre pensato che la stranezza della disuguaglianza di NaN fosse una cosa Javascript.
Dan M,

2
NaN === Nan; // falso. Questo è un bug noto in JavaScript. isNan è un nuovo metodo.
Atilkan,

52

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

1
Forse sono solo io, ma l'idea di NaN diventa confusa quando var value = 0/0;e var value2= String("123 131");creare valori NaN e qualcosa del genere var value3 = "abcd";è anche un valore NaN.
Nick Pineda,

@NickPineda Perché?
Sinjai,

44

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.


6
Grazie per non aver semplicemente usato "isNan ()", ma piuttosto per aver fornito una risposta completamente dettagliata. Questo è ESATTAMENTE quello che stavo cercando quando ho trovato questa domanda su Google.
mjohnsonengr,

1
".... stava dando risultati sbagliati per i casi precedenti" Non direi di sbagliato, solo diverso, perché il globale isNaNconverte prima l'argomento in un valore numerico.
Felix Kling

1
@FelixKling Controlla la risposta aggiornata. Grazie.
dopeddude

1
isNaN ("lorem ipsum"); // vero con ES5 mi stava facendo impazzire
Nick Pineda

2
@NickPineda Il sentimento è così reciproco, ma alla fine MDN potrebbe spiegarlo in questo modo "Quando l'argomento della funzione isNaN non è di tipo Numero, il valore viene prima costretto a un Numero. Il valore risultante viene quindi testato per determinare se è NaN."
dopeddude

16

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.


1
Questo non è un modo perfettamente affidabile. Secondo le specifiche. variabile! == variabile è il modo più affidabile per verificare la presenza di NaN
allsyed

1
Vedi la mia risposta sopra su questo ^
Jazzy,

14

È 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.


1
Sì, isNaN('') //falsema parseInt('') //NaN. Lo stesso si può dire per null.
Silent Penguin

13

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


9

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".


7

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.


1
Interessante. Un modo per contrastare questo e rilevare che "1.2geoff" non è in realtà una stringa numerica valida?
Gabe Halsmer,

2
Si noti che ciò accade solo quando la stringa inizia con un numero. parseFloat('test1.2')tornerà NaN.
Eduard Luca,

6

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:


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.


1
@ PaulD.Waite forse è questa app, ma non vedo una risposta accettata. In realtà, vedo solo circa 5 risposte, ma vedo che ci sono 15
SpYk3HH,

1
Quale app stai usando?
Paul D. Waite,

2
@ PaulD.Waite Quello SE per Android. on galaxy s3
SpYk3HH,

1
Aha. Non ho l'app per guardare me stesso, ma ecco un link alla risposta accettata: stackoverflow.com/a/2652335/20578
Paul D. Waite

@ PaulD.Waite Ah, capisco. Suppongo che, in risposta diretta alla sola domanda in sé e per sé, tale risposta possa essere sufficiente. Ho pubblicato la mia risposta su un'altra domanda in relazione al "modo JS di verificare se è" davvero "NaN", poiché isNaNNON è 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.
SpYk3HH,

5

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.


5

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

7
Il mio ambiente supporta solo ECMAScript XP Home Edition :(
Paul D. Waite,

1
@ PaulD.Waite (spero che intendessi IE 6: D) Nessun problema :-) Ricordati solo che isNaNpotresti metterti nei guai e ricordati di usarlo Number.isNaNnegli ambienti ECMAScript 2015 :-)
thefourtheye

5

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

4

Uso laisNaN funzione di sottolineatura perché in JavaScript:

isNaN(undefined) 
-> true

Almeno, sii consapevole di quel gotcha.


10
Non ho capito bene. Perché NaN potrebbe restituire true quando trasmesso undefinedsarebbe un comportamento errato? È vero che undefinednon è un numero, non è vero?
Xaxis,

3
@Xaxis NaN non deve essere considerato equivalente a indefinito, sono entrambi valori speciali con significati specifici e diversi . Considera questo: ho un valore ma non sto dicendo di cosa si tratta, forse è un numero e forse non lo è, dal tuo punto di vista, non è definito.
Corin,

1
@Corin undefined potrebbe essere qualcosa di diverso rispetto a NaN, tuttavia non è ancora un numero, quindi isNaN(undefined)dovrebbe essere (ed è)true
neuhaus

4

Forse anche questo:

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

3

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

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

Certo, ma non stavo chiedendo di Node.js.
Paul D. Waite,



2

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

1

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.


1

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

1
"L'unico modo semplice per scoprire se la variabile è NaN è una funzione globale isNaN ()" - non vero; c'è un altro modo semplice: var xIsNaN = x !== x;questo diventa vero solo se x lo è NaN.
Raphael Schweikert,

1

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


1

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'

1

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

1

Trovato un altro modo, solo per divertimento.

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

1

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


La tua premessa è che l'infinito non è tecnicamente un numero tecnicamente imperfetto: math.stackexchange.com/questions/36289/is-infinity-a-number . Dalla mia lettura delle risposte è che l'infinito essendo un numero dipende dal contesto.
Jon P


1
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.


1

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

0

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

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

0

È (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 ".


non molto utile se cerchi esplicitamente i valori NaN invece di cercare il contrario
liviu blidar
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.