如何检查一个变量是否是一个整数在JavaScript?

小开

检查变量是否等于相同的变量四舍五入为整数，就像这样:

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

小开

首先，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

这是小提琴: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 < / p >

如果你喜欢更短的钝角短路形式:

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

当然了，我建议让这个小工具来处理。

小开

你可以使用regexp:

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

小开

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>

小开

你可以使用这个函数:

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

小开

使用时要小心

Num % 1

空字符串(")或布尔值(真或假)将返回为整数。你可能不想这么做

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

Number.isInteger(数据)

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

内置功能在浏览器中。不支持旧浏览器

选择:

Math.round(num)=== num

然而，Math.round()对于空字符串和布尔值也会失败

小开

检查像poster这样的整数是否需要:

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

注意+在data前面(将字符串转换为数字)，===表示精确。

下面是一些例子:

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


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


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

小开

从http://www.toptal.com/javascript/interview-questions:

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

我发现这是最好的方法。

小开

使用|操作符:

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

小开

你可以使用一个简单的正则表达式:

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

小开

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

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

MDN页面链接

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

小开

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

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。

小开

你可以使用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;}
}

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

小开

这将解决另一个场景(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/, '') );

< p >测试 1. 如果不是空的， 2.

. If value等于替换其值中的非数字字符的结果

小开

ECMA-262 6.0 (ES6)标准包含Number.isInteger函数。

为了增加对旧浏览器的支持，我强烈建议使用强大的和社区支持的解决方案:

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

它是纯ES6 JS polyfills库。

注意，这个库需要es5-shim，只需遵循README.md即可。

小开

此外,Number.isInteger()。也许Number.isSafeInteger()是使用es6指定的另一个选项在这里。

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

小开

为文本框添加类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.');
}
});

这对我有用。试试这个

你可以使用键盘，键上，键下等，而不是输入。

小开

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和^ operator就不能很好地工作了。

小开

Lodash https://lodash.com/docs#isInteger(自4.0.0起)有一个函数来检查变量是否为整数:

_.isInteger(3);
// → true


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


_.isInteger(Infinity);
// → false


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

小开

if(Number.isInteger(Number(data))){
//-----
}

小开

你可以尝试__abc0，如果value可能是字符串形式的整数，例如var value = "23"，并且你想让它计算为true。避免尝试Number.isInteger(parseInt(value))，因为这并不总是返回正确的值。例如，如果var value = "23abc"和你使用parseInt实现，它仍然会返回true。

但如果你想要严格的整数值，那么Number.isInteger(value)可能可以做到这一点。

小开

试试下面的功能:

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

小开

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

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

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

< p >编辑: 我找到了一个更好的方法，不使用字符串:

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

我认为这是最简短的答案。也许是最有效的，但我可以更正一下。：）

小开

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

小开

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() ?

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

工作完美为我和解决问题的NaN开始一个数字。

小开

我的方法:

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

小开

你也可以试试这种方法

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

小开

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

其中Number.isInteger ()方法返回true如果参数为整数，否则返回false。

重要提示:对于可以表示为整数的浮点数，该方法也将返回true。例如:5.0(因为它恰好等于5)

用法示例:

Number.isInteger(0);         // true
Number.isInteger(1);         // true
Number.isInteger(-100000);   // true
Number.isInteger(99999999999999999999999); // true


Number.isInteger(0.1);       // false
Number.isInteger(Math.PI);   // false


Number.isInteger(NaN);       // false
Number.isInteger(Infinity);  // false
Number.isInteger(-Infinity); // false
Number.isInteger('10');      // false
Number.isInteger(true);      // false
Number.isInteger(false);     // false
Number.isInteger([1]);       // false


Number.isInteger(5.0);       // true
Number.isInteger(5.000000000000001); // false
Number.isInteger(5.0000000000000001); // true

小开

试试这个:

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

小开

大整数(`bigint`)呢?

大多数这些答案在大整数(2⁵³或更大)上失败:(x | 0) === x)，测试typeof x === 'number'，常规int函数(例如parseInt)，常规算术在大整数上失败。这可以通过使用BigInt来解决。

我将几个答案编译成一个代码片段以显示结果。对于大整数，大多数完全失败，而其他则可以，除非传递类型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
}
}

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


console.log('--- should be false')
console.log(isInt(undefined))
console.log(isInt(null))
console.log(isInt({}))
console.log(isInt(1.1e-1))
console.log(isInt(1.1))
console.log(isInt(NaN))
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))
// gets converted to number
console.log(isInt(''))
console.log(isInt([]))
console.log(isInt(true))
console.log(isInt('1'))

小开

答案中有很多选项。

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

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

小开

接受的答案不为我工作，因为我需要检查int/float和字母。因此，尝试这将工作的int/float和字母检查

function is_int(value){
if( (parseInt(value) % 1 === 0 )){
return true;
}else{
return false;
}
}

使用

is_int(44);   // true
is_int("44");   // true
is_int(44.55);  // true
is_int("44.55");  // true
is_int("aaa");  // false

小开

在今天的浏览器中，Number.isInteger()是一种方式，就像之前解释的许多答案一样，但我遇到了一个常见的问题，它发生在我构建API的时候。

所以在API请求中，我们接收到属性为string，因此Number.isInteger()将返回false。

如果我们尝试用Number.isInteger(parseInt())检查它，那么像1.1或1.asd这样的值将返回true

为了解决这个问题，我创建了一个函数，它检查value是否为integer，将其传递为integer或string

function isNumber(value) {
return ([...value.toString()]
.filter(x => [ '1', '2', '3', '4', '5', '6', '7', '8', '9', '0' ]
.indexOf(x) >= 0))
.length == Math.max(value.toString().length, 1)
}

Math.max()部分用于处理空字符串