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

Sto cercando un modo semplice in JavaScript per verificare se un numero ha una posizione decimale (al fine di 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 si basa sul valore numerico del numero, indipendentemente dal formato. Tratta le stringhe numeriche contenenti numeri interi con un punto decimale fisso uguale agli interi:

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

Number.isInteger(23);  // true
Number.isInteger(1.5); // false
Number.isInteger("x"); // false: 

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

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

Oppure potresti semplicemente usarlo per scoprire se NON è un decimale:

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

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

function Test()
{
     var startVal = 123.456
     alert( (startVal - Math.floor(startVal)) != 0 )
}

Semplice ma efficace!

Math.floor(number) === number;

// Che ne dici di byte-ing?

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

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

difficilmente si esercitano.

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 () taglia qualsiasi decimale se ne ha uno, quindi se il piano è diverso dal numero originale sappiamo che è un decimale! E nessuna conversione di stringhe :)

var re=/^-?[0-9]+$/;
var num=10;
re.test(num);

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

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

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

converte la stringa numerica in array, divisa per punto decimale. Quindi, se l'array ha un solo valore, ciò significa che nessun decimale nella stringa.

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

In questo modo puoi anche sapere quali 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
}

Ecco un estratto dalla mia biblioteca di guardie (ispirato a Effective 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

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

function isDecimal(num) {
  return (num !== parseInt(num, 10));
}

È possibile utilizzare le operazioni bit a bit che non modificano il valore ( ^ 0o ~~) per scartare la parte decimale, che può essere utilizzata per l'arrotondamento. 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

function isWholeNumber(num) {
  return num === Math.round(num);
}

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

function hasDecimal(num){
    return !!(num % 1);
}

console.log(hasDecimal(2)); //false
console.log(hasDecimal(2.32423)); //true

Quindi apparentemente alcuni utenti vogliono spiegazioni. Lo spezzerò in pezzi: (num% 1)

Le parentesi significano eseguire prima quelle operazioni. num: una variabile passata dalla funzione. %: un simbolo del modulo che tenta di dividere il numero sinistro per il diritto. Se c'è un resto, lo restituisce come un decimale. Se si divide uniformemente, restituisce 0.

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

0 se diviso equamente O #. ##### in caso contrario

0 == falso.

[ANY_NUMBER_NOT_ZERO] == vero.

Esempi: il nuovo booleano (0) è falso il nuovo booleano (12312.1231) è vero

Altre alternative: un utente avrebbe potuto tentare di restituire il valore di (num% 1), che avrebbe sostanzialmente ottenuto la stessa cosa. Poiché return (0) è falso e return (1.213113) è vero.

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

Quanti ne potrebbero sapere.,! significa NO. Ma forza anche un valore in un valore booleano.

Dal momento che! Symobol forza il valore in un valore booleano e ne inverte il valore. Io uso !! per forzare il valore in un valore booleano e invertire il suo valore al valore booleano originale.

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

function IsDecimalExist(p_decimalNumber) {
    var l_boolIsExist = true;

    if (p_decimalNumber % 1 == 0)
        l_boolIsExist = false;

    return l_boolIsExist;
}

Forse questo funziona per te?

Usa regex per verificare se c'è una virgola nel numero e, in caso contrario, aggiungerà la virgola e la striscia.

var myNumber = '50';
function addCommaStripe(text){
    if(/,/.test(text) == false){
        return text += ',-';
    } else {
        return text;
    }
}
myNumber = addCommaStripe(myNumber);

Utilizzare quanto segue se il valore è stringa (ad es. Da <input):

Math.floor(value).toString() !== value

Aggiungo .toString()al piano per farlo funzionare anche nei casi in cui value == "1."(termina con un separatore decimale o un'altra stringa). Inoltre Math.floorrestituisce sempre un valore quindi .toString()non fallisce mai.