How to check if a number is float or integer?-Collection of common programming errors

2 years ago

admin

5 minutes

how to find if a number is float or integer?

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

check a remainder when dividing by 1:

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

If you don’t know that the argument is a number-

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

If you also want to include examples such as 1E308 is a float, and not an integer:

function isInt(n) {
   return typeof n === 'number' && parseFloat(n) == parseInt(n, 10) && !isNaN(n);
} // 6 characters

Try this.

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

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

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!
You can use a simple regular expression:
```
function isInt(value)
{
    var er = /^[0-9]+$/;

    return ( er.test(value) ) ? true : false;
}
```
Or you can use the below functions too, according your needs. They are developed by the PHPJS Project.

is_int() => Check if the variable type is Integer and if its content is Integer

is_float() => Check if the variable type is Float and if its content is Integer

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

Why not something like this:

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

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

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

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

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

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.

Another method is:
```
    function isFloat(float) {
        return /\./.test(float.toString());
    }
```
Might not be as efficient as the others but another method all the same.
```
!!(24%1) // false
!!(24.2%1) // true
```

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

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

float values consists of ., so here we can use indexOf method.

function isInt(number){
    if(number.toString().indexOf(".") > -1)
        return false; // it is float
    else 
        return true; //it is integer
}

The above code is only applicable if the given variable is number. if you are not sure about the type of variable , then do the following before the above code:

//as suggested by @kennebec
function isNumber(number){
    return typeof n === 'number'
}

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

parseInt(yourNumber)=== parseFloat(yourNumber)

Originally posted 2013-11-09 21:01:54.