使用|运算符:

(5.3 | 0) === 5.3 // => false
(5.0 | 0) === 5.0 // => true

所以，一个测试函数可能是这样的:

var isInteger = function (value) {
  if (typeof value !== 'number') {
    return false;
  }

  if ((value | 0) !== value) {
    return false;
  }

  return true;
};

答案中有很多选项。

isNaN对于纯整数来说可能很棘手，您仍然需要其他检查来使它过时。 Number.isInteger()在IE中不受官方支持(大多数人不会关心，但也有一些掉队者)。

最后我自己写了一些东西:

function isInteger(valueToCheck) {
    return typeof valueToCheck !== 'undefined'
        && (valueToCheck === parseInt(valueToCheck, 10));
}

Test

let undefinedValue;
const testValues = [
    1,
    '',
    undefinedValue,
    1.1,
    '1',
    '1.1',
    '1-2',
    'bob',
    false,
    [],
    [1],
    {},
    {foo: 1}
];

testValues.forEach(value => {
    console.log(`${value} - ${isInteger(value)}`);
})

结果:

1 - true
'' - false
undefined - false
1.1 - false
'1' - false
'1.1' - false
'1-2' - false
'bob' - false
false - false
[] - false
[1] - false
{} - false
{foo: 1} - false

一些测试值是多余的，但它们的存在只是清楚地表明没有任何东西通过。你可以省略函数中的未定义检查，但我发现在JS中未定义的东西可能会很奇怪，所以感觉更安全。

我必须检查一个变量(字符串或数字)是否为整数，我使用了这个条件:

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

http://jsfiddle.net/e267369d/1/

其他一些答案也有类似的解决方案(依赖于parseFloat与isNaN相结合)，但我的答案应该更直接和自我解释。

编辑:我发现我的方法失败的字符串包含逗号(如“1,2”)，我也意识到，在我的特定情况下，我希望函数失败，如果字符串不是一个有效的整数(应该失败的任何浮点数，甚至1.0)。这是我的函数Mk II

function isInt(a){
    return !isNaN(a) && parseInt(a) == parseFloat(a) && (typeof a != 'string' || (a.indexOf('.') == -1 && a.indexOf(',') == -1));
}

http://jsfiddle.net/e267369d/3/

当然，如果你真的需要这个函数接受整数浮点数(1.0之类的东西)，你总是可以删除点条件a.indexOf('.') == -1。

ecmascript -6之前最简单、最清晰的解决方案(它也足够健壮，即使传递给函数的是一个非数字值，如字符串或null，也会返回false)如下:

function isInteger(x) { return (x^0) === x; } 

下面的解决方案也可以工作，尽管没有上面的那样优雅:

function isInteger(x) { return Math.round(x) === x; }

注意，在上述实现中Math.ceil()或Math.floor()也可以同样好地使用(而不是Math.round())。

或者:

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

一个相当常见的错误解决方案是:

function isInteger(x) { return parseInt(x, 10) === x; }

While this parseInt-based approach will work well for many values of x, once x becomes quite large, it will fail to work properly. The problem is that parseInt() coerces its first parameter to a string before parsing digits. Therefore, once the number becomes sufficiently large, its string representation will be presented in exponential form (e.g., 1e+21). Accordingly, parseInt() will then try to parse 1e+21, but will stop parsing when it reaches the e character and will therefore return a value of 1. Observe:

> String(1000000000000000000000)
'1e+21'

> parseInt(1000000000000000000000, 10)
1

> parseInt(1000000000000000000000, 10) === 1000000000000000000000
false

我的方法:

a >= 1e+21→只适用于非常大的数字。这将肯定涵盖所有情况，不像本讨论中提供的其他解决方案。

A === (A |0)→如果给定函数的实参与按位转换的值完全相同(===)，则意味着实参是一个整数。

A |0→对于A的任何非数字值都返回0，如果A确实是数字，它将去掉小数点后的所有数字，因此1.0001将变成1

const isInteger = n => n >= 1e+21 ? true : n === (n|0); // tests: [ [1, true], [1000000000000000000000, true], [4e2, true], [Infinity, true], [1.0, true], [1.0000000000001, false], [0.1, false], ["0", false], ["1", false], ["1.1", false], [NaN, false], [[], false], [{}, false], [true, false], [false, false], [null, false], [undefined, false], ].forEach(([test, expected]) => console.log( isInteger(test) === expected, typeof test, test ) )

假设你对问题中的变量一无所知，你应该采用这种方法:

if(typeof data === 'number') {
    var remainder = (data % 1);
    if(remainder === 0) {
        // yes, it is an integer
    }
    else if(isNaN(remainder)) {
        // no, data is either: NaN, Infinity, or -Infinity
    }
    else {
        // no, it is a float (still a number though)
    }
}
else {
    // no way, it is not even a number
}

简单来说:

if(typeof data==='number' && (data%1)===0) {
    // data is an integer
}