How to check if a variable is an integer in JavaScript?

How do I check if a variable is an integer in JavaScript, and throw an alert if it isn't? I tried this, but it doesn't work:

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

40 Answers

12 Next

That depends, do you also want to cast strings as potential integers as well?

This will do:

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

With Bitwise operations

Simple parse and check

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

Short-circuiting, and saving a parse operation:

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

Or perhaps both in one shot:

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

Tests:

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

Here's the fiddle:

Performance

Testing reveals that the short-circuiting solution has the best performance (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;
}

Here is a benchmark:

If you fancy a shorter, obtuse form of short circuiting:

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

Of course, I'd suggest letting the minifier take care of that.

Use the === operator (strict equality) as below,

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

Number.isInteger() seems to be the way to go.

MDN has also provided the following polyfill for browsers not supporting Number.isInteger(), mainly all versions of IE.

Link to MDN page

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

Assuming you don't know anything about the variable in question, you should take this approach:

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
}

To put it simply:

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

You could check if the number has a remainder:

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

Mind you, if your input could also be text and you want to check first it is not, then you can check the type first:

var data = 22;
if(typeof data === 'number'){ // yes it is numeric if(data % 1 === 0){ // yes it's an integer. }
}

You can use a simple regular expression:

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

In ES6 2 new methods are added for Number Object.

In it Number.isInteger() method returns true if the argument is an integer, otherwise returns false.

Important Note: The method will also return true for floating point numbers that can be represented as integer. Eg: 5.0 (as it is exactly equal to 5 )

Example usage :

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

First off, NaN is a "number" (yes I know it's weird, just roll with it), and not a "function".

You need to check both if the type of the variable is a number, and to check for integer I would use modulus.

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

Be careful while using

num % 1

empty string ('') or boolean (true or false) will return as integer. You might not want to do that

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

Number.isInteger(data)

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

build in function in the browser. Dosnt support older browsers

Alternatives:

Math.round(num)=== num

However, Math.round() also will fail for empty string and boolean

To check if integer like poster wants:

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

notice + in front of data (converts string to number), and === for exact.

Here are examples:

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

The simplest and cleanest pre-ECMAScript-6 solution (which is also sufficiently robust to return false even if a non-numeric value such as a string or null is passed to the function) would be the following:

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

The following solution would also work, although not as elegant as the one above:

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

Note that Math.ceil() or Math.floor() could be used equally well (instead of Math.round()) in the above implementation.

Or alternatively:

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

One fairly common incorrect solution is the following:

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

Why hasnt anyone mentioned Number.isInteger() ?

Works perfectly for me and solves the issue with the NaN beginning a number.

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

Check if the variable is equal to that same variable rounded to an integer, like this:

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

ECMA-262 6.0 (ES6) standard include Number.isInteger function.

In order to add support for old browser I highly recommend using strong and community supported solution from:

which is pure ES6 JS polyfills library.

Note that this lib require es5-shim, just follow README.md.

You could use this function:

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

It will return true even if the value is a string containing an integer value.
So, the results will be:

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

Use the | operator:

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

So, a test function might look like this:

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

You could tryNumber.isInteger(Number(value)) if value might be an integer in string form e.g var value = "23" and you want this to evaluate to true. Avoid trying Number.isInteger(parseInt(value)) because this won't always return the correct value. e.g if var value = "23abc" and you use the parseInt implementation, it would still return true.

But if you want strictly integer values then probably Number.isInteger(value) should do the trick.

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

My approach:

a >= 1e+21 → Only pass for very large numbers. This will cover all cases for sure, unlike other solutions which has been provided in this discussion.

a === (a|0) → if the given function's argument is exactly the same (===) as the bitwise-transformed value, it means that the argument is an integer.

a|0 → return 0 for any value of a that isn't a number, and if a is indeed a number, it will strip away anything after the decimal point, so 1.0001 will become 1

function isInteger(a){ return a >= 1e+21 ? true : a === (a|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( a => console.log(typeof a, a, isInteger(a)) )

What about large integers (`bigint`)?

Most of these answers fail on large integers (2⁵³ and larger): Bitwise tests(e.g. (x | 0) === x), testing typeof x === 'number', regular int functions (e.g. parseInt), regular arithmetics fail on large integers. This can be resolved by using BigInt.

I've compiled several answers into one snippet to show the results. Most outright fail with large integers, while others work, except when passed the type BigInt (e.g. 1n). I've not included duplicate answers and have also left out any answers that allow decimals or don't attempt to test type)

// these all fail
n = 1000000000000000000000000000000
b = 1n
// These all fail on large integers
//
console.log('fail',1,n === parseInt(n, 10))
//
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)))
//
console.log('fail',3,n == ~~n)
//
console.log('fail',4,!isNaN(n) && parseInt(n) == parseFloat(n))
//
console.log('fail',5,String(parseInt(n, 10)) === String(n))
// These ones work for integers, but not BigInt types (e.g. 1n)
//
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
//
console.log('partial',2,Number.isInteger(n)) // this one works
console.log('partial',2,Number.isInteger(b)) // this one fails
//
console.log('partial',3,n % 1 === 0)
console.log('partial',3,b % 1 === 0) // gives uncaught type on BigInt

Checking type

If you actually want to test the incoming value's type to ensure it's an integer, use this instead:

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

Without checking type

If you don't care if the incoming type is actually boolean, string, etc. converted into a number, then just use the following:

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

The Accepted answer not worked for me as i needed to check for int/float and alphabet. so try this at will work for both int/float and alphabet check

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

usage

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

Besides, Number.isInteger(). Maybe Number.isSafeInteger() is another option here by using the ES6-specified.

To polyfill Number.isSafeInteger(..) in pre-ES6 browsers:

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

Number.isInteger() is the best way if your browser support it, if not, I think there are so many ways to go:

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

or:

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

or:

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

or:

function isInt4(value){ return Math.round(value) === value;
}

now we can test the results:

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

So, all of these methods are works, but when the number is very big, parseInt and ^ operator would not works well.

Just try this:

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

The 'accepted' answer is wrong (as some comments below point out). this modification can make it work:

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

You can use regexp for this:

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

From :

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

Found it to be the best way to do this.

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

Usage:

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

or:

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

Usage:

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

This will solve one more scenario (121.), a dot at end

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

0 12 Next