Come posso verificare che un numero sia float o intero?

Come scoprire che un numero è float o integer ?

 1.25 --> float 1 --> integer 0 --> integer 0.25 --> float 

controlla il resto quando dividi per 1:

 function isInt(n) { return n % 1 === 0; } 

Se non sai che l’argomento è un numero hai bisogno di due test:

 function isInt(n){ return Number(n) === n && n % 1 === 0; } function isFloat(n){ return Number(n) === n && n % 1 !== 0; } 

Prova queste funzioni per verificare se un valore è un valore primitivo numerico che non ha una parte frazionaria e si trova entro i limiti di dimensione di ciò che può essere rappresentato come un numero intero esatto.

 function isFloat(n) { return n === +n && n !== (n|0); } function isInteger(n) { return n === +n && n === (n|0); } 

Perché non qualcosa del genere:

 var isInt = function(n) { return parseInt(n) === n }; 

Esiste un metodo chiamato Number.isInteger() che è attualmente implementato solo nell’ultimo Firefox e fa ancora parte della proposta di EcmaScript 6. Tuttavia MDN fornisce un polyfill per gli altri browser, che corrisponde a quello specificato nell’armonia ECMA:

 if (!Number.isInteger) { Number.isInteger = function isInteger (nVal) { return typeof nVal === "number" && isFinite(nVal) && nVal > -9007199254740992 && nVal < 9007199254740992 && Math.floor(nVal) === nVal; }; } 

Puoi usare un’espressione regolare semplice:

 function isInt(value) { var er = /^-?[0-9]+$/; return er.test(value); } 

Oppure puoi utilizzare anche le funzioni seguenti, in base alle tue esigenze. Sono sviluppati dal progetto PHPJS .

is_int() => Controlla se il tipo di variabile è intero e se il suo contenuto è intero

is_float() => Controlla se il tipo di variabile è float e se il suo contenuto è float

ctype_digit() => Controlla se il tipo di variabile è una stringa e se il suo contenuto ha solo cifre decimali

Aggiornamento 1

Ora controlla anche i numeri negativi, grazie per il commento di @ChrisBartley !

Qui ci sono funzioni efficienti che controllano se il valore è un numero o possono essere convertiti in sicurezza in un numero:

 function isNumber(value) { if ((undefined === value) || (null === value)) { return false; } if (typeof value == 'number') { return true; } return !isNaN(value - 0); } 

E per i numeri interi (restituirebbe false se il valore è un float):

 function isInteger(value) { if ((undefined === value) || (null === value)) { return false; } return value % 1 == 0; } 

L’efficienza qui è che parseInt (o parseNumber) vengono evitati quando il valore è già un numero. Entrambe le funzioni di analisi si convertono sempre in string, quindi tentano di analizzare quella stringa, che sarebbe uno spreco se il valore è già un numero.

Grazie agli altri post qui per fornire ulteriori idee per l’ottimizzazione!

 function isInteger(x) { return typeof x === "number" && isFinite(x) && Math.floor(x) === x; } function isFloat(x) { return !!(x % 1); } // give it a spin isInteger(1.0); // true isFloat(1.0); // false isFloat(1.2); // true isInteger(1.2); // false isFloat(1); // false isInteger(1); // true isFloat(2e+2); // false isInteger(2e+2); // true isFloat('1'); // false isInteger('1'); // false isFloat(NaN); // false isInteger(NaN); // false isFloat(null); // false isInteger(null); // false isFloat(undefined); // false isInteger(undefined); // false 
 function isInt(n) { return n != "" && !isNaN(n) && Math.round(n) == n; } function isFloat(n){ return n != "" && !isNaN(n) && Math.round(n) != n; } 

funziona per tutti i casi.

Come altri hanno menzionato, hai solo il doppio in JS. Quindi come definisci un numero come un intero? Basta controllare se il numero arrotondato è uguale a se stesso:

 function isInteger(f) { return typeof(f)==="number" && Math.round(f) == f; } function isFloat(f) { return typeof(f)==="number" && !isInteger(f); } 

Ecco cosa uso per i numeri interi:

 Math.ceil(parseFloat(val)) === val 

Breve, carino 🙂 Funziona sempre. Questo è ciò che David Flanagan suggerisce se non mi sbaglio.

Qualsiasi numero Float con una parte decimale pari a zero (ad es. 1.0, 12.00, 0.0) viene convertito implicitamente in numero intero, pertanto non è ansible controllare se sono in virgola mobile o meno.

 !!(24%1) // false !!(24.2%1) // true 
 var isInt = function (n) { return n === (n | 0); }; 

Non ho avuto un caso in cui questo non ha fatto il lavoro.

Dipende davvero da cosa vuoi ottenere. Se vuoi “emulare” lingue fortemente tipizzate, ti suggerisco di non provare. Come altri hanno menzionato tutti i numeri hanno la stessa rappresentazione (lo stesso tipo).

Usando qualcosa come Claudiu ha fornito:

isInteger( 1.0 ) -> true

che sembra buono per il buon senso, ma in qualcosa come C si otterrebbe false

È semplice come:

 if( n === parseInt(n) ) ... 

Prova questo in console:

 x=1; x===parseInt(x); // true x="1"; x===parseInt(x); // false x=1.1; x===parseInt(x); // false, obviously // BUT! x=1.0; x===parseInt(x); // true, because 1.0 is NOT a float! 

Questo confonde molte persone. Ogni volta che qualcosa è .0, non è più un galleggiante. È un numero intero Oppure puoi chiamarlo semplicemente “una cosa numerica” ​​perché non esiste una distinzione rigorosa come quella di C. Bei vecchi tempi.

Quindi, in pratica, tutto quello che puoi fare è verificare che il numero intero accetta il fatto che 1.000 è un numero intero.

Interessante nota a margine

C’è stato un commento su numeri enormi. Numeri enormi significano NESSUN problema per questo approccio; ogni volta che parseInt non è in grado di gestire il numero (perché è troppo grande) restituirà qualcosa di diverso dal valore effettivo, in modo che il test restituisca FALSE. Questa è una buona cosa perché se consideri qualcosa un “numero” normalmente ti aspetti che JS sia in grado di calcolare con esso – quindi sì, i numeri sono limitati e PARSEInt prenderà in considerazione questo , per dirla in questo modo.

Prova questo:

  

Nel mio browser (IE8) ciò restituisce “a is ok; b fail” che è esattamente a causa dell’enorme numero in b. Il limite può variare ma immagino che 20 cifre “dovrebbero essere sufficienti per chiunque”, per citare un classico 🙂

QUESTO È IL CODICE FINALE PER CONTROLLARE SIA INT E GALLEGGIANTE

 function isInt(n) { if(typeof n == 'number' && Math.Round(n) % 1 == 0) { return true; } else { return false; } } 

O

 function isInt(n) { return typeof n == 'number' && Math.Round(n) % 1 == 0; } 
 function isInteger(n) { return ((typeof n==='number')&&(n%1===0)); } function isFloat(n) { return ((typeof n==='number')&&(n%1!==0)); } function isNumber(n) { return (typeof n==='number'); } 

Ho scritto una funzione che accetta stringhe (se qualcuno avrà bisogno)

 function isInt(x) { return !isNaN(x) && eval(x).toString().length == parseInt(eval(x)).toString().length } function isFloat(x) { return !isNaN(x) && !isInt(eval(x)) && x.toString().length > 0 } 

esempio ouptuts:

 console.log(isFloat('0.2')) // true console.log(isFloat(0.2)) // true console.log(isFloat('.2')) // true console.log(isFloat('-.2')) // true console.log(isFloat(-'.2')) // true console.log(isFloat(-.2)) // true console.log(isFloat('u.2')) // false console.log(isFloat('2')) // false console.log(isFloat('0.2u')) // false console.log(isInt('187')) // true console.log(isInt(187)) // true console.log(isInt('1.2')) // false console.log(isInt('-2')) // true console.log(isInt(-'1')) // true console.log(isInt('10e1')) // true console.log(isInt(10e1)) // true 

Per i numeri interi lo uso

 function integer_or_null(value) { if ((undefined === value) || (null === value)) { return null; } if(value % 1 != 0) { return null; } return value; } 

In realtà non deve essere così complicato. Il valore numerico degli equivalenti parseFloat () e parseInt () di un intero sarà lo stesso. Quindi puoi fare così:

 function isInt(value){ return (parseFloat(value) == parseInt(value)) && !isNaN(value); } 

Poi

 if (isInt(x)) // do work 

Ciò consentirà anche il controllo delle stringhe e quindi non è rigoroso. Se vuoi una soluzione di tipo forte (aka, non lavorerai con le stringhe):

 function is_int(value){ return !isNaN(parseInt(value * 1) } 

Nello script java tutti i numeri sono internally 64 bit floating point , come il doppio in java. Non ci sono tipi diversi in javascript, tutti sono rappresentati dal number tipo. Quindi non sarai in grado di fare instanceof controllo. Comunque puoi usare le soluzioni sopra indicate per scoprire se si tratta di un numero frazionario. i progettisti di script java sentiti con un singolo tipo possono evitare numerosi errori di cast di tipo.

Questo forse non è performante come la risposta%, che ti impedisce di dover prima convertire in una stringa, ma non ho ancora visto nessuno postarlo, quindi ecco un’altra opzione che dovrebbe funzionare bene:

 function isInteger(num) { return num.toString().indexOf('.') === -1; } 

Ecco il mio codice. Controlla che non sia una stringa vuota (che altrimenti passerà) e quindi la converte in formato numerico. Ora, a seconda che tu voglia ‘1.1’ essere uguale a 1.1, questo potrebbe o non potrebbe essere quello che stai cercando.

 var isFloat = function(n) { n = n.length > 0 ? Number(n) : false; return (n === parseFloat(n)); }; var isInteger = function(n) { n = n.length > 0 ? Number(n) : false; return (n === parseInt(n)); }; var isNumeric = function(n){ if(isInteger(n) || isFloat(n)){ return true; } return false; }; 

Mi piace questa piccola funzione, che restituirà true per i numeri interi sia positivi che negativi:

 function isInt(val) { return ["string","number"].indexOf(typeof(val)) > -1 && val !== '' && !isNaN(val+".0"); } 

Questo funziona perché 1 o “1” diventa “1.0”, che isNaN () restituisce false on (che poi annulliamo e restituisce), ma 1.0 o “1.0” diventa “1.0.0”, mentre “string” diventa “string”. 0 “, nessuno dei quali è un numero, quindi isNaN () restituisce false (e, di nuovo, viene annullato).

Se vuoi solo interi positivi, c’è questa variante:

 function isPositiveInt(val) { return ["string","number"].indexOf(typeof(val)) > -1 && val !== '' && !isNaN("0"+val); } 

o, per numeri interi negativi:

 function isNegativeInt(val) { return `["string","number"].indexOf(typeof(val)) > -1` && val !== '' && isNaN("0"+val); } 

isPositiveInt () funziona spostando la stringa numerica concatenata prima del valore da testare. Ad esempio, isPositiveInt (1) genera isNaN () che valuta “01”, che valuta false. Nel frattempo, isPositiveInt (-1) genera isNaN () che valuta “0-1”, che valuta true. Neghiamo il valore di ritorno e questo ci dà quello che vogliamo. isNegativeInt () funziona in modo simile, ma senza annullare il valore restituito da isNaN ().

Modificare:

La mia implementazione originale restituirebbe anche true su array e stringhe vuote. Questa implementazione non ha questo difetto. Ha anche il vantaggio di tornare presto se val non è una stringa o un numero, o se è una stringa vuota, rendendola più veloce in questi casi. È ansible modificarlo ulteriormente sostituendo le prime due clausole con

 typeof(val) != "number" 

se vuoi solo abbinare numeri letterali (e non stringhe)

Modificare:

Non posso ancora postare commenti, quindi aggiungo questo alla mia risposta. Il benchmark pubblicato da @Asok è molto informativo; tuttavia, la funzione più veloce non soddisfa i requisiti, poiché restituisce anche TRUE per float, array, booleani e stringhe vuote.

Ho creato la seguente suite di test per testare ognuna delle funzioni, aggiungendo anche la mia risposta alla lista (funzione 8, che analizza le stringhe e la funzione 9, che non funziona):

 funcs = [ function(n) { return n % 1 == 0; }, function(n) { return typeof n === 'number' && n % 1 == 0; }, function(n) { return typeof n === 'number' && parseFloat(n) == parseInt(n, 10) && !isNaN(n); }, function(n) { return n.toString().indexOf('.') === -1; }, function(n) { return n === +n && n === (n|0); }, function(n) { return parseInt(n) === n; }, function(n) { return /^-?[0-9]+$/.test(n.toString()); }, function(n) { if ((undefined === n) || (null === n)) { return false; } if (typeof n == 'number') { return true; } return !isNaN(n - 0); }, function(n) { return ["string","number"].indexOf(typeof(n)) > -1 && n !== '' && !isNaN(n+".0"); } ]; vals = [ [1,true], [-1,true], [1.1,false], [-1.1,false], [[],false], [{},false], [true,false], [false,false], [null,false], ["",false], ["a",false], ["1",null], ["-1",null], ["1.1",null], ["-1.1",null] ]; for (var i in funcs) { var pass = true; console.log("Testing function "+i); for (var ii in vals) { var n = vals[ii][0]; var ns; if (n === null) { ns = n+""; } else { switch (typeof(n)) { case "string": ns = "'" + n + "'"; break; case "object": ns = Object.prototype.toString.call(n); break; default: ns = n; } ns = "("+typeof(n)+") "+ns; } var x = vals[ii][1]; var xs; if (x === null) { xs = "(ANY)"; } else { switch (typeof(x)) { case "string": xs = "'" + n + "'"; break; case "object": xs = Object.prototype.toString.call(x); break; default: xs = x; } xs = "("+typeof(x)+") "+xs; } var rms; try { var r = funcs[i](n); var rs; if (r === null) { rs = r+""; } else { switch (typeof(r)) { case "string": rs = "'" + r + "'"; break; case "object": rs = Object.prototype.toString.call(r); break; default: rs = r; } rs = "("+typeof(r)+") "+rs; } var m; var ms; if (x === null) { m = true; ms = "N/A"; } else if (typeof(x) == 'object') { m = (xs === rs); ms = m; } else { m = (x === r); ms = m; } if (!m) { pass = false; } rms = "Result: "+rs+", Match: "+ms; } catch (e) { rms = "Test skipped; function threw exception!" } console.log(" Value: "+ns+", Expect: "+xs+", "+rms); } console.log(pass ? "PASS!" : "FAIL!"); } 

Riesco anche a ripetere il benchmark con la funzione n. 8 aggiunta all’elenco. Non posterò il risultato, dato che sono un po ‘imbarazzanti (ad esempio, la funzione NON è veloce) …

Il (abbreviato – ho rimosso i test di successo, dal momento che l’output è piuttosto lungo) i risultati sono i seguenti:

 Testing function 0 Value: (object) [object Array], Expect: (boolean) false, Result: (boolean) true, Match: false Value: (boolean) true, Expect: (boolean) false, Result: (boolean) true, Match: false Value: (boolean) false, Expect: (boolean) false, Result: (boolean) true, Match: false Value: null, Expect: (boolean) false, Result: (boolean) true, Match: false Value: (string) '', Expect: (boolean) false, Result: (boolean) true, Match: false Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A FAIL! Testing function 1 Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A PASS! Testing function 2 Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A PASS! Testing function 3 Value: (object) true, Expect: (boolean) false, Result: (boolean) true, Match: false Value: (object) false, Expect: (boolean) false, Result: (boolean) true, Match: false Value: (boolean) [object Array], Expect: (boolean) false, Result: (boolean) true, Match: false Value: (boolean) [object Object], Expect: (boolean) false, Result: (boolean) true, Match: false Value: null, Expect: (boolean) false, Test skipped; function threw exception! Value: (string) '', Expect: (boolean) false, Result: (boolean) true, Match: false Value: (string) 'a', Expect: (boolean) false, Result: (boolean) true, Match: false Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A FAIL! Testing function 4 Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A PASS! Testing function 5 Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A PASS! Testing function 6 Value: null, Expect: (boolean) false, Test skipped; function threw exception! Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A PASS! Testing function 7 Value: (number) 1.1, Expect: (boolean) false, Result: (boolean) true, Match: false Value: (number) -1.1, Expect: (boolean) false, Result: (boolean) true, Match: false Value: (object) true, Expect: (boolean) false, Result: (boolean) true, Match: false Value: (boolean) [object Array], Expect: (boolean) false, Result: (boolean) true, Match: false Value: (boolean) [object Object], Expect: (boolean) false, Result: (boolean) true, Match: false Value: (string) '', Expect: (boolean) false, Result: (boolean) true, Match: false Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A Value: (string) '1.1', Expect: (ANY), Result: (boolean) true, Match: N/A Value: (string) '-1.1', Expect: (ANY), Result: (boolean) true, Match: N/A FAIL! Testing function 8 Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A PASS! Testing function 9 Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A PASS! 

Ho lasciato in errore in modo da poter vedere dove ogni funzione ha esito negativo, e la (stringa) ‘#’ verifica in modo da poter vedere come ogni funzione gestisce valori interi e float nelle stringhe, poiché alcuni potrebbero volere che siano analizzati come numeri e alcuni non può

Tra le 10 funzioni testate, quelle che corrispondono ai requisiti dell’OP sono [1,3,5,6,8,9]

Condtion per la convalida mobile:

 if (lnk.value == +lnk.value && lnk.value != (lnk.value | 0)) 

Condtion per la convalida di interi:

 if (lnk.value == +lnk.value && lnk.value == (lnk.value | 0)) 

Spero che questo possa essere utile.

 function int(a) { return a - a === 0 && a.toString(32).indexOf('.') === -1 } function float(a) { return a - a === 0 && a.toString(32).indexOf('.') !== -1 } 

You can add typeof a === 'number' if you want to exclude strings.

YourJS provides the following two functions which work for all numbers including returning false for -Infinity and Infinity :

 function isFloat(x) { return typeOf(x, 'Number') && !!(x % 1); } function isInt(x) { return typeOf(x, 'Number') && x % 1 == 0; } 

Due to the fact that typeOf() is a YourJS internal function, if you wanted to use these definitions you can download the version for just these functions here: http://yourjs.com/snippets/build/34

Some times Number objects don’t allow you to use direct the mod operator (%), if you are facing that case you can use this solution.

 if(object instanceof Number ){ if( ((Number) object).doubleValue() % 1 == 0 ){ //your object is an integer } else{ //your object is a double } } 

Questa soluzione ha funzionato per me.

   

Based on all that I have seen here, I’ve created my own set of functions to test for what I need:

 function NumberValidator() { this.isFloat = function (n) { return typeof(n)==="number" && n === +n && Math.round(n) !== n; }; this.isInteger = function (n) { return typeof(n)==="number" && n === +n && Math.round(n) === n; }; this.isFloatOrInteger = function (n) { return this.isFloat(n) || this.isInteger(n); }; this.isNonZeroFloatOrInteger = function (n) { return this.isFloatOrInteger(n) && n > 0; }; this.isNonZeroInteger = function (n) { return this.isInteger(n) && n > 0; }; } 

However, shime ‘s solution is shorter and with less checks, so it might be a better one.