如何检查数字是浮点数还是整数？

Question

如何找到一个数字是float或integer？

1.25 --> float  
1 --> integer  
0 --> integer  
0.25 --> float

Answer 1

除以1时检查余数:

function isInt(n) {
   return n % 1 === 0;
}

如果您不知道参数是数字,则需要进行两次测试:

function isInt(n){
    return Number(n) === n && n % 1 === 0;
}

function isFloat(n){
    return Number(n) === n && n % 1 !== 0;
}

Answer 2

尝试使用这些函数来测试值是否是一个数字原始值,它没有小数部分,并且在可以表示为精确整数的大小限制范围内.

function isFloat(n) {
    return n === +n && n !== (n|0);
}

function isInteger(n) {
    return n === +n && n === (n|0);
}

Answer 3

为什么不是这样的:

var isInt = function(n) { return parseInt(n) === n };

Answer 4

有一种方法Number.isInteger(),目前只在最新的Firefox中实现,仍然是EcmaScript 6提案的一部分.但是,MDN为其他浏览器提供了一个polyfill,它匹配ECMA和声中指定的那个:

Number.isInteger = Number.isInteger || function(value) {
  return typeof value === 'number' && 
    isFinite(value) && 
    Math.floor(value) === value;
};

Answer 5

您可以使用简单的正则表达式:

function isInt(value) {

    var er = /^-?[0-9]+$/;

    return er.test(value);
}

或者您也可以根据需要使用以下功能.它们由PHPJS项目开发.

is_int() =>检查变量类型是否为整数,以及其内容是否为整数

is_float() =>检查变量类型是否为float,以及其内容是否为float

ctype_digit() =>检查变量类型是否为字符串,以及其内容是否只有十进制数字

更新1

现在它也检查负数,感谢@ChrisBartley评论!

Answer 6

以下是检查值是数字还是可以安全地转换为数字的高效函数:

function isNumber(value) {
    if ((undefined === value) || (null === value)) {
        return false;
    }
    if (typeof value == 'number') {
        return true;
    }
    return !isNaN(value - 0);
}

对于整数(如果值为float,则返回false):

function isInteger(value) {
    if ((undefined === value) || (null === value)) {
        return false;
    }
    return value % 1 == 0;
}

这里的效率是当值已经是数字时避免使用parseInt(或parseNumber).两个解析函数总是首先转换为字符串,然后尝试解析该字符串,如果值已经是数字,这将是一种浪费.

感谢此处的其他帖子提供进一步的优化建议!

Answer 7

2022 更新 - 我们可以简单地使用 Number 的方法。

检查是整数还是浮点： Number.isFinite(val)

检查是否为整数： Number.isInteger(val)

检查是否为浮点数（非整数）：!Number.isInteger(val) && Number.isFinite(val)

Answer 8

function isInteger(x) { return typeof x === "number" && isFinite(x) && Math.floor(x) === x; }
function isFloat(x) { return !!(x % 1); }

// give it a spin

isInteger(1.0);        // true
isFloat(1.0);          // false
isFloat(1.2);          // true
isInteger(1.2);        // false
isFloat(1);            // false
isInteger(1);          // true    
isFloat(2e+2);         // false
isInteger(2e+2);       // true
isFloat('1');          // false
isInteger('1');        // false
isFloat(NaN);          // false
isInteger(NaN);        // false
isFloat(null);         // false
isInteger(null);       // false
isFloat(undefined);    // false
isInteger(undefined);  // false

Answer 9

function isInt(n) 
{
    return n != "" && !isNaN(n) && Math.round(n) == n;
}
function isFloat(n){
    return n != "" && !isNaN(n) && Math.round(n) != n;
}

适用于所有情况.

Answer 10

我们可以通过isInteger功能来检查。即 number 将返回 true，float 返回 false

console.log(Number.isInteger(2)),<BR>

将返回true

console.log(Number.isInteger(2.5))

会返回 false

Answer 11

这个怎么样？

isFloat(num) {
    return typeof num === "number" && !Number.isInteger(num);
}

Answer 12

正如其他人提到的,你只有JS中的双打.那么如何定义一个整数？只需检查舍入数字是否等于它自己:

function isInteger(f) {
    return typeof(f)==="number" && Math.round(f) == f;
}
function isFloat(f) { return typeof(f)==="number" && !isInteger(f); }

Answer 13

简单整数测试：

if( n === parseInt(n) ) ...

这是有道理的：如果 JavaScript 可以将某些东西转换为整数，并且通过转换它变成完全相同的东西，那么你的操作数就是一个整数。

控制台测试用例：

x = 1;     x===parseInt(x); // true
x = "1";   x===parseInt(x); // false
x = 1.1;   x===parseInt(x); // false, obviously

// BUT!

x = 1.0;   x===parseInt(x); // true, because 1.0 is NOT a float!

这让很多人感到困惑。每当某个东西是 .0 时，它就不再是浮点数了。它是一个整数。或者你可以称它为“数字事物”，因为没有像当时的 C 语言那样的严格区别。美好的旧时代。

所以基本上，您所能做的就是检查整数，接受 1.000 是整数这一事实。

有趣的旁注

有一个关于巨大数字的评论。巨大的数字意味着这种方法没有问题；每当 parseInt 无法处理该数字（因为它太大）时，它将返回实际值以外的其他内容，因此测试将返回 FALSE。看：

var a = 99999999999999999999;
var b = 999999999999999999999; // just one more 9 will kill the show!

var aIsInteger = (  a===parseInt(a)  )?"a is ok":"a fails";
var bIsInteger = (  b===parseInt(b)  )?"b is ok":"b fails";

alert(aIsInteger+"; "+bIsInteger);

我于 2014 年在 IE8 上进行了测试，然后在 2021 年在 Chrome 上进行了测试，两者都返回“a 正常；b 失败”，这意味着如果数字太大，它就不能再是整数了。

引用一句经典的话，20 位数字对任何人来说都应该足够了。

Answer 14

任何具有零小数部分的浮点数(例如1.0,12.00,0.0)都会隐式转换为Integer,因此无法检查它们是否为Float.

Answer 15

这是我用于整数的内容:

Math.ceil(parseFloat(val)) === val

简短,好看:)一直都在工作.如果我没有弄错的话,这就是大卫弗拉纳根所暗示的.

Answer 16

!!(24%1) // false
!!(24.2%1) // true

Answer 17

var isInt = function (n) { return n === (n | 0); };

还没有发生过这不起作用的情况。

Answer 18

尝试了这里的一些答案，我最终编写了这个解决方案。这也适用于字符串内的数字。

function isInt(number) {
    if (!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
    return !(number - parseInt(number));
}

function isFloat(number) {
    if (!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
    return number - parseInt(number) ? true : false;
}

function isInt(number) {
    if (!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
    return !(number - parseInt(number));
}

function isFloat(number) {
    if (!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
    return number - parseInt(number) ? true : false;
}