检查一个数字是否有小数点/是否为整数

使用模量可以工作:

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

当传递一个数字时，parseInt()只是将该数字返回为int:

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

简单，但有效!

Math.floor(number) === number;

以下是我的守卫库的摘录(灵感来自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中不支持。

NaN， Infinity和非数字参数返回false，而x % 1 != 0返回true。

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

也许这对你有用?

它使用regex检查数字中是否有逗号，如果没有，则添加逗号和条纹。

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

if value是字符串(例如from <input):

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

我将.toString()添加到floor，使其也适用于value == "1."(以十进制分隔符或其他字符串结束)的情况。此外，Math.floor总是返回一些值，因此.toString()永远不会失败。

当使用带有十进制步骤的计数器时，检查number是否为整数实际上会失败，如下所示。因此，用小数点后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双精度数，而不需要舍入。