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

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

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

除以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;
}

更新2019 这个答案写在5年后，一种解决方案，ECMA脚本2015年被标准化该解决方案涵盖在这个答案。

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

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

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

为什么不这样：

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

目前有一种称为Number.isInteger()IE 的方法，除了IE之外，其他所有方法均已实现。MDN还为其他浏览器提供了polyfill：

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

但是，在大多数情况下，最好还是使用Number.isSafeInteger 后者来检查该值是否过高/过低，以至于任何小数位都会丢失。MDN对此也有一个polyfil。（您还需要isInteger上面的polyfill。）

if (!Number.MAX_SAFE_INTEGER) {
    Number.MAX_SAFE_INTEGER = 9007199254740991; // Math.pow(2, 53) - 1;
}
Number.isSafeInteger = Number.isSafeInteger || function (value) {
   return Number.isInteger(value) && Math.abs(value) <= Number.MAX_SAFE_INTEGER;
};

您可以使用一个简单的正则表达式：

function isInt(value) {

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

    return er.test(value);
}

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

is_int() =>检查变量类型是否为整数，并且其内容是否为整数

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

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

更新1

现在它也检查负数，感谢@ChrisBartley评论！

以下是一些有效的函数，它们可以检查值是数字还是可以安全地转换为数字：

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

对于整数（如果值是浮点型，则将返回false）：

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

这里的效率是当值已经是一个数字时，避免使用parseInt（或parseNumber）。这两个解析函数总是先转换为字符串，然后再尝试解析该字符串，如果值已经是数字，那将是浪费。

感谢您在此提供的其他其他优化建议！

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

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

适用于所有情况。

正如其他人提到的那样，您在JS中只有双打。那么如何定义数字为整数呢？只需检查舍入的数字是否等于自己：

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

这个怎么样？

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

这是我用于整数的内容：

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

简短，好:)一直工作。如果我没记错的话，这就是大卫·弗拉纳根（David Flanagan）的建议。

这实际上取决于您要实现的目标。如果您想“模仿”强类型语言，那么我建议您不要尝试。正如其他提到的那样，所有数字都具有相同的表示形式（相同的类型）。

使用像Claudiu这样的东西提供：

isInteger( 1.0 ) ->真实

对于常识来说，这看起来不错，但是在C语言中，您将得到 false

带有零小数部分（例如1.0、12.00、0.0）的任何Float数字都隐式转换为Integer，因此无法检查它们是否为Float。

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

确实不必这么复杂。整数的parseFloat（）和parseInt（）等效项的数值将相同。因此，您可以这样做：

function isInt(value){ 
    return (parseFloat(value) == parseInt(value)) && !isNaN(value);
}

然后

if (isInt(x)) // do work

这也将允许进行字符串检查，因此并不严格。如果要一个强类型的解决方案（又名，不能与字符串一起使用）：

function is_int(value){ return !isNaN(parseInt(value * 1) }

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

还没有一个案例不能解决这个问题。

这是检查整数和浮点数的最终代码

function isInt(n) { 
   if(typeof n == 'number' && Math.Round(n) % 1 == 0) {
       return true;
   } else {
       return false;
   }
} 

要么

function isInt(n) {   
   return typeof n == 'number' && Math.Round(n) % 1 == 0;   
}   

function isInteger(n) {
   return ((typeof n==='number')&&(n%1===0));
}

function isFloat(n) {
   return ((typeof n==='number')&&(n%1!==0));
}

function isNumber(n) {
   return (typeof n==='number');
}

它很简单：

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

在控制台中尝试：

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。这是一件好事，因为如果您认为某个东西是“数字”，那么您通常希望JS能够使用它来计算-因此，是的，数字是有限的，parseInt将考虑这一点，以这种方式进行说明。

尝试这个：

<script>

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

</script>

在我的浏览器（IE8）中，这返回“ a正常； b失败”，这恰恰是因为b中的数字很大。限制可能会有所不同，但我想引用经典的20位数字“对于任何人都足够”

这个解决方案对我有用。

<html>
<body>
  <form method="post" action="#">
    <input type="text" id="number_id"/>
    <input type="submit" value="send"/>
  </form>
  <p id="message"></p>
  <script>
    var flt=document.getElementById("number_id").value;
    if(isNaN(flt)==false && Number.isInteger(flt)==false)
    {
     document.getElementById("message").innerHTML="the number_id is a float ";
    }
   else 
   {
     document.getElementById("message").innerHTML="the number_id is a Integer";
   }
  </script>
</body>
</html>

对于整数我用这个

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

在Java脚本中，所有数字均为internally 64 bit floating point，与java中的double相同。javascript中没有不同的类型，所有类型都由type表示number。因此，您将无法进行instanceof检查。但是，您可以使用上面给出的解决方案来确定它是否为分数。Java脚本的设计人员认为，使用单一类型的脚本可以避免大量的类型转换错误。

有时，Number对象不允许您直接使用mod运算符（％），如果遇到这种情况，可以使用此解决方案。

if(object instanceof Number ){
   if( ((Number) object).doubleValue() % 1 == 0 ){
      //your object is an integer
   }
   else{
      //your object is a double
   }
}

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

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

    var tests = {
        'integer' : 1,
        'float' : 1.1,
        'integerInString' : '5',
        'floatInString' : '5.5',
        'negativeInt' : -345,
        'negativeFloat' : -34.98,
        'negativeIntString' : '-45',
        'negativeFloatString' : '-23.09',
        'notValidFalse' : false,
        'notValidTrue' : true,
        'notValidString' : '45lorem',
        'notValidStringFloat' : '4.5lorem',
        'notValidNan' : NaN,
        'notValidObj' : {},
        'notValidArr' : [1,2],
    };

    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 testFunctions(obj) {
        var keys = Object.keys(obj);
        var values = Object.values(obj);

        values.forEach(function(element, index){
            console.log(`Is ${keys[index]} (${element}) var an integer? ${isInt(element)}`);
            console.log(`Is ${keys[index]} (${element}) var a float? ${isFloat(element)}`);
        });
    }

    testFunctions(tests);

这可能不如％Answer的性能好，这可以防止您首先转换为字符串，但是我还没有看到有人发布它，因此这是另一个可以正常使用的选项：

function isInteger(num) {
    return num.toString().indexOf('.') === -1;
}

对于那些好奇的人，我使用Benchmark.js测试了这篇文章中投票最多的答案（以及今天发布的答案），这是我的结果：

var n = -10.4375892034758293405790;
var suite = new Benchmark.Suite;
suite
    // kennebec
    .add('0', function() {
        return n % 1 == 0;
    })
    // kennebec
    .add('1', function() {
        return typeof n === 'number' && n % 1 == 0;
    })
    // kennebec
    .add('2', function() {
        return typeof n === 'number' && parseFloat(n) == parseInt(n, 10) && !isNaN(n);
    })

    // Axle
    .add('3', function() {
        return n.toString().indexOf('.') === -1;
    })

    // Dagg Nabbit
    .add('4', function() {
        return n === +n && n === (n|0);
    })

    // warfares
    .add('5', function() {
        return parseInt(n) === n;
    })

    // Marcio Simao
    .add('6', function() {
        return /^-?[0-9]+$/.test(n.toString());
    })

    // Tal Liron
    .add('7', function() {
        if ((undefined === n) || (null === n)) {
            return false;
        }
        if (typeof n == 'number') {
            return true;
        }
        return !isNaN(n - 0);
    });

// Define logs and Run
suite.on('cycle', function(event) {
    console.log(String(event.target));
}).on('complete', function() {
    console.log('Fastest is ' + this.filter('fastest').pluck('name'));
}).run({ 'async': true });

0 x 12,832,357 ops/sec ±0.65% (90 runs sampled)
1 x 12,916,439 ops/sec ±0.62% (95 runs sampled)
2 x 2,776,583 ops/sec ±0.93% (92 runs sampled)
3 x 10,345,379 ops/sec ±0.49% (97 runs sampled)
4 x 53,766,106 ops/sec ±0.66% (93 runs sampled)
5 x 26,514,109 ops/sec ±2.72% (93 runs sampled)
6 x 10,146,270 ops/sec ±2.54% (90 runs sampled)
7 x 60,353,419 ops/sec ±0.35% (97 runs sampled)

Fastest is 7 Tal Liron

这是我的代码。它检查以确保它不是一个空字符串（否则会通过），然后将其转换为数字格式。现在，取决于您是否希望“ 1.1”等于1.1，这可能是您想要的，也可能不是。

var isFloat = function(n) {
    n = n.length > 0 ? Number(n) : false;
    return (n === parseFloat(n));
};
var isInteger = function(n) {
    n = n.length > 0 ? Number(n) : false;
    return (n === parseInt(n));
};

var isNumeric = function(n){

   if(isInteger(n) || isFloat(n)){
        return true;
   }
   return false;

};

我喜欢这个小函数，对于正整数和负整数都将返回true：

function isInt(val) {
    return ["string","number"].indexOf(typeof(val)) > -1 && val !== '' && !isNaN(val+".0");
}

之所以有效，是因为1或“ 1”变成“ 1.0”，isNaN（）返回false（然后取反然后返回），但是1.0或“ 1.0”变成“ 1.0.0”，而“ string”变成“ string”。 0”，两者都不是数字，因此isNaN（）返回false（并且再次取反）。

如果只需要正整数，则有以下变体：

function isPositiveInt(val) {
    return ["string","number"].indexOf(typeof(val)) > -1 && val !== '' && !isNaN("0"+val);
}

或，对于负整数：

function isNegativeInt(val) {
    return `["string","number"].indexOf(typeof(val)) > -1` && val !== '' && isNaN("0"+val);
}

isPositiveInt（）通过将串联的数字字符串移到要测试的值之前来工作。例如，isPositiveInt（1）导致isNaN（）评估为“ 01”，其评估为false。同时，isPositiveInt（-1）导致isNaN（）评估为“ 0-1”，评估为true。我们取消了返回值，这给了我们想要的东西。isNegativeInt（）的工作原理类似，但不忽略isNaN（）的返回值。

编辑：

我最初的实现也会在数组和空字符串上返回true。该实现没有该缺陷。如果val不是字符串或数字，或者如果它是空字符串，它还具有提早返回的好处，在这种情况下，它可以更快地返回。您可以通过将前两个子句替换为来进一步修改它

typeof(val) != "number"

如果您只想匹配文字数字（而不是字符串）

编辑：

我还不能发表评论，所以将其添加到我的答案中。@Asok发布的基准非常有用；但是，最快的函数不符合要求，因为它对浮点数，数组，布尔值和空字符串也返回TRUE。

我创建了以下测试套件来测试每个功能，并将我的答案也添加到列表中（功能8（解析字符串）和功能9（不解析字符串））：

funcs = [
    function(n) {
        return n % 1 == 0;
    },
    function(n) {
        return typeof n === 'number' && n % 1 == 0;
    },
    function(n) {
        return typeof n === 'number' && parseFloat(n) == parseInt(n, 10) && !isNaN(n);
    },
    function(n) {
        return n.toString().indexOf('.') === -1;
    },
    function(n) {
        return n === +n && n === (n|0);
    },
    function(n) {
        return parseInt(n) === n;
    },
    function(n) {
        return /^-?[0-9]+$/.test(n.toString());
    },
    function(n) {
        if ((undefined === n) || (null === n)) {
            return false;
        }
        if (typeof n == 'number') {
            return true;
        }
        return !isNaN(n - 0);
    },
    function(n) {
        return ["string","number"].indexOf(typeof(n)) > -1 && n !== '' && !isNaN(n+".0");
    }
];
vals = [
    [1,true],
    [-1,true],
    [1.1,false],
    [-1.1,false],
    [[],false],
    [{},false],
    [true,false],
    [false,false],
    [null,false],
    ["",false],
    ["a",false],
    ["1",null],
    ["-1",null],
    ["1.1",null],
    ["-1.1",null]
];

for (var i in funcs) {
    var pass = true;
    console.log("Testing function "+i);
    for (var ii in vals) {
        var n = vals[ii][0];
        var ns;
        if (n === null) {
            ns = n+"";
        } else {
            switch (typeof(n)) {
                case "string":
                    ns = "'" + n + "'";
                    break;
                case "object":
                    ns = Object.prototype.toString.call(n);
                    break;
                default:
                    ns = n;
            }
            ns = "("+typeof(n)+") "+ns;
        }

        var x = vals[ii][1];
        var xs;
        if (x === null) {
            xs = "(ANY)";
        } else {
            switch (typeof(x)) {
                case "string":
                    xs = "'" + n + "'";
                    break;
                case "object":
                    xs = Object.prototype.toString.call(x);
                    break;
                default:
                    xs = x;
            }
            xs = "("+typeof(x)+") "+xs;
        }

        var rms;
        try {
            var r = funcs[i](n);
            var rs;
            if (r === null) {
                rs = r+"";
            } else {
                switch (typeof(r)) {
                    case "string":
                        rs = "'" + r + "'";
                        break;
                    case "object":
                        rs = Object.prototype.toString.call(r);
                        break;
                    default:
                        rs = r;
                }
                rs = "("+typeof(r)+") "+rs;
            }

            var m;
            var ms;
            if (x === null) {
                m = true;
                ms = "N/A";
            } else if (typeof(x) == 'object') {
                m = (xs === rs);
                ms = m;
            } else {
                m = (x === r);
                ms = m;
            }
            if (!m) {
                pass = false;
            }
            rms = "Result: "+rs+", Match: "+ms;
        } catch (e) {
            rms = "Test skipped; function threw exception!"
        }

        console.log("    Value: "+ns+", Expect: "+xs+", "+rms);
    }
    console.log(pass ? "PASS!" : "FAIL!");
}

我还重新运行了基准测试，并将功能＃8添加到了列表中。我不会发布结果，因为它们有点令人尴尬（例如，该功能不是很快）...

结果（摘要-我删除了成功的测试，因为输出很长），结果如下：

Testing function 0
Value: (object) [object Array], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) true, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) false, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: null, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
FAIL!

Testing function 1
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 2
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 3
Value: (object) true, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (object) false, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Array], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Object], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: null, Expect: (boolean) false, Test skipped; function threw exception!
Value: (string) '', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) 'a', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
FAIL!

Testing function 4
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 5
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 6
Value: null, Expect: (boolean) false, Test skipped; function threw exception!
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 7
Value: (number) 1.1, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (number) -1.1, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (object) true, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Array], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Object], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) true, Match: N/A
FAIL!

Testing function 8
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 9
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

我已经失败了，所以您可以看到每个函数在哪里失败，以及（字符串）“＃”测试，以便可以看到每个函数如何处理字符串中的整数和浮点值，因为有些人可能希望将它们解析为数字，而另一些不得。

在测试的10个功能中，实际符合OP要求的功能为[1、3、5、6、8、9]

浮动验证的条件：

if (lnk.value == +lnk.value && lnk.value != (lnk.value | 0)) 

整数验证的条件：

if (lnk.value == +lnk.value && lnk.value == (lnk.value | 0)) 

希望这会有所帮助。

function int(a) {
  return a - a === 0 && a.toString(32).indexOf('.') === -1
}

function float(a) {
  return a - a === 0 && a.toString(32).indexOf('.') !== -1
}

typeof a === 'number'如果要排除字符串，则可以添加。