Verifique se um número tem uma casa decimal / é um número inteiro

Eu estou procurando uma maneira fácil em JavaScript para verificar se um número tem uma casa decimal (para determinar se é um número inteiro). Por exemplo,

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

if(number is integer) {...}

Usar o módulo funcionará:

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

Observe que isso se baseia no valor numérico do número, independentemente do formato. Ele trata seqüências numéricas contendo números inteiros com um ponto decimal fixo da mesma forma que números inteiros:

'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 () faz parte do padrão ES6 e não é suportado no IE11.

Ele retorna falsos para NaN, Infinitye não numéricos argumentos enquanto x % 1 != 0retorna verdadeiro.

Ou você pode simplesmente usar isso para descobrir se NÃO é um decimal:

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

A solução mais comum é retirar a parte inteira do número e compará-la com zero da seguinte forma:

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

Simples mas efetivo!

Math.floor(number) === number;

// Que tal contorná-lo?

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

Eu sempre me sinto mal por operadores de bit em javascript-

eles quase não fazem exercício.

number = 20.5

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

alert("Integer")

} else {

alert("Decimal")

}

Muito legal e funciona para coisas como XX.0 também! Funciona porque Math.floor () corta qualquer decimal, se tiver um, se o piso for diferente do número original, sabemos que é um decimal! E sem conversões de string :)

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

Number.isInteger()é provavelmente o mais conciso. Retorna true se for um número inteiro e false se não for.

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 passado um número, parseInt()apenas retorna o número como int:

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

converta a sequência numérica em matriz, dividida por ponto decimal. Então, se a matriz tiver apenas um valor, isso significa que não há decimal na sequência.

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

Dessa forma, você também pode saber qual é o número inteiro e o decimal. um exemplo mais avançado seria.

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

if(!dece){
    //do stuff
}

Aqui está um trecho da minha biblioteca de guarda (inspirado no JavaScript eficaz de 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

Você pode multiplicá-lo por 10 e, em seguida, executar uma operação / divisão de " módulo " com 10 e verificar se o resultado dessas duas operações é zero. O resultado dessas duas operações fornecerá o primeiro dígito após o ponto decimal. Se o resultado for igual a zero, o número é um número inteiro.

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

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

Você pode usar as operações bit a bit que não alteram o valor ( ^ 0ou ~~) para descartar a parte decimal, que pode ser usada para arredondar. Depois de arredondar o número, ele é comparado ao 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);
}

Você pode usar a seguinte função para verificar se um número tem casas decimais:

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

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

Aparentemente, alguns usuários querem explicações. Vou dividi-lo em pedaços: (num% 1)

Parêntese significa realizar essas operações primeiro. num - uma variável transmitida pela função. % - um símbolo de módulo que tenta dividir o número esquerdo pelo direito. Se houver um restante, ele retornará como um decimal. Se dividir uniformemente, retornará 0.

Então, resumindo o que temos até agora., (Num% 1) retornará:

0 quando dividido uniformemente OU #. ##### se não

0 == falso.

[ANY_NUMBER_NOT_ZERO] == verdadeiro.

Exemplos: new Boolean (0) é false new Boolean (12312.1231) é true

Outras alternativas: um usuário poderia ter tentado retornar o valor de (num% 1)., Que basicamente alcançaria a mesma coisa. Como o retorno (0) é falso e o retorno (1.213113) é verdadeiro.

Mas eu queria retornar um valor booleano. Então, como um atalho para forçar um valor a um booleano, adicionei a! símbolo antes dele.

Tantos quanto se sabe.! significa NÃO. Mas também força um valor a um valor booleano.

Desde o ! O symobol força o valor a um valor booleano e inverte seu valor. Eu uso !! para forçar o valor para um booleano e inverter seu valor de volta ao seu valor booleano original.

A função do número do cheque é número decimal ou inteiro

function IsDecimalExist(p_decimalNumber) {
    var l_boolIsExist = true;

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

    return l_boolIsExist;
}

Talvez isso funcione para você?

Ele usa regex para verificar se há uma vírgula no número e, se não houver, adicionará a vírgula e a faixa.

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

Use a seguir se value for string (por exemplo, from <input):

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

Eu adiciono .toString()ao chão para fazê-lo funcionar também nos casos em que value == "1."(termina com separador decimal ou outra string). Também Math.floorsempre retorna algum valor para que .toString()nunca falhe.