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

## The Question :

747 people think this question is useful

How to find that a number is float or integer?

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


• I understand what you’re asking here, but just to be clear: <nit-pick> JavaScript does not have different integer and float numeric types. Every number in JavaScript is just a Number. </nit-pick>
• Is Infinityan integer or a non-integer value as far as you’re concerned? The answers here are pretty evenly distributed on this score.
• @MikeSamuel To be mathematically accurate: since infinity is not a real number and all integers are real numbers, Infinity cannot be considered an integer.
• @rvighne, The question asks about “float”, not “real”. Either way, reals are irrelevant because computers can only represent computable numbers.
• @rvighne, I think we agree that the fact that the infinities and NaN are not real numbers means that IEEE-754 floats are not a subset of real numbers. All numerical analysis based on IEEE-754 has to deal with this fact. What I don’t understand is how you think this fact determines how is_integral should behave w.r.t. cardinalities. Personally, I think ((x % 1) == 0) is a good proxy and is fully specified by IEEE-754, so there’s no need to argue about correspondances between different number lines.

1302 people think this answer is useful

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 &amp;&amp; n % 1 === 0;
}

function isFloat(n){
return Number(n) === n &amp;&amp; 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.

152 people think this answer is useful

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 &amp;&amp; n !== (n|0);
}

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



107 people think this answer is useful

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' &amp;&amp;
isFinite(value) &amp;&amp;
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) &amp;&amp; Math.abs(value) <= Number.MAX_SAFE_INTEGER;
};



92 people think this answer is useful

Why not something like this:

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



32 people think this answer is useful

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! ## The Answer 6 19 people think this answer is useful 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! ## The Answer 7 15 people think this answer is useful function isInteger(x) { return typeof x === "number" &amp;&amp; isFinite(x) &amp;&amp; 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  ## The Answer 8 10 people think this answer is useful function isInt(n) { return n != "" &amp;&amp; !isNaN(n) &amp;&amp; Math.round(n) == n; } function isFloat(n){ return n != "" &amp;&amp; !isNaN(n) &amp;&amp; Math.round(n) != n; }  works for all cases. ## The Answer 9 7 people think this answer is useful How about this one? isFloat(num) { return typeof num === "number" &amp;&amp; !Number.isInteger(num); }  ## The Answer 10 6 people think this answer is useful 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" &amp;&amp; Math.round(f) == f; } function isFloat(f) { return typeof(f)==="number" &amp;&amp; !isInteger(f); }  ## The Answer 11 5 people think this answer is useful 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. ## The Answer 12 4 people think this answer is useful 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 ## The Answer 13 4 people think this answer is useful 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. ## The Answer 14 4 people think this answer is useful !!(24%1) // false !!(24.2%1) // true  ## The Answer 15 3 people think this answer is useful 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)) &amp;&amp; !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) }  ## The Answer 16 3 people think this answer is useful var isInt = function (n) { return n === (n | 0); };  Haven’t had a case where this didn’t do the job. ## The Answer 17 3 people think this answer is useful 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);  ## The Answer 18 2 people think this answer is useful THIS IS FINAL CODE FOR CHECK BOTH INT AND FLOAT function isInt(n) { if(typeof n == 'number' &amp;&amp; Math.Round(n) % 1 == 0) { return true; } else { return false; } }  OR function isInt(n) { return typeof n == 'number' &amp;&amp; Math.Round(n) % 1 == 0; }  ## The Answer 19 2 people think this answer is useful function isInteger(n) { return ((typeof n==='number')&amp;&amp;(n%1===0)); } function isFloat(n) { return ((typeof n==='number')&amp;&amp;(n%1!==0)); } function isNumber(n) { return (typeof n==='number'); }  ## The Answer 20 2 people think this answer is useful 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"; alert(aIsInteger+"; "+bIsInteger); </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 ðŸ™‚ ## The Answer 21 2 people think this answer is useful 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 &amp;&amp; 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>  ## The Answer 22 1 people think this answer is useful 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; }  ## The Answer 23 1 people think this answer is useful 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. ## The Answer 24 1 people think this answer is useful 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 } }  ## The Answer 25 0 people think this answer is useful 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; }  ## The Answer 26 0 people think this answer is useful 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 .add('0', function() { return n % 1 == 0; }) // kennebec .add('1', function() { return typeof n === 'number' &amp;&amp; n % 1 == 0; }) // kennebec .add('2', function() { return typeof n === 'number' &amp;&amp; parseFloat(n) == parseInt(n, 10) &amp;&amp; !isNaN(n); }) // Axle .add('3', function() { return n.toString().indexOf('.') === -1; }) // Dagg Nabbit .add('4', function() { return n === +n &amp;&amp; n === (n|0); }) // warfares .add('5', function() { return parseInt(n) === n; }) // Marcio Simao .add('6', function() { 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



0 people think this answer is useful

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;

};



0 people think this answer is useful

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 &amp;&amp; val !== '' &amp;&amp; !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 &amp;&amp; val !== '' &amp;&amp; !isNaN("0"+val);
}



or, for negative integers:

function isNegativeInt(val) {
return ["string","number"].indexOf(typeof(val)) > -1 &amp;&amp; val !== '' &amp;&amp; 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' &amp;&amp; n % 1 == 0;
},
function(n) {
return typeof n === 'number' &amp;&amp; parseFloat(n) == parseInt(n, 10) &amp;&amp; !isNaN(n);
},
function(n) {
return n.toString().indexOf('.') === -1;
},
function(n) {
return n === +n &amp;&amp; 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 &amp;&amp; n !== '' &amp;&amp; !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]

0 people think this answer is useful

Condtion for floating validation :

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



Condtion for Integer validation :

if (lnk.value == +lnk.value &amp;&amp; lnk.value == (lnk.value | 0))



function int(a) {

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