Verifique si un número tiene un lugar decimal / es un número entero

Estoy buscando una manera fácil en JavaScript para verificar si un número tiene un lugar decimal (para determinar si es un número entero). Por ejemplo,

23 -> OK
5 -> OK
3.5 -> not OK
34.345 -> not OK

if(number is integer) {...}

Usar el módulo funcionará:

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

Tenga en cuenta que esto se basa en el valor numérico del número, independientemente del formato. Trata cadenas numéricas que contienen números enteros con un punto decimal fijo igual que los enteros:

'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 () es parte del estándar ES6 y no es compatible con IE11.

Se devuelve false para NaN, Infinityy no numéricos argumentos mientras x % 1 != 0vuelve verdadera.

O simplemente podría usar esto para averiguar si NO es un decimal:

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

La solución más común es quitar la parte entera del número y compararlo con cero de la siguiente manera:

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

Simple, pero efectivo!

Math.floor(number) === number;

// ¿Qué hay de byte-it?

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

Siempre me siento mal por los operadores de bits en javascript

apenas hacen ejercicio.

number = 20.5

if (number == Math.floor(number)) {

alert("Integer")

} else {

alert("Decimal")

}

¡Bastante genial y funciona para cosas como XX.0 también! Funciona porque Math.floor () corta cualquier decimal si tiene uno, así que si el piso es diferente del número original, ¡sabemos que es un decimal! Y sin conversiones de cadena :)

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

Number.isInteger()Es probablemente el más conciso. Devuelve verdadero si es un número entero y falso si no lo es.

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

cuando se pasa un número, parseInt()solo devuelve el número como int:

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

convertir cadena de número a matriz, dividido por punto decimal. Entonces, si la matriz tiene solo un valor, eso significa que no hay decimal en la cadena.

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

De esta manera, también puede saber cuáles son realmente el número entero y el decimal. Un ejemplo más avanzado sería.

number_to_array = string.split(".");
inte = number_to_array[0];
dece = number_to_array[1]; 

if(!dece){
    //do stuff
}

Aquí hay un extracto de mi biblioteca de guardia (inspirado en JavaScript efectivo por 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

Puede multiplicarlo por 10 y luego hacer una operación / división de " módulo " con 10 , y verificar si el resultado de esas dos operaciones es cero. El resultado de esas dos operaciones le dará el primer dígito después del punto decimal. Si el resultado es igual a cero, entonces el número es un número entero.

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

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

Puede usar las operaciones bit a bit que no cambian el valor ( ^ 0o ~~) para descartar la parte decimal, que puede usarse para redondear. Después de redondear el número, se compara con el valor original:

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

Puede usar la siguiente función para verificar si un número tiene decimales:

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

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

Aparentemente, algunos usuarios quieren explicaciones. Lo partiré en pedazos: (num% 1)

Paréntesis significa realizar esas operaciones primero. num - una variable pasada por la función. %: un símbolo de módulo que intenta dividir el número izquierdo por el derecho. Si hay un resto, lo devuelve como un decimal. Si se divide de manera uniforme, devuelve 0.

Entonces, resume lo que tenemos hasta ahora, (num% 1) devolverá:

0 cuando se divide equitativamente O #. ##### si no

0 == falso.

[ANY_NUMBER_NOT_ZERO] == verdadero.

Ejemplos: nuevo booleano (0) es falso nuevo booleano (12312.1231) es verdadero

Otras alternativas: Un usuario podría haber intentado devolver el valor de (num% 1), que básicamente lograría lo mismo. Dado que return (0) es falso y return (1.213113) es verdadero.

Pero quería devolver un valor booleano. Entonces, como atajo para forzar un valor en un valor booleano, agregué un! símbolo delante de él.

¡Todos los que puedan saber! significa NO. Pero también fuerza un valor a un valor booleano.

Desde el! symobol fuerza el valor en un valor booleano e invierte su valor. Yo suelo !! para forzar el valor a un valor booleano e invertir su valor nuevamente a su valor booleano original.

La función para el número de cheque es decimal o número entero

function IsDecimalExist(p_decimalNumber) {
    var l_boolIsExist = true;

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

    return l_boolIsExist;
}

Tal vez esto funciona para ti?

Utiliza regex para verificar si hay una coma en el número, y si no la hay, agregará la coma y la franja.

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

Use el siguiente si el valor es una cadena (por ejemplo, de <input):

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

Agrego .toString()al piso para que funcione también para casos cuando value == "1."(termina con un separador decimal u otra cadena). También Math.floorsiempre devuelve algún valor, por lo que .toString()nunca falla.