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

284

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) {...}
Hans
fonte

Respostas:

819

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
Andy E
fonte
10
Não votei para baixo, mas eu diria que é algo a ver com 20.0, ainda tem um ponto decimal e satisfaz o acima. +1 de mim de qualquer maneira para me ensinar algo novo :)
Abe Petrillo
7
@ Abe: verdadeiro o suficiente, embora eu ache improvável. É impossível dizer se 20.0tem um ponto decimal programaticamente, a menos que seja expresso como uma sequência. Além disso, nenhuma das outras soluções tem um voto para baixo por não abordar que ;-)
Andy E
1
@ SREEP: veja os comentários acima. 0.00 não é 0.00 em JavaScript quando representado como um valor numérico. Pode ser representada como uma sequência ("0,00"). Nesse caso, a questão é "verificar se uma sequência é um número inteiro" em vez de "verificar se um número é um número inteiro" .
Andy E
3
@Swanidhi: o que você quer dizer? O que não será válido? "10."é um número inteiro e o resultado será exatamente o mesmo que "10"ou 10.
Andy E
3
O OP pergunta sobre como verificar se um NUMBER é um número inteiro. Em nenhum lugar ele menciona seqüências de caracteres - nesse aspecto, a resposta de Andy está certa.
Om Shankar
58
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.

le_m
fonte
2
solução falhar por 12,0
Vikas Arora
@VikasArora Não, funciona como pretendido. Number.isInteger(12.0)retorna true.
Le_m
Parece que deve ser a resposta certa, mas infelizmente não funciona para notação científica, por exemplo , Number.isInteger('1e3')é falsemesmo que Number.isInteger(1e3)seja verdade. Supondo que a intenção da pergunta é encontrar valores não inteiros (em vez da presença real de um ponto decimal na representação), o valor da string '12 .0 ' deve passar, pois representa um número inteiro, mas novamente Number.isInteger('12.0')é false.
Brianmearns
A pergunta do @brianmearns OP é se um numberé inteiro ou não. Se sua entrada é uma string, você precisa convertê-la em uma numberprimeira, por exemplo parseFloat(), via , é claro.
le_m
47

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

string.indexOf(".") == -1;
Ike
fonte
2
Eu acho que esta é a solução real, pois isso esta trabalhando mesmo para XX.0
Deepankar Sarkar
5
converter em string antes de prosseguir .. ie: yournumber.toString.indexOf(".")
Daniel Omine 21/09
1
francisco_ssb .. o símbolo do ponto é universal ... representa a casa decimal na linguagem matemática .. é universal e deve funcionar em qualquer país. Se você está falando vírgulas ( " "), você deve converter a ponto (". ") Antes do indexOf ("."), Obviamente ..
Daniel Omine
1
Acho que quando ele quis dizer que não funciona em alguns países, ele está se referindo à moeda, pois o euro usa vírgula em vez de ponto decimal. No entanto, a pergunta não é específica da moeda, apenas decimais ... como em uma fração de um número.
Tessa
1
Isso não funciona se decimal é 1,00 e você quer que ele seja um int a menos que você coagir valor
simon-pr
21

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 )
}
Thomas
fonte
31
Por que não apenas startVal != Math.floor(startVal)?
Andy E
2
Agradável. Mesmo conceito, mas sua versão é ainda mais limpa.
Thomas
1
@ Andy E: Isso é possível apenas para números positivos. Não vai funcionar para números negativos ..
Seeya K
3
@ SeeyaK: é claro que funcionará para números negativos. Por favor, sinta-se livre para experimentá-lo.
Andy E
1
@DeepakGoyal - Isso é por design. A Math.Floorfunção assume um valor decimal e o maior valor decimal permitido no JavaScript é 2^53 - 1ou 9007199254740991. Como 893144042145698745.3é maior que esse máximo, a função falhará.
Thomas
20

Simples mas efetivo!

Math.floor(number) === number;
dYale
fonte
4
@OmShankar eficiente! = Eficaz #
Fiddles
Math.floor(3.0) == 3.0é verdadeiro, Math.floor(3.3) == 3.3é falso
Rohmer
@ Fiddles, oh certo, é o que eu queria dizer: Não é eficiente, pois isso é muito mais lento no desempenho em comparação com o método% mod. Obrigado por corrigir
Om Shankar
19

// 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.

Kennebec
fonte
14
Isso falha para números inteiros maiores que 2 ^ 31 - 1, porque >>converte o valor em um número inteiro de 32 bits assinado .
Matthew Crumley
1
@kennebec awesome - essa é de longe a solução mais divertida. E é muito melhor do que um RegEx.
Daniel B. Chapman
5
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 :)


fonte
4
var re=/^-?[0-9]+$/;
var num=10;
re.test(num);
ghostdog74
fonte
4
Falha no num= 999999999999999999999.
21910
1
converta primeiro em string e depois faça o re.
ghostdog74
Trabalhou para mim sem converter em string.
Abe Petrillo
4

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

Christopher Connery
fonte
1
Essa deve ser a resposta aceita, porque é melhor usar o módulo devido aos problemas de string.
Ini
3
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;
}
Vitor Lins
fonte
Não precisa de explicação. É bem simples.
Grant Birchmeier
1
Se a string contém qualquer um dos valores em strCheck, é um decimal ... (ele está perdendo e, embora ....
NicoJuicy
2
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
Michael
fonte
4
Gosto muito deste, mas depende das necessidades específicas. Infelizmente, eu preciso de uma função para falhar no testeparseInt(3.0) === 3.0 // true
zipzit
2

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
}
Kareem
fonte
1

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
schirrmacher
fonte
1

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
}
BSevo
fonte
1
function isDecimal(num) {
  return (num !== parseInt(num, 10));
}
Steve Brush
fonte
1

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
makovkastar
fonte
1
function isWholeNumber(num) {
  return num === Math.round(num);
}
Dmitry Shashurov
fonte
1

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.

insira a descrição da imagem aqui

twalow
fonte
Embora esse código possa responder à pergunta, fornecer um contexto adicional sobre como e / ou por que resolve o problema melhoraria o valor a longo prazo da resposta.
precisa saber é o seguinte
0

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;
}
user3897934
fonte
0

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);
user11608734
fonte
Bem-vindo ao StackOverflow. Você poderia elaborar o que esse código faz e por que você acha que ele resolverá o problema.
quinz 6/06/19
@quinz Ele usa regex para verificar se existe uma vírgula no número e, se não houver, adicionará a vírgula e a faixa. Portanto, ele faz o que a pergunta está solicitando com a funcionalidade adicional de adicionar a formatação para etiquetas de preço arredondadas.
user11608734
0

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.

michal.jakubeczy
fonte