如何在JavaScript中检查变量是否为整数？_Javascript

如何在JavaScript中检查变量是否为整数？

javascript

如何在JavaScript中检查变量是否为整数？,javascript,Javascript,如何在JavaScript中检查变量是否为整数，如果不是，如何抛出警报？我试过这个，但不起作用： <html> <head> <script type="text/javascript"> var data = 22; alert(NaN(data)); </script> </head> </html> var数据=22；

如何在JavaScript中检查变量是否为整数，如果不是，如何抛出警报？我试过这个，但不起作用：

<html>
    <head>
        <script type="text/javascript">
            var data = 22;
            alert(NaN(data));
        </script>
    </head>
</html>


var数据=22；
警报（NaN（数据））；

检查变量是否等于四舍五入为整数的同一变量，如下所示：

if(Math.round(data) != data) {
    alert("Variable is not an integer!");
}

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

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

  return true;
};

首先，NaN是一个“数字”（是的，我知道这很奇怪，随它去吧），而不是一个“函数”

如果变量的类型是一个数字，则需要同时检查这两个变量，如果要检查整数，则需要使用模数

alert(typeof data === 'number' && data%1 == 0);

您可以检查数字是否有余数：

var data = 22;

if(data % 1 === 0){
   // yes it's an integer.
}

请注意，如果您的输入也可以是文本，并且您想先检查它是否为文本，那么您可以先检查类型：

var data = 22;

if(typeof data === 'number'){
     // yes it is numeric

    if(data % 1 === 0){
       // yes it's an integer.
    }
}

使用===运算符（）如下所示

if (data === parseInt(data, 10))
    alert("data is integer")
else
    alert("data is not an integer")

假设您对所讨论的变量一无所知，则应采用以下方法：

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
}

这要视情况而定，您是否也希望将字符串转换为潜在整数

这将有助于：

function isInt(value) {
  return !isNaN(value) && 
         parseInt(Number(value)) == value && 
         !isNaN(parseInt(value, 10));
}

用位运算简单的解析和检查

function isInt(value) {
  var x = parseFloat(value);
  return !isNaN(value) && (x | 0) === x;
}

短路并保存解析操作：

function isInt(value) {
  if (isNaN(value)) {
    return false;
  }
  var x = parseFloat(value);
  return (x | 0) === x;
}

或者两种方法都可以一次性使用：

function isInt(value) {
  return !isNaN(value) && (function(x) { return (x | 0) === x; })(parseFloat(value))
}

测试：

isInt(42)        // true
isInt("42")      // true
isInt(4e2)       // true
isInt("4e2")     // true
isInt(" 1 ")     // true
isInt("")        // false
isInt("  ")      // false
isInt(42.1)      // false
isInt("1a")      // false
isInt("4e2a")    // false
isInt(null)      // false
isInt(undefined) // false
isInt(NaN)       // false

这是小提琴：

演出测试表明，短路解决方案具有最佳性能（ops/sec）

以下是一个基准：

如果您喜欢较短、钝的短路形式：

function isInt(value) {
  var x;
  return isNaN(value) ? !1 : (x = parseFloat(value), (0 | x) === x);
}

当然，我建议让minifier处理这个问题。

您可以使用regexp：

function isInteger(n) {
    return (typeof n == 'number' && /^-?\d+$/.test(n+''));
}

您可以使用此功能：

function isInteger(value) {
    return (value == parseInt(value));
}

即使值是包含整数值的字符串，它也将返回true。
因此，结果将是：

alert(isInteger(1)); // true
alert(isInteger(1.2)); // false
alert(isInteger("1")); // true
alert(isInteger("1.2")); // false
alert(isInteger("abc")); // false

使用时要小心

数量%1

空字符串（“”）或布尔值（true或false）将作为整数返回。你可能不想那样做

false % 1 // true
'' % 1 //true

编号：isInteger（数据）浏览器中的内置功能。Dosnt支持旧浏览器吗

备选方案：

Math.round(num)=== num

但是，对于空字符串和布尔值，Math.round（）也将无法检查是否需要整数：

if (+data===parseInt(data)) {return true} else {return false}

注意数据前面的+（将字符串转换为数字）和===表示精确值

以下是一些例子：

data=10
+data===parseInt(data)
true

data="10"
+data===parseInt(data)
true

data="10.2"
+data===parseInt(data)
false

发件人：

发现这是最好的方法。

使用

操作符：

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

因此，测试函数可能如下所示：

if(Math.round(data) != data) {
    alert("Variable is not an integer!");
}

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

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

  return true;
};

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

function isInt(value) {
    var er = /^-?[0-9]+$/;
    return er.test(value);
}

Number.isInteger（）

似乎是一条出路

MDN还为不支持

Number.isInteger（）

的浏览器（主要是IE的所有版本）提供了以下polyfill

这将解决另一个场景（121.），即末尾的一个点

function isInt(value) {
        var ind = value.indexOf(".");
        if (ind > -1) { return false; }

        if (isNaN(value)) {
            return false;
        }

        var x = parseFloat(value);
        return (x | 0) === x;

    }

对于不带分隔符的正整数值：

return ( data !== '' && data === data.replace(/\D/, '') );

测验 1.如果不是空的和 2.如果值等于替换其值中非数字字符的结果。

ECMA-262 6.0（ES6）标准包含函数

为了增加对旧浏览器的支持，我强烈建议使用强大且社区支持的解决方案，该解决方案来自：

这是纯ES6 JS polyfills库

请注意，此库需要es5垫片，只需遵循README.md.

，此外，

Number.isInteger（）

。可能

Number.isSafeInteger（）

是使用指定ES6的另一个选项

要在ES6之前的浏览器中使用polyfill

Number.issafeinterger（..）

，请执行以下操作：

Number.isSafeInteger = Number.isSafeInteger || function(num) {
    return typeof num === "number" && 
           isFinite(num) && 
           Math.floor(num) === num &&
           Math.abs( num ) <= Number.MAX_SAFE_INTEGER;
};

Number.isSafeInteger=Number.isSafeInteger | |函数（num）{
返回typeof num==“number”&&
isFinite（num）和
数学地板（num）==num&&
如果您的浏览器支持Math.abs（num）Number.isInteger（）
是最好的方法，如果不支持，我认为有很多方法可以做到：
function isInt1(value){
  return (value^0) === value
}

或：
或：
或：
现在我们可以测试结果：
var value = 1
isInt1(value)   // return true
isInt2(value)   // return true
isInt3(value)   // return true
isInt4(value)   // return true

var value = 1.1
isInt1(value)   // return false
isInt2(value)   // return false
isInt3(value)   // return false
isInt4(value)   // return false

var value = 1000000000000000000
isInt1(value)   // return false
isInt2(value)   // return true
isInt3(value)   // return false
isInt4(value)   // return true

var value = undefined
isInt1(value)   // return false
isInt2(value)   // return false
isInt3(value)   // return false
isInt4(value)   // return false

var value = '1' //number as string
isInt1(value)   // return false
isInt2(value)   // return false
isInt3(value)   // return false
isInt4(value)   // return false

因此，所有这些方法都是可行的，但是当数字很大时，parseInt和^operator就不能很好地工作。
您可以尝试number。如果value
可能是字符串形式的整数，例如var value=“23”
并且您希望它的计算结果为true
。避免尝试Number.isInteger（parseInt（value））
，因为这并不总是返回正确的值。例如，如果var value=“23abc”
并且您使用parseInt
实现，它仍然会返回true
if(Number.isInteger(Number(data))){
    //-----
}

但是，如果您想要严格的整数值，那么可能Number.isInteger（value）
就应该做到这一点。
最简单、最干净的ECMAScript-6之前的解决方案（即使将字符串或null等非数值传递给函数，该解决方案也足以返回false）如下：
function isInteger(x) { return (x^0) === x; } 

function isInteger(x) { return parseInt(x, 10) === 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 (x^0) === x; } 

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

虽然这种基于parseInt的方法适用于x的许多值，但一旦x变得相当大，它将无法正常工作。问题是parseInt（）在解析数字之前将其第一个参数强制为字符串。因此，一旦数字变得足够大，其字符串表示形式将以指数形式显示（例如，1e+21）。因此，parseInt（）将尝试解析1e+21，但在到达e字符时将停止解析，因此将返回值1。请注意：
> String(1000000000000000000000)
'1e+21'

> parseInt(1000000000000000000000, 10)
1

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

好的，得到负数，因为没有描述我的示例，所以更多示例：）：
我使用正则表达式和测试方法：
var isInteger = /^[0-9]\d*$/;

isInteger.test(123); //true
isInteger.test('123'); // true
isInteger.test('sdf'); //false
isInteger.test('123sdf'); //false

// If u want to avoid string value:
typeof testVal !== 'string' && isInteger.test(testValue);

为什么没有人提到编号。isInteger（）


非常适合我，用NaN
开头的数字解决问题。我的方法：
a>=1e+21→ 仅适用于非常大的数字。这肯定会涵盖所有情况，与本讨论中提供的其他解决方案不同
function isInteger(x) { return parseInt(x, 10) === x; }

> String(1000000000000000000000)
'1e+21'

> parseInt(1000000000000000000000, 10)
1

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

var x = 1.5;
if(!isNaN(x)){
 console.log('Number');
 if(x % 1 == 0){
   console.log('Integer');
 }
}else {
 console.log('not a number');
}

var isInteger = /^[0-9]\d*$/;

isInteger.test(123); //true
isInteger.test('123'); // true
isInteger.test('sdf'); //false
isInteger.test('123sdf'); //false

// If u want to avoid string value:
typeof testVal !== 'string' && isInteger.test(testValue);

Number.isInteger(10);        // returns true
Number.isInteger(10.5);      // returns false
Number.isInteger("10");      // returns false

let number = 5;
if (Number.isInteger(number)) {
    //do something
}

if (data.toString() === parseInt(data, 10).toString())
    alert("data is a valid integer")
else
    alert("data is not a valid integer")