# How do I check that a number is float or integer?

How to find that a number is `float` or `integer`?

``````1.25 --> float
1 --> integer
0 --> integer
0.25 --> float
``````

check for a remainder when dividing by 1:

``````function isInt(n) {
return n % 1 === 0;
}
``````

If you don't know that the argument is a number you need two tests:

``````function isInt(n){
return Number(n) === n && n % 1 === 0;
}

function isFloat(n){
return Number(n) === n && n % 1 !== 0;
}
``````

Update 2019 5 years after this answer was written, a solution was standardized in ECMA Script 2015. That solution is covered in this answer.

Try these functions to test whether a value is a number primitive value that has no fractional part and is within the size limits of what can be represented as an exact integer.

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

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

Why not something like this:

``````var isInt = function(n) { return parseInt(n) === n };
``````

There is a method called `Number.isInteger()` which is currently implemented in everything but IE. MDN also provides a polyfill for other browsers:

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

However, for most uses cases, you are better off using `Number.isSafeInteger` which also checks if the value is so high/low that any decimal places would have been lost anyway. MDN has a polyfil for this as well. (You also need the `isInteger` pollyfill above.)

``````if (!Number.MAX_SAFE_INTEGER) {
Number.MAX_SAFE_INTEGER = 9007199254740991; // Math.pow(2, 53) - 1;
}
Number.isSafeInteger = Number.isSafeInteger || function (value) {
return Number.isInteger(value) && Math.abs(value) <= Number.MAX_SAFE_INTEGER;
};
``````

You can use a simple regular expression:

``````function isInt(value) {

var er = /^-?[0-9]+\$/;

return er.test(value);
}
``````

Or you can use the below functions too, according your needs. They are developed by the PHPJS Project.

`is_int()` => Check if variable type is integer and if its content is integer

`is_float()` => Check if variable type is float and if its content is float

`ctype_digit()` => Check if variable type is string and if its content has only decimal digits

Update 1

Now it checks negative numbers too, thanks for @ChrisBartley comment!

Here are efficient functions that check if the value is a number or can be safely converted to a number:

``````function isNumber(value) {
if ((undefined === value) || (null === value)) {
return false;
}
if (typeof value == 'number') {
return true;
}
return !isNaN(value - 0);
}
``````

And for integers (would return false if the value is a float):

``````function isInteger(value) {
if ((undefined === value) || (null === value)) {
return false;
}
return value % 1 == 0;
}
``````

The efficiency here is that parseInt (or parseNumber) are avoided when the value already is a number. Both parsing functions always convert to string first and then attempt to parse that string, which would be a waste if the value already is a number.

Thank you to the other posts here for providing further ideas for optimization!

``````function isInteger(x) { return typeof x === "number" && isFinite(x) && Math.floor(x) === x; }
function isFloat(x) { return !!(x % 1); }

// give it a spin

isInteger(1.0);        // true
isFloat(1.0);          // false
isFloat(1.2);          // true
isInteger(1.2);        // false
isFloat(1);            // false
isInteger(1);          // true
isFloat(2e+2);         // false
isInteger(2e+2);       // true
isFloat('1');          // false
isInteger('1');        // false
isFloat(NaN);          // false
isInteger(NaN);        // false
isFloat(null);         // false
isInteger(null);       // false
isFloat(undefined);    // false
isInteger(undefined);  // false
``````

``````function isInt(n)
{
return n != "" && !isNaN(n) && Math.round(n) == n;
}
function isFloat(n){
return n != "" && !isNaN(n) && Math.round(n) != n;
}
``````

works for all cases.

As others mentioned, you only have doubles in JS. So how do you define a number being an integer? Just check if the rounded number is equal to itself:

``````function isInteger(f) {
return typeof(f)==="number" && Math.round(f) == f;
}
function isFloat(f) { return typeof(f)==="number" && !isInteger(f); }
``````

Here's what I use for integers:

``````Math.ceil(parseFloat(val)) === val
``````

Short, nice :) Works all the time. This is what David Flanagan suggests if I'm not mistaken.

``````isFloat(num) {
return typeof num === "number" && !Number.isInteger(num);
}
``````

Any Float number with a zero decimal part (e.g. 1.0, 12.00, 0.0) are implicitly cast to Integer, so it is not possible to check if they are Float or not.

It really depends on what you want to achieve. If you want to "emulate" strongly typed languages then I suggest you not trying. As others mentioned all numbers have the same representation (the same type).

Using something like Claudiu provided:

`isInteger( 1.0 )` -> true

which looks fine for common sense, but in something like C you would get `false`

It really doesn't have to be so complicated. The numeric value of an integer's parseFloat() and parseInt() equivalents will be the same. Thus you can do like so:

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

Then

``````if (isInt(x)) // do work
``````

This will also allow for string checks and thus is not strict. If want a strong type solution (aka, wont work with strings):

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

``````!!(24%1) // false
!!(24.2%1) // true
``````

``````var isInt = function (n) { return n === (n | 0); };
``````

Haven't had a case where this didn't do the job.

THIS IS FINAL CODE FOR CHECK BOTH INT AND FLOAT

``````function isInt(n) {
if(typeof n == 'number' && Math.Round(n) % 1 == 0) {
return true;
} else {
return false;
}
}
``````

OR

``````function isInt(n) {
return typeof n == 'number' && Math.Round(n) % 1 == 0;
}
``````

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

function isFloat(n) {
return ((typeof n==='number')&&(n%1!==0));
}

function isNumber(n) {
return (typeof n==='number');
}
``````

It's simple as:

``````if( n === parseInt(n) ) ...
``````

Try this in console:

``````x=1;
x===parseInt(x); // true
x="1";
x===parseInt(x); // false
x=1.1;
x===parseInt(x); // false, obviously

// BUT!

x=1.0;
x===parseInt(x); // true, because 1.0 is NOT a float!
``````

This confuses a lot of people. Whenever something is .0, it's not a float anymore. It's an integer. Or you can just call it "a numeric thing" for there is no strict distinction like back then in C. Good old times.

So basically, all you can do is check for integer accepting the fact that 1.000 is an integer.

Interesting side note

There was a comment about huge numbers. Huge numbers mean NO problem for this approach; whenever parseInt is unable to handle the number (for it's too big) it will return something else than the actual value so the test will return FALSE. This is a good thing because if you consider something a "number" you normally expect JS to be able to calculate with it - so yes, numbers are limited and parseInt will take this into consideration, to put it this way.

Try this:

``````<script>

var a = 99999999999999999999;
var b = 999999999999999999999; // just one more 9 will kill the show!
var aIsInteger = (a===parseInt(a))?"a is ok":"a fails";
var bIsInteger = (b===parseInt(b))?"b is ok":"b fails";

</script>
``````

In my browser (IE8) this returns "a is ok; b fails" which is exactly because of the huge number in b. The limit may vary but I guess 20 digits "ought to be enough for anybody", to quote a classical :)

This solution worked for me.

``````<html>
<body>
<form method="post" action="#">
<input type="text" id="number_id"/>
<input type="submit" value="send"/>
</form>
<p id="message"></p>
<script>
var flt=document.getElementById("number_id").value;
if(isNaN(flt)==false && Number.isInteger(flt)==false)
{
document.getElementById("message").innerHTML="the number_id is a float ";
}
else
{
document.getElementById("message").innerHTML="the number_id is a Integer";
}
</script>
</body>
</html>
``````

For integers I use this

``````function integer_or_null(value) {
if ((undefined === value) || (null === value)) {
return null;
}
if(value % 1 != 0) {
return null;
}
return value;
}
``````

In java script all the numbers are `internally 64 bit floating point`, same as double in java. There are no diffrent types in javascript, all are represented by type `number`. Hence you wil l not be able make a `instanceof` check. However u can use the above solutions given to find out if it is a fractional number. designers of java script felt with a single type they can avoid numerous type cast errors.

Some times Number objects don't allow you to use direct the mod operator (%), if you are facing that case you can use this solution.

``````if(object instanceof Number ){
if( ((Number) object).doubleValue() % 1 == 0 ){
//your object is an integer
}
else{
//your object is a double
}
}
``````

Trying some of the answers here I ended up writing this solution. This works also with numbers inside a string.

``````function isInt(number) {
if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}\$/.test(number)) return false;
return !(number - parseInt(number));
}

function isFloat(number) {
if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}\$/.test(number)) return false;
return number - parseInt(number) ? true : false;
}
``````

``````    var tests = {
'integer' : 1,
'float' : 1.1,
'integerInString' : '5',
'floatInString' : '5.5',
'negativeInt' : -345,
'negativeFloat' : -34.98,
'negativeIntString' : '-45',
'negativeFloatString' : '-23.09',
'notValidFalse' : false,
'notValidTrue' : true,
'notValidString' : '45lorem',
'notValidStringFloat' : '4.5lorem',
'notValidNan' : NaN,
'notValidObj' : {},
'notValidArr' : [1,2],
};

function isInt(number) {
if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}\$/.test(number)) return false;
return !(number - parseInt(number));
}

function isFloat(number) {
if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}\$/.test(number)) return false;
return number - parseInt(number) ? true : false;
}

function testFunctions(obj) {
var keys = Object.keys(obj);
var values = Object.values(obj);

values.forEach(function(element, index){
console.log(`Is \${keys[index]} (\${element}) var an integer? \${isInt(element)}`);
console.log(`Is \${keys[index]} (\${element}) var a float? \${isFloat(element)}`);
});
}

testFunctions(tests);``````

This maybe isn't as performant as the % answer, which prevents you from having to convert to a string first, but I haven't seen anyone post it yet, so here's another option that should work fine:

``````function isInteger(num) {
return num.toString().indexOf('.') === -1;
}
``````

For those curious, using Benchmark.js I tested the most up-voted answers (and the one posted today) on this post, here are my results:

``````var n = -10.4375892034758293405790;
var suite = new Benchmark.Suite;
suite
// kennebec
return n % 1 == 0;
})
// kennebec
return typeof n === 'number' && n % 1 == 0;
})
// kennebec
return typeof n === 'number' && parseFloat(n) == parseInt(n, 10) && !isNaN(n);
})

// Axle
return n.toString().indexOf('.') === -1;
})

// Dagg Nabbit
return n === +n && n === (n|0);
})

// warfares
return parseInt(n) === n;
})

// Marcio Simao
return /^-?[0-9]+\$/.test(n.toString());
})

// Tal Liron
if ((undefined === n) || (null === n)) {
return false;
}
if (typeof n == 'number') {
return true;
}
return !isNaN(n - 0);
});

// Define logs and Run
suite.on('cycle', function(event) {
console.log(String(event.target));
}).on('complete', function() {
console.log('Fastest is ' + this.filter('fastest').pluck('name'));
}).run({ 'async': true });
``````

``````0 x 12,832,357 ops/sec ±0.65% (90 runs sampled)
1 x 12,916,439 ops/sec ±0.62% (95 runs sampled)
2 x 2,776,583 ops/sec ±0.93% (92 runs sampled)
3 x 10,345,379 ops/sec ±0.49% (97 runs sampled)
4 x 53,766,106 ops/sec ±0.66% (93 runs sampled)
5 x 26,514,109 ops/sec ±2.72% (93 runs sampled)
6 x 10,146,270 ops/sec ±2.54% (90 runs sampled)
7 x 60,353,419 ops/sec ±0.35% (97 runs sampled)

Fastest is 7 Tal Liron
``````

Here's my code. It checks to make sure it's not an empty string (which will otherwise pass) and then converts it to numeric format. Now, depending on whether you want '1.1' to be equal to 1.1, this may or may not be what you're looking for.

``````var isFloat = function(n) {
n = n.length > 0 ? Number(n) : false;
return (n === parseFloat(n));
};
var isInteger = function(n) {
n = n.length > 0 ? Number(n) : false;
return (n === parseInt(n));
};

var isNumeric = function(n){

if(isInteger(n) || isFloat(n)){
return true;
}
return false;

};
``````

I like this little function, which will return true for both positive and negative integers:

``````function isInt(val) {
return ["string","number"].indexOf(typeof(val)) > -1 && val !== '' && !isNaN(val+".0");
}
``````

This works because 1 or "1" becomes "1.0", which isNaN() returns false on (which we then negate and return), but 1.0 or "1.0" becomes "1.0.0", while "string" becomes "string.0", neither of which are numbers, so isNaN() returns false (and, again, gets negated).

If you only want positive integers, there's this variant:

``````function isPositiveInt(val) {
return ["string","number"].indexOf(typeof(val)) > -1 && val !== '' && !isNaN("0"+val);
}
``````

or, for negative integers:

``````function isNegativeInt(val) {
return `["string","number"].indexOf(typeof(val)) > -1` && val !== '' && isNaN("0"+val);
}
``````

isPositiveInt() works by moving the concatenated numeric string ahead of the value to be tested. For example, isPositiveInt(1) results in isNaN() evaluating "01", which evaluates false. Meanwhile, isPositiveInt(-1) results in isNaN() evaluating "0-1", which evaluates true. We negate the return value and that gives us what we want. isNegativeInt() works similarly, but without negating the return value of isNaN().

Edit:

My original implementation would also return true on arrays and empty strings. This implementation doe not have that defect. It also has the benefit of returning early if val is not a string or number, or if it's an empty string, making it faster in these cases. You can further modify it by replacing the first two clauses with

``````typeof(val) != "number"
``````

if you only want to match literal numbers (and not strings)

Edit:

I can't post comments yet, so I'm adding this to my answer. The benchmark posted by @Asok is very informative; however, the fastest function does not fit the requirements, as it also returns TRUE for floats, arrays, booleans, and empty strings.

I created the following test suite to test each of the functions, adding my answer to the list, as well (function 8, which parses strings, and function 9, which does not):

``````funcs = [
function(n) {
return n % 1 == 0;
},
function(n) {
return typeof n === 'number' && n % 1 == 0;
},
function(n) {
return typeof n === 'number' && parseFloat(n) == parseInt(n, 10) && !isNaN(n);
},
function(n) {
return n.toString().indexOf('.') === -1;
},
function(n) {
return n === +n && n === (n|0);
},
function(n) {
return parseInt(n) === n;
},
function(n) {
return /^-?[0-9]+\$/.test(n.toString());
},
function(n) {
if ((undefined === n) || (null === n)) {
return false;
}
if (typeof n == 'number') {
return true;
}
return !isNaN(n - 0);
},
function(n) {
return ["string","number"].indexOf(typeof(n)) > -1 && n !== '' && !isNaN(n+".0");
}
];
vals = [
[1,true],
[-1,true],
[1.1,false],
[-1.1,false],
[[],false],
[{},false],
[true,false],
[false,false],
[null,false],
["",false],
["a",false],
["1",null],
["-1",null],
["1.1",null],
["-1.1",null]
];

for (var i in funcs) {
var pass = true;
console.log("Testing function "+i);
for (var ii in vals) {
var n = vals[ii][0];
var ns;
if (n === null) {
ns = n+"";
} else {
switch (typeof(n)) {
case "string":
ns = "'" + n + "'";
break;
case "object":
ns = Object.prototype.toString.call(n);
break;
default:
ns = n;
}
ns = "("+typeof(n)+") "+ns;
}

var x = vals[ii][1];
var xs;
if (x === null) {
xs = "(ANY)";
} else {
switch (typeof(x)) {
case "string":
xs = "'" + n + "'";
break;
case "object":
xs = Object.prototype.toString.call(x);
break;
default:
xs = x;
}
xs = "("+typeof(x)+") "+xs;
}

var rms;
try {
var r = funcs[i](n);
var rs;
if (r === null) {
rs = r+"";
} else {
switch (typeof(r)) {
case "string":
rs = "'" + r + "'";
break;
case "object":
rs = Object.prototype.toString.call(r);
break;
default:
rs = r;
}
rs = "("+typeof(r)+") "+rs;
}

var m;
var ms;
if (x === null) {
m = true;
ms = "N/A";
} else if (typeof(x) == 'object') {
m = (xs === rs);
ms = m;
} else {
m = (x === r);
ms = m;
}
if (!m) {
pass = false;
}
rms = "Result: "+rs+", Match: "+ms;
} catch (e) {
rms = "Test skipped; function threw exception!"
}

console.log("    Value: "+ns+", Expect: "+xs+", "+rms);
}
console.log(pass ? "PASS!" : "FAIL!");
}
``````

I also reran the benchmark with function #8 added to the list. I won't post the result, as they're a bit embarrassing (e.g. that function is NOT fast)...

The (abridged -- I removed successful tests, since the output is quite long) results are as follows:

``````Testing function 0
Value: (object) [object Array], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) true, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) false, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: null, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
FAIL!

Testing function 1
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 2
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 3
Value: (object) true, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (object) false, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Array], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Object], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: null, Expect: (boolean) false, Test skipped; function threw exception!
Value: (string) '', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) 'a', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
FAIL!

Testing function 4
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 5
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 6
Value: null, Expect: (boolean) false, Test skipped; function threw exception!
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 7
Value: (number) 1.1, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (number) -1.1, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (object) true, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Array], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Object], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) true, Match: N/A
FAIL!

Testing function 8
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 9
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!
``````

I've left in failures so you can see where each function is failing, and the (string) '#' tests so you can see how each function handles integer and float values in strings, as some may want these parsed as numbers and some may not.

Out of the 10 functions tested, the ones that actually fit OP's requirements are [1,3,5,6,8,9]

Condtion for floating validation :

``````if (lnk.value == +lnk.value && lnk.value != (lnk.value | 0))
``````

Condtion for Integer validation :

``````if (lnk.value == +lnk.value && lnk.value == (lnk.value | 0))
``````

Hope this might be helpful.

``````function int(a) {
return a - a === 0 && a.toString(32).indexOf('.') === -1
}

function float(a) {
return a - a === 0 && a.toString(32).indexOf('.') !== -1
}
``````

You can add `typeof a === 'number'` if you want to exclude strings.