javascript - change - ¿Cómo verifico que un número sea flotante o entero?

change title javascript

Question

¿Cómo encontrar que un número es float o integer ?

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

Answer 1

¿Por qué no algo como esto?

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

Answer 2

Aquí está mi código. Comprueba que no sea una cadena vacía (que de lo contrario pasará) y luego la convierte en formato numérico. Ahora, dependiendo de si quiere que ''1.1'' sea igual a 1.1, esto puede o no ser lo que está buscando.

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

Answer 3

Aquí hay funciones eficientes que verifican si el valor es un número o se puede convertir de manera segura en un número:

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

Y para los enteros (devolvería false si el valor es un valor flotante):

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

La eficiencia aquí es que parseInt (o parseNumber) se evitan cuando el valor ya es un número. Ambas funciones de análisis siempre se convierten primero en cadena y luego intentan analizar esa cadena, lo que sería un desperdicio si el valor ya es un número.

¡Gracias a las otras publicaciones aquí por proporcionar más ideas para la optimización!

Answer 4

Como han mencionado otros, solo tienes dobles en JS. Entonces, ¿cómo se define un número que es un número entero? Solo verifica si el número redondeado es igual a sí mismo:

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

Answer 5

Compruebe si hay un resto al dividir por 1:

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

Si no sabe que el argumento es un número, necesita dos pruebas:

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

Answer 6

Cualquier número de Flotante con una parte decimal cero (por ejemplo, 1.0, 12.00, 0.0) se convierte implícitamente a Entero, por lo que no es posible verificar si son Flotante o no.

Answer 7

ESTE ES EL CÓDIGO FINAL PARA COMPROBAR AMBOS INT Y FLOTADOR

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

O

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

Answer 8

En el script java, todos los números son internally 64 bit floating point , igual que el doble en java. No hay diferentes tipos en javascript, todos están representados por number tipo. Por lo tanto, no podré hacer una instanceof verificación. Sin embargo, puedes usar las soluciones anteriores para averiguar si es un número fraccional. los diseñadores de java script se sintieron con un solo tipo y pueden evitar numerosos errores de conversión.

Answer 9

Es simple como:

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

Prueba esto en la consola:

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!

Esto confunde a mucha gente. Cuando algo es .0, ya no es un flotador. Es un entero. O simplemente puede llamarlo "una cosa numérica" ​​porque no hay una distinción estricta como en ese entonces en C. Los viejos tiempos.

Básicamente, todo lo que puede hacer es verificar si el entero acepta el hecho de que 1.000 es un entero.

Nota interesante

Hubo un comentario sobre grandes números. Los números enormes no significan ningún problema para este enfoque; siempre que parseInt no pueda manejar el número (porque es demasiado grande) devolverá algo más que el valor real, por lo que la prueba devolverá FALSO. Esto es bueno porque si considera algo como un "número", normalmente espera que JS pueda calcularlo, así que sí, los números son limitados y ParseInt tomará esto en cuenta para ponerlo de esta manera.

Prueba esto:

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

En mi navegador (IE8) esto devuelve "a está bien; b falla", lo cual se debe exactamente a la gran cantidad de b. El límite puede variar pero supongo que 20 dígitos "deberían ser suficientes para cualquiera", para citar un clásico :)

Answer 10

Escribí una función que acepta cadenas (si alguien necesita)

function isInt(x) {
return !isNaN(x) && eval(x).toString().length == parseInt(eval(x)).toString().length
}
function isFloat(x) {
return !isNaN(x) && !isInt(eval(x)) && x.toString().length > 0
}

Ouptuts de ejemplo:

console.log(isFloat(''0.2'')) // true
console.log(isFloat(0.2)) // true
console.log(isFloat(''.2'')) // true
console.log(isFloat(''-.2'')) // true
console.log(isFloat(-''.2'')) // true
console.log(isFloat(-.2)) // true
console.log(isFloat(''u.2'')) // false
console.log(isFloat(''2'')) // false
console.log(isFloat(''0.2u'')) // false
console.log(isInt(''187'')) // true
console.log(isInt(187)) // true
console.log(isInt(''1.2'')) // false
console.log(isInt(''-2'')) // true
console.log(isInt(-''1'')) // true
console.log(isInt(''10e1'')) // true
console.log(isInt(10e1)) // true

Answer 11

Esta solución funcionó para mí.

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

Answer 12

Esto es lo que uso para los enteros:

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

Corto, bonito :) Funciona todo el tiempo. Esto es lo que sugiere David Flanagan si no me equivoco.

Answer 13

Existe un método llamado Number.isInteger() que actualmente se implementa solo en la última versión de Firefox y aún es parte de la propuesta de EcmaScript 6. Sin embargo, MDN proporciona un polyfill para los otros navegadores, que coincide con el especificado en la armonía de ECMA:

if (!Number.isInteger) {
Number.isInteger = function isInteger (nVal) {
return typeof nVal === "number" && isFinite(nVal) && nVal > -9007199254740992 && nVal < 9007199254740992 && Math.floor(nVal) === nVal;
};
}

Answer 14

Me gusta esta pequeña función, que devolverá true para enteros positivos y negativos:

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

Esto funciona porque 1 o "1" se convierte en "1.0", que esNaN () devuelve falso (que luego negamos y devolvemos), pero 1.0 o "1.0" se convierte en "1.0.0", mientras que "cadena" se convierte en "cadena". 0 ", ninguno de los cuales son números, por lo que isNaN () devuelve falso (y, nuevamente, se niega).

Si solo quieres enteros positivos, hay esta variante:

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

o, para enteros negativos:

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

isPositiveInt () funciona moviendo la cadena numérica concatenada por delante del valor a probar. Por ejemplo, isPositiveInt (1) da como resultado que isNaN () evalúe "01", lo que se evalúa como falso. Mientras tanto, isPositiveInt (-1) da como resultado que isNaN () evalúe "0-1", lo que se evalúa como verdadero. Negamos el valor de retorno y eso nos da lo que queremos. isNegativeInt () funciona de manera similar, pero sin negar el valor de retorno de isNaN ().

Editar:

Mi implementación original también devolvería verdadero en matrices y cadenas vacías. Esta implementación no tiene ese defecto. También tiene la ventaja de regresar temprano si val no es una cadena o un número, o si es una cadena vacía, haciéndolo más rápido en estos casos. Puede modificarlo aún más reemplazando las dos primeras cláusulas con

typeof(val) != "number"

si solo quieres hacer coincidir números literales (y no cadenas)

Editar:

No puedo publicar comentarios todavía, así que estoy agregando esto a mi respuesta. El punto de referencia publicado por @Asok es muy informativo; sin embargo, la función más rápida no cumple con los requisitos, ya que también devuelve VERDADERO para flotadores, matrices, booleanos y cadenas vacías.

Creé el siguiente conjunto de pruebas para probar cada una de las funciones, y también agregué mi respuesta a la lista (función 8, que analiza cadenas, y función 9, que no lo hace):

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

También repito la prueba con la función # 8 agregada a la lista. No publicaré el resultado, ya que son un poco embarazosos (por ejemplo, esa función NO es rápida) ...

Los resultados (resumidos: eliminé las pruebas exitosas, ya que la salida es bastante larga) son los siguientes:

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!

He dejado fallas para que pueda ver dónde falla cada función, y las pruebas (cadena) ''#'' para ver cómo cada función maneja los valores enteros y flotantes en cadenas, ya que algunos pueden querer analizarlos como números y otros podría no.

De las 10 funciones probadas, las que realmente cumplen con los requisitos de OP son [1,3,5,6,8,9]

Answer 15

Para aquellos curiosos, utilizando Benchmark.js, probé las respuestas más votadas (y la publicada hoy) en esta publicación, aquí están mis resultados:

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'' && n % 1 == 0;
})
// kennebec
.add(''2'', function() {
return typeof n === ''number'' && parseFloat(n) == parseInt(n, 10) && !isNaN(n);
})
// Axle
.add(''3'', function() {
return n.toString().indexOf(''.'') === -1;
})
// Dagg Nabbit
.add(''4'', function() {
return n === +n && n === (n|0);
})
// warfares
.add(''5'', function() {
return parseInt(n) === n;
})
// Marcio Simao
.add(''6'', function() {
return /^-?[0-9]+$/.test(n.toString());
})
// Tal Liron
.add(''7'', function() {
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

Answer 16

Para enteros yo uso este

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

Answer 17

Pruebe estas funciones para probar si un valor es un valor primitivo numérico que no tiene una parte fraccionaria y está dentro de los límites de tamaño de lo que puede representarse como un número entero exacto.

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

Answer 18

Puedes usar una expresión regular simple:

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

O también puede utilizar las siguientes funciones, según sus necesidades. Están desarrollados por el Proyecto PHPJS .

is_int() => Verifique si el tipo de variable es entero y si su contenido es entero

is_float() => Comprueba si el tipo de variable es float y si su contenido es float

is_float() => Compruebe si el tipo de variable es una cadena y si su contenido tiene solo dígitos decimales

Actualización 1

Ahora también verifica los números negativos, gracias por el comentario de @ChrisBartley .

Answer 19

Realmente depende de lo que quieras lograr. Si quieres "emular" lenguajes fuertemente tipados, te sugiero que no lo intentes. Como otros mencionaron, todos los números tienen la misma representación (el mismo tipo).

Usando algo como Claudiu proporcionó:

isInteger( 1.0 ) -> true

que se ve bien para el sentido común, pero en algo como C obtendrías false

Answer 20

Realmente no tiene que ser tan complicado. El valor numérico de los equivalentes parseFloat () y parseInt () de un entero será el mismo. Así puedes hacer así:

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

Entonces

if (isInt(x)) // do work

Esto también permitirá la verificación de cadenas y por lo tanto no es estricto. Si desea una solución de tipo fuerte (alias, no funciona con cadenas):

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

Answer 21

Tal vez no sea tan eficaz como el% de respuesta, lo que evita que tengas que convertirte primero a una cadena, pero aún no he visto a nadie publicarlo, así que aquí hay otra opción que debería funcionar bien:

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

Answer 22

YourJS proporciona las siguientes dos funciones que funcionan para todos los números, incluido el retorno falsepara -Infinityy Infinity:

function isFloat(x) {
return typeOf(x, ''Number'') && !!(x % 1);
}
function isInt(x) {
return typeOf(x, ''Number'') && x % 1 == 0;
}

Debido al hecho de que typeOf()es una función interna de YourJS, si desea usar estas definiciones, puede descargar la versión de estas funciones aquí: http://yourjs.com/snippets/build/34

Answer 23

Condición para la validación flotante:

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

Condición para la validación de enteros:

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

Espero que esto pueda ser útil.

Answer 24

Algunas veces, los objetos numéricos no le permiten usar el operador mod directo (%), si se enfrenta a ese caso, puede usar esta solución.

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

Answer 25

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

Answer 26

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

Puede agregar typeof a === ''number''si desea excluir cadenas.

Answer 27

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

Funciona para todos los casos.

Answer 28

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

Answer 29

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

Answer 30

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

No he tenido un caso donde esto no hizo el trabajo.