Controlla se un numero ha una cifra decimale / è un numero intero

Sto cercando un modo semplice in JavaScript per verificare se un numero ha una sua posizione decimale (per determinare se è un numero intero). Per esempio,

23 -> OK 5 -> OK 3.5 -> not OK 34.345 -> not OK 
 if(number is integer) {...} 

L’uso del modulo funzionerà:

 num % 1 != 0 // 23 % 1 = 0 // 23.5 % 1 = 0.5 

Si noti che questo è basato sul valore numerico del numero, indipendentemente dal formato. Tratta le stringhe numeriche contenenti numeri interi con un punto decimale fisso uguale ai numeri interi:

 '10.0' % 1; // returns 0 10 % 1; // returns 0 '10.5' % 1; // returns 0.5 10.5 % 1; // returns 0.5 

O potresti semplicemente usare per scoprire se NON è un decimale:

 string.indexOf(".")==-1; 

La soluzione più comune è quella di rimuovere la parte intera del numero e confrontarla a zero in questo modo:

 function Test() { var startVal = 123.456 alert( (startVal - Math.floor(startVal)) != 0 ) } 
 Number.isInteger(23); // true Number.isInteger(1.5); // false Number.isInteger("x"); // false: 

Number.isInteger () è parte dello standard ES6 e non è supportato in IE11.

Restituisce false per gli argomenti NaN , Infinity e non numerici mentre x % 1 != 0 restituisce true.

// Che ne dici di byte-it?

 Number.prototype.isInt= function(){ return this== this>> 0; } 

Mi sento sempre un po ‘male per gli operatori di bit in javascript-

difficilmente riescono a fare esercizio fisico.

Semplice ma efficace!

 Math.floor(number) == number; 
 var re=/^-?[0-9]+$/; var num=10; re.test(num); 
 function isDecimal(n){ if(n == "") return false; var strCheck = "0123456789"; var i; for(i in n){ if(strCheck.indexOf(n[i]) == -1) return false; } return true; } 
 number = 20.5 if (number == Math.floor(number)) { alert("Integer") } else { alert("Decimal") } 

Abbastanza bello e funziona anche per cose come XX.0! Funziona perché Math.floor () elimina ogni decimale se ne ha uno quindi se il pavimento è diverso dal numero originale sappiamo che è un decimale! E nessuna conversione di stringhe 🙂

 parseInt(num) === num 

quando viene passato un numero, parseInt() restituisce semplicemente il numero come int:

 parseInt(3.3) === 3.3 // false because 3 !== 3.3 parseInt(3) === 3 // true 

Ecco un estratto dalla mia biblioteca di guardie (ispirata all’efficace JavaScript di David Herman):

 var guard = { guard: function(x) { if (!this.test(x)) { throw new TypeError("expected " + this); } } // ... }; // ... var number = Object.create(guard); number.test = function(x) { return typeof x === "number" || x instanceof Number; }; number.toString = function() { return "number"; }; var uint32 = Object.create(guard); uint32.test = function(x) { return typeof x === "number" && x === (x >>> 0); }; uint32.toString = function() { return "uint32"; }; var decimal = Object.create(guard); decimal.test = function(x) { return number.test(x) && !uint32.test(x); }; decimal.toString = function() { return "decimal"; }; uint32.guard(1234); // fine uint32.guard(123.4); // TypeError: expected uint32 decimal.guard(1234); // TypeError: expected decimal decimal.guard(123.4); // fine 

È ansible moltiplicarlo per 10 e quindi eseguire un’operazione ” modulo ” / divison con 10 e verificare se il risultato di queste due operazioni è zero. Il risultato di queste due operazioni ti darà la prima cifra dopo il punto decimale. Se il risultato è uguale a zero, il numero è un numero intero.

 if ( (int)(number * 10.0) % 10 == 0 ){ // your code } 

Number.isInteger() è probabilmente il più conciso. Restituisce vero se è un numero intero e falso se non lo è.

La funzione per il numero di controllo è decimale o numero intero

 function IsDecimalExist(p_decimalNumber) { var l_boolIsExist = true; if (p_decimalNumber % 1 == 0) l_boolIsExist = false; return l_boolIsExist; } 

converti la stringa numerica in matrice, divisa per punto decimale. Quindi, se l’array ha solo un valore, significa nessun decimale nella stringa.

 if(!number.split(".")[1]){ //do stuff } 

In questo modo puoi anche sapere cosa sono effettivamente il numero intero e il decimale. un esempio più avanzato sarebbe.

 number_to_array = string.split("."); inte = number_to_array[0]; dece = number_to_array[1]; if(!dece){ //do stuff } 
 function isDecimal(num) { return (num !== parseInt(num, 10)); } 

È ansible utilizzare le operazioni bit a bit che non modificano il valore ( ^ 0 o ~~ ) per ignorare la parte decimale, che può essere utilizzata per arrotondare. Dopo aver arrotondato il numero, viene confrontato con il valore originale:

 function isDecimal(num) { return (num ^ 0) !== num; } console.log( isDecimal(1) ); // false console.log( isDecimal(1.5) ); // true console.log( isDecimal(-0.5) ); // true 

È ansible utilizzare la seguente funzione per verificare se un numero ha posizioni decimali:

 function hasDecimal(num){ return !!(num % 1); } console.log(hasDecimal(2)); //true console.log(hasDecimal(2.32423)); //false 

Quindi a quanto pare alcuni utenti vogliono delle spiegazioni. Lo romperò a pezzi: (num% 1)

Parentesi significa eseguire prima quelle operazioni. num – una variabile trasmessa dalla funzione. % – un simbolo del modulo che tenta di dividere il numero a sinistra a destra. Se c’è un resto lo restituisce come un decimale. Se divide equamente, restituisce 0.

Quindi riassumiamo ciò che abbiamo finora., (Num% 1) restituirà:

0 se diviso uniformsmente OR #. ##### se non lo è

0 == falso.

[ANY_NUMBER_NOT_ZERO] == true.

Esempi: new Boolean (0) è false new Boolean (12312.1231) è true

Altre alternative: un utente avrebbe potuto provare a restituire il valore di (num% 1)., Che sostanzialmente avrebbe ottenuto la stessa cosa. Poiché return (0) è false e return (1.213113) è true.

Ma volevo restituire un valore booleano. Quindi come scorciatoia per forzare un valore in un booleano ho aggiunto un! simbolo prima di esso.

Tutti quelli che potrebbero sapere.,! significa NOT. Ma costringe anche un valore in un booleano.

Dal momento che! symobol forza il valore in un valore booleano e ne inversa il valore. Io uso !! per forzare il valore in un valore booleano e invertire il valore sul valore booleano originale.

 $('.rsval').bind('keypress', function(e){ var asciiCodeOfNumbers = [48,46, 49, 50, 51, 52, 53, 54, 54, 55, 56, 57]; var keynum = (!window.event) ? e.which : e.keyCode; var val = this.value; var numlenght = val.length; var splitn = val.split("."); var decimal = splitn.length; var precision = splitn[1]; var startPos = this.selectionStart; var decimalIndex = val.indexOf('.'); if(decimal == 2) { if(decimalIndex < startPos){ if(precision.length >= 2){ e.preventDefault(); } } } if( keynum == 46 ){ if(startPos < (numlenght-2)){ e.preventDefault(); } if(decimal >= 2) { e.preventDefault(); } } if ($.inArray(keynum, asciiCodeOfNumbers) == -1) e.preventDefault(); });