检查数字是否有小数位/是否为整数

使用模数将起作用：

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

最常见的解决方案是剥离数字的整数部分并将其与零进行比较，如下所示：

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

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

对它进行字节化怎么样？

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

我总是觉得 javascript 中的位运算符有点不好——

他们几乎得不到任何锻炼。

或者你可以用它来找出它是否不是小数：

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

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

当传递一个数字时，只需将数字返回为 int：parseInt()

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

简单，但有效！

Math.floor(number) === number;

以下是我的 guard 库的摘录（灵感来自 David Herman 的 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

校验号码的函数是十进制或整数

function IsDecimalExist(p_decimalNumber) {
    var l_boolIsExist = true;

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

    return l_boolIsExist;
}

将数字字符串转换为数组，按小数点拆分。然后，如果数组只有一个值，则表示字符串中没有小数。

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
}

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

Number.isInteger（） 是 ES6 标准的一部分，在 IE11 中不受支持。

它返回 的 false 和非数字参数，而返回 true。NaNInfinityx % 1 != 0

您可以将其乘以 10，然后用 10 进行“模”运算/除法，并检查这两个运算的结果是否为零。这两个操作的结果将为您提供小数点后的第一个数字。 如果 result 等于零，则该数字为整数。

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

number = 20.5

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

alert("Integer")

} else {

alert("Decimal")

}

很酷，也适用于 XX.0 之类的东西！ 它之所以有效，是因为 Math.floor（） 会砍掉任何小数点（如果它有一个小数点），所以如果下限与原始数字不同，我们知道它是小数点！并且没有字符串转换:)

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

Number.isInteger()可能是最简洁的。如果它是整数，则返回 true，如果不是，则返回 false。

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

也许这对你有用？

它使用正则表达式来检查数字中是否有逗号，如果没有，则将添加逗号和条纹。

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

如果 value 是字符串，请使用以下内容（例如 from）：<input

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

我添加到地板以使其也适用于以下情况（以小数分隔符或其他字符串结尾）。也总是返回一些值，所以永远不会失败。.toString()value == "1."Math.floor.toString()

使用带有小数步长的计数器时，检查数字是否为舍入实际上会失败，如下所示。因此，用 9 位（可能更多）小数位格式化数字可能是最安全的（尽管速度很慢），如果它以 9 个零结尾，那么它就是一个整数。

const isRound = number => number.toFixed(9).endsWith('000000000');

for (let counter = 0; counter < 2; counter += 0.1) {
  console.log({ counter, modulo: counter % 1, formatted: counter.toFixed(9), isRound: isRound(counter) });
}

Number.isSafeInteger(value);

在 JavaScript 中，isSafeInteger（） 是一个 Number 方法，用于返回一个布尔值，指示一个值是否为安全整数。这意味着它是一个整数值，可以精确地表示为 IEEE-754 双精度数字，而无需四舍五入。

您可以使用以下功能：

bool IsInteger() {
    if (num.indexOf(".") != -1) // a decimal
    {
        return Math.ceil(num) == Math.floor(num); // passes for 1.0 as integer if thats the intent.
    }
    return Number.isSafeInteger(num);
}

以检查数字是整数还是小数。

使用可以帮助检查哪些算作整数，哪些不算作整数。Number.isInteger(num)

例如：

let num1 = 6.0000000000000001; // 16 decimal places
let num2 = 6.000000000000001; // 15 decimal places

Number.isInteger(num1); // true, because of loss of precision

// while:
Number.isInteger(num2); // false

因此，在我看来，如果您需要的是知道数学上什么是整数，那么使用其他建议的方式是安全的。Number.isInteger()