我的方法：

Question

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

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

Answer 1

这取决于，您是否也希望将字符串转换为潜在的整数？

这样做：

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

这是小提琴：http://jsfiddle.net/opfyrqwp/28/

性能

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

// Short-circuiting, and saving a parse operation
function isInt(value) {
  var x;
  if (isNaN(value)) {
    return false;
  }
  x = parseFloat(value);
  return (x | 0) === x;
}

这是一个基准： http://jsben.ch/#/htLVw

如果您想要一种较短的，钝的短路形式：

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

当然，我建议让迷你者来处理。

Answer 2

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

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

Answer 3

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

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
}

Answer 4

Number.isInteger()似乎是要走的路。

MDN还为不支持Number.isInteger()的浏览器提供了以下polyfill，主要是IE的所有版本。

Link to MDN page

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

Answer 5

您可以检查号码是否有余数：

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

Answer 6

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

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

Answer 7

首先，NaN是一个“数字”（是的我知道它很奇怪，只是滚动它），而不是“功能”。

你需要检查变量的类型是否为数字，并检查整数，我会使用模数。

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

Answer 8

使用时要小心

num％1

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

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

Number.isInteger（数据）

Number.isInteger(22); //true
Number.isInteger(22.2); //false
Number.isInteger('22'); //false

在浏览器中构建功能。 Dosnt支持旧浏览器

<强>备选方案：

Math.round(num)=== num

但是，对于空字符串和布尔值

，Math.round（）也会失败

Answer 9

检查海报是否需要整数：

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

Answer 10

 describe('My suite that breaks', function(){
        it('sp start page', function() {
            //some other stuff
        });
        it('select something from dropdown', function(){
            waitForElement(by.css('button[data-organization="none"]')).click();
            waitForElement(by.css('a[data-organization="somevalue"]')).click();
            //some other stuff
        });

Answer 11

最简单和最干净的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; }

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

> String(1000000000000000000000)
'1e+21'

> parseInt(1000000000000000000000, 10)
1

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

Answer 12

为什么没有人提到Number.isInteger()？

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger

完美适合我，并以NaN开头的数字来解决问题。

Answer 13

如果Number.isInteger(Number(value))可能是字符串形式的整数，例如value，您可以尝试var value = "23"，并且您希望将其评估为true。避免尝试Number.isInteger(parseInt(value))，因为这并不总是返回正确的值。例如，如果var value = "23abc"并且您使用parseInt实现，它仍将返回true。

但是如果你想要严格的整数值，那么Number.isInteger(value)可能就可以了。

Answer 14

ECMA-262 6.0（ES6）标准包括Number.isInteger功能。

为了添加对旧版浏览器的支持，我强烈建议您使用以下强大的社区支持解决方案：

https://github.com/paulmillr/es6-shim

这是纯 ES6 JS polyfills库。

请注意，此lib需要es5-shim，只需按照README.md。

Answer 15

Number.isInteger()是最好的方式，如果您的浏览器支持它，如果没有，我认为有很多方法可以去：

function isInt1(value){
  return (value^0) === value
}

或：

function isInt2(value){
  return (typeof value === 'number') && (value % 1 === 0); 
}

或：

function isInt3(value){
  return parseInt(value, 10) === value; 
}

或：

function isInt4(value){
  return Math.round(value) === 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和^运算符就不会很好。

Answer 16

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

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

Answer 17

此外，Number.isInteger()。通过使用指定的ES6，Number.isSafeInteger()可能是另一个选项here。

要在ES6之前的浏览器中填充Number.isSafeInteger(..)：

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

Answer 18

大整数 (`bigint`) 怎么样？

这些答案中的大多数在大整数（2⁵³ 和更大）上失败：按位测试（例如 (x | 0) === x）、测试 typeof x === 'number'、常规 int 函数（例如 {{ 1}})，常规算术在大整数上失败。这可以通过使用 BigInt 来解决。

我已将多个答案汇总到一个片段中以显示结果。大多数完全以大整数失败，而其他人则工作，除非传递类型parseInt（例如BigInt）。我没有包含重复的答案，也没有包含任何允许小数或不尝试测试类型的答案）

1n

检查类型

如果您确实想测试传入值的类型以确保它是整数，请改用：

// these all fail
n = 1000000000000000000000000000000
b = 1n

// These all fail on large integers
//https://stackoverflow.com/a/14636652/3600709
console.log('fail',1,n === parseInt(n, 10))
//https://stackoverflow.com/a/14794066/3600709
console.log('fail',2,!isNaN(n) && parseInt(Number(n)) == n && !isNaN(parseInt(n, 10)))
console.log('fail',2,!isNaN(n) && (parseFloat(n) | 0) === parseFloat(n))
console.log('fail',2,!isNaN(n) && (function(x) { return (x | 0) === x; })(parseFloat(n)))
//https://stackoverflow.com/a/21742529/3600709
console.log('fail',3,n == ~~n)
//https://stackoverflow.com/a/28211631/3600709
console.log('fail',4,!isNaN(n) && parseInt(n) == parseFloat(n))
//https://stackoverflow.com/a/41854178/3600709
console.log('fail',5,String(parseInt(n, 10)) === String(n))

// These ones work for integers, but not BigInt types (e.g. 1n)
//https://stackoverflow.com/a/14636725/3600709
console.log('partial',1,typeof n==='number' && (n%1)===0) // this one works
console.log('partial',1,typeof b==='number' && (b%1)===0) // this one fails
//https://stackoverflow.com/a/27424770/3600709
console.log('partial',2,Number.isInteger(n)) // this one works
console.log('partial',2,Number.isInteger(b)) // this one fails
//https://stackoverflow.com/a/14636638/3600709
console.log('partial',3,n % 1 === 0)
console.log('partial',3,b % 1 === 0) // gives uncaught type on BigInt

function isInt(value) {
    try {
        BigInt(value)
        return !['string','object','boolean'].includes(typeof value)
    } catch(e) {
        return false
    }
}

不检查类型

如果您不关心传入的类型是否实际上是布尔值、字符串等转换为数字的，那么只需使用以下内容：

function isInt(value) {
    try {
        BigInt(value)
        return !['string','object','boolean'].includes(typeof value)
    } catch(e) {
        return false
    }
}

console.log('--- should be false')
console.log(isInt(undefined))
console.log(isInt(''))
console.log(isInt(null))
console.log(isInt({}))
console.log(isInt([]))
console.log(isInt(1.1e-1))
console.log(isInt(1.1))
console.log(isInt(true))
console.log(isInt(NaN))
console.log(isInt('1'))
console.log(isInt(function(){}))
console.log(isInt(Infinity))

console.log('--- should be true')
console.log(isInt(10))
console.log(isInt(0x11))
console.log(isInt(0))
console.log(isInt(-10000))
console.log(isInt(100000000000000000000000000000000000000))
console.log(isInt(1n))

function isInt(value) {
    try {
        BigInt(value)
        return true
    } catch(e) {
        return false
    }
}

Answer 19

您可以使用此功能：

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

Answer 20

这将解决另一种情况（ 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;

    }

Answer 21

您可以使用正则表达式：

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

Answer 22

“接受”的答案是错误的（如以下一些评论所指出）。此修改可以使其起作用：

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

Answer 23

只需尝试一下：

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

Answer 24

在ES6中，为Number Object添加了2种新方法。

如果参数为整数，则Number.isInteger（）方法在其中返回true。

示例用法：

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

Answer 25

好了，因为没有描述我的例子，所以更多的例子：）：

我使用正则表达式和测试方法：

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

Answer 26

来自http://www.toptal.com/javascript/interview-questions：

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

发现这是最好的方法。

Answer 27

使用|运算符：

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

Answer 28

对于没有分隔符的正整数值：

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

测试 1.如果不是空的话 2.如果value等于在其值中替换非数字字符的结果。

Answer 29

在几次成功和失败之后，我想出了这个解决方案：

const isInt = (value) => {
  return String(parseInt(value, 10)) === String(value)
}

我喜欢上面检查不是NaN的值并使用parseFloat的想法，但是当我在React基础设施中尝试它时，由于某种原因它没有工作。

编辑：我没有使用字符串找到了更好的方法：

var isInt = function (str) {
  return str === '0' || !!~~str;
}

我认为这是最简短的答案。也许效率最高，但我可以立即纠正。：）

Answer 30

我必须检查变量（字符串或数字）是否为整数，并且我使用了这个条件：

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

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

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

编辑：我发现我的方法对于包含逗号的字符串失败了（比如＆＃34; 1,2＆＃34;）我也意识到在我的特定情况下我希望函数失败如果字符串不是有效整数（任何浮点数都应该失败，甚至是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。

Answer 31

function isInteger(argument) { return argument == ~~argument; }

用法：

isInteger(1);     // true<br>
isInteger(0.1);   // false<br>
isInteger("1");   // true<br>
isInteger("0.1"); // false<br>

或

function isInteger(argument) { return argument == argument + 0 && argument == ~~argument; }

用法：

isInteger(1); // true<br> isInteger(0.1); // false<br> isInteger("1"); // false<br> isInteger("0.1"); // false<br>

Answer 32

我的方法：

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

Answer 33

您也可以这样尝试

var data = 22;
if (Number.isInteger(data)) {
    console.log("integer");
 }else{
     console.log("not an integer");
 }

或

if (data === parseInt(data, 10)){
    console.log("integer");
}else{
    console.log("not an integer");
}

Answer 34

Lodash https://lodash.com/docs#isInteger（自4.0.0起）具有检查变量是否为整数的函数：

_.isInteger(3);
// → true

_.isInteger(Number.MIN_VALUE);
// → false

_.isInteger(Infinity);
// → false

_.isInteger('3');
// → false

Answer 35

答案中有很多选项。

isNaN 对于纯整数来说可能很棘手，您仍然需要其他检查使其过时。
Number.isInteger() 在 IE 中没有得到官方支持（大多数人不会在意，但也有一些落后者）。

我最终自己写了一些东西：

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

测试

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

一些测试值是矫枉过正的，但它们的存在只是清楚地表明什么都没有通过。你可以省略函数中的 undefined 检查，但我发现未定义的东西在 JS 中可能很奇怪，所以在那里感觉更安全。

Answer 36

尝试以下功能：

function isInteger (num) {
    return num == parseInt(+num,10)  && !isNaN(parseInt(num));
}

console.log ( isInteger(42));        // true
console.log ( isInteger("42"));      // true
console.log ( isInteger(4e2));       // true
console.log ( isInteger("4e2"));     // true
console.log ( isInteger(" 1 "));     // true
console.log ( isInteger(""));        // false
console.log ( isInteger("  "));      // false
console.log ( isInteger(42.1));      // false
console.log ( isInteger("1a"));      // false
console.log ( isInteger("4e2a"));    // false
console.log ( isInteger(null));      // false
console.log ( isInteger(undefined)); // false
console.log ( isInteger(NaN));       // false    
console.log ( isInteger(false));       // false
console.log ( isInteger(true));       // false
console.log ( isInteger(Infinity));       // false

Answer 37

此解决方案适用于所有浏览器。
1.将您的电话号码转换为字符串，例如123 =>字符串（123）
2.使用字符串的indexOf函数检查给定字符串中是否有任何。（点）。

“ 123” .indexOf（“。”）=> -1 //整数
“ 123.1” .indexOf（“。”）=> 3 //不是整数

OR

使用以下功能

function isInt(val) {
    return String(val).indexOf('.') === -1;
}

Answer 38

您可以使用regexp执行此操作：

function isInt(data){
  if(typeof(data)=='number'){
    var patt=/^[0-9e+]+$/;
    data=data+"";
    data=data.match(patt);
    if(data==null){return false;}
     else {return true;}}
  else{return false;} 
}

如果数据不是整数，则返回false，否则返回true。

Answer 39

为文本框添加类numOnly，

$(document).on("input", ".numOnly", function(e) {
    this.value = this.value.replace(/[^0-9\$]/g,'');
    if(this.value!=""){
      alert('Integer Number.');
    }else{
      alert('Not an Integer Number.');
   }
});

它对我有用..试试这个

您可以使用keypres，keyup，keydown等代替输入。

Answer 40

如果是数字则输出

if (data >= 0 || data <=0){
            console.log('its a number');
          }

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

41 个答案:

使用按位操作

性能

Number.isInteger（数据）

大整数 (`bigint`) 怎么样？

检查类型

不检查类型

我的方法：

测试

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

41 个答案:

使用按位操作

性能

Number.isInteger（数据）

大整数 (bigint) 怎么样？

检查类型

不检查类型

我的方法：

测试

大整数 (`bigint`) 怎么样？