const integerCheck = (num) => {
        const isInt = (n) => Number(n) === n && n % 1 === 0
        const isFloat = (n) => Number(n) === n && n % 1 !== 0
        return (isInt(num) || !isFloat(num))        
}
console.log( integerCheck('23.3') );

这真的取决于你想要实现什么。如果你想“模仿”强类型语言，那么我建议你不要尝试。正如其他人提到的，所有数字都有相同的表示（相同类型）。

使用Claudiu提供的内容：

isInteger（1.0）->true

这看起来很正常，但在C这样的情况下，你会错

基于我在这里看到的所有内容，我创建了自己的一组函数来测试我所需要的：

function NumberValidator() {
this.isFloat = function (n) {
    return typeof(n)==="number" && n === +n && Math.round(n) !== n;
};

this.isInteger = function (n) {
    return typeof(n)==="number" && n === +n && Math.round(n) === n;
};

this.isFloatOrInteger = function (n) {
    return this.isFloat(n) || this.isInteger(n);
};

this.isNonZeroFloatOrInteger = function (n) {
    return this.isFloatOrInteger(n) && n > 0;
};

this.isNonZeroInteger = function (n) {
    return this.isInteger(n) && n > 0;
};
}

然而，shime的解决方案更短，检查更少，因此可能是更好的解决方案。

它真的不必那么复杂。整数的parseFloat（）和parseInt（）等价物的数值将相同。因此，您可以这样做：

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

Then

if (isInt(x)) // do work

这也将允许字符串检查，因此并不严格。如果想要一个强类型的解决方案（也就是，不使用字符串）：

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

parseInt(yourNumber)=== parseFloat(yourNumber)

尝试这些函数来测试一个值是否是一个没有小数部分的数字基元值，并且在可以表示为精确整数的大小范围内。

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

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