Проверьте, имеет ли число десятичное место / является целым числом

Я ищу простой способ в JavaScript, чтобы проверить, если число имеет десятичное место в нем (чтобы определить, является ли оно целым числом). Например,

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

if(number is integer) {...}

Использование модуля будет работать:

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

Обратите внимание, что это основано на числовом значении числа, независимо от формата. Он обрабатывает числовые строки, содержащие целые числа с фиксированной десятичной точкой, так же, как целые числа:

'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 () является частью стандарта ES6 и не поддерживается в IE11.

Она возвращает ложные для NaN, Infinityи не числовых аргументов в то время как x % 1 != 0возвращает истину.

Или вы можете просто использовать это, чтобы узнать, не является ли это десятичным числом:

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

Наиболее распространенным решением является удаление целой части числа и сравнение ее с нулем следующим образом:

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

Простой, но эффективный!

Math.floor(number) === number;

// Как насчет этого?

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

Я всегда чувствую себя плохо для битовых операторов в javascript-

они вряд ли получают какое-либо упражнение.

number = 20.5

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

alert("Integer")

} else {

alert("Decimal")

}

Довольно круто и работает на такие вещи, как XX.0 тоже! Это работает, потому что Math.floor () отбирает любое десятичное число, если оно есть, поэтому, если слово отличается от исходного числа, мы знаем, что это десятичное число! И без преобразования строк :)

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

Number.isInteger()наверное, самый лаконичный. Он возвращает истину, если это целое число, и ложь, если это не так.

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

когда передано число, parseInt()просто возвращает число как int:

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

преобразовать числовую строку в массив, разделить на десятичную точку Затем, если массив имеет только одно значение, это означает отсутствие десятичного числа в строке.

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

Таким образом, вы также можете узнать, что такое целые и десятичные числа. более продвинутый пример будет.

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

if(!dece){
    //do stuff
}

Вот отрывок из моей охранной библиотеки (вдохновлен Effective JavaScript Дэвидом Херманом):

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

Вы можете умножить его на 10, а затем выполнить операцию / деление по модулю на 10 и проверить, равен ли результат этих двух операций нулю. Результат этих двух операций даст вам первую цифру после десятичной точки. Если результат равен нулю, то число является целым числом.

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

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

Вы можете использовать побитовые операции, которые не изменяют значение ( ^ 0или ~~), чтобы отбросить десятичную часть, которая может использоваться для округления. После округления числа оно сравнивается с исходным значением:

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

Вы можете использовать следующую функцию, чтобы проверить, имеет ли число десятичные разряды:

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

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

По-видимому, некоторые пользователи хотят объяснений. Я разобью его на части: (num% 1)

Скобки означают выполнение этих операций в первую очередь. num - переменная, переданная функцией. % - символ модуля, который пытается разделить левое число на правое. Если есть остаток, он возвращает его в виде десятичной дроби. Если он делится равномерно, он возвращает 0.

Итак, подытожим то, что у нас есть. (Num% 1) вернет:

0 при равномерном делении ИЛИ #. ##### если нет

0 == неверно.

[ANY_NUMBER_NOT_ZERO] == верно.

Примеры: new Boolean (0) равен false new Boolean (12312.1231) равен true

Другие альтернативы: пользователь мог попытаться вернуть значение (num% 1)., Что в основном позволило бы достичь того же. Поскольку return (0) является ложным, а return (1.213113) истинным.

Но я хотел вернуть логическое значение. Чтобы добавить значение в логическое значение, я добавил! символ перед ним.

Столько, сколько может знать. значит НЕ. Но это также превращает значение в логическое значение.

С тех пор! symobol переводит значение в логическое значение и инвертирует его значение. Я использую !! заставить значение в логическое значение и инвертировать его значение обратно к исходному логическому значению.

Функция для контрольного номера является десятичным или целым числом

function IsDecimalExist(p_decimalNumber) {
    var l_boolIsExist = true;

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

    return l_boolIsExist;
}

Возможно, это работает для вас?

Он использует регулярные выражения, чтобы проверить, есть ли запятая в числе, и если нет, то он добавит запятую и полосу.

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

Используйте следующее, если значением является строка (например, from <input):

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

Я добавляю .toString()слово floor, чтобы оно работало и в тех случаях, когда value == "1."(заканчивается десятичным разделителем или другой строкой) Также Math.floorвсегда возвращает некоторое значение, поэтому .toString()никогда не завершается ошибкой.