¿Cómo verificar si una variable es un número integer en JavaScript?

¿Cómo puedo verificar si una variable es un número integer en JavaScript y lanzar una alerta si no es así? Intenté esto, pero no funciona:

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

30 Solutions collect form web for “¿Cómo verificar si una variable es un número integer en JavaScript?”

Use el operador === ( igualdad estricta ) como se muestra a continuación,

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

Eso depende, ¿también quieres usar cadenas como integers potenciales?

Esto lo hara:

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

Con operaciones Bitwise

Análisis y análisis simples

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

Cortocircuito y save una operación de análisis:

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

O tal vez ambos de una vez:

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

Pruebas:

 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 

Aquí está el violín: http://jsfiddle.net/opfyrqwp/28/

Aquí está el yolpo: http://www.yolpo.com/embed.html?gist=a3c46f837ea7bbb708ae&autoplay=2

Actuación

Las testings revelan que la solución de cortocircuito tiene el mejor 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; } 

Aquí hay un punto de reference: http://jsben.ch/#/htLVw

Si te apetece una forma más corta y obtusa de cortocircuito:

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

Por supuesto, sugeriría dejar que el minificador se encargue de eso.

Suponiendo que no sabe nada sobre la variable en cuestión, debe tomar este enfoque:

 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 } 

Para hacerlo mas simple:

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

Number.isInteger() parece ser el path a seguir.

MDN también ha proporcionado el siguiente rellenado para browseres que no admiten Number.isInteger() , principalmente todas las versiones de IE.

Enlace a la página MDN

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

Puede verificar si el número tiene un residuo:

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

Eso sí, si tu input también puede ser text y quieres verificar primero que no, entonces puedes verificar primero el tipo:

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

Tenga cuidado al usar

num% 1

cadena vacía ('') o booleana (verdadera o falsa) regresará como un integer. Es posible que no quieras hacer eso

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

Number.isInteger (datos)

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

build en function en el browser. Dosnt admite browseres antiguos

Alternativas:

 Math.round(num)=== num 

Sin embargo, Math.round () también fallará para string vacío y boolean

Puedes usar una expresión regular simple:

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

En primer lugar, NaN es un "número" (sí, sé que es raro, simplemente rodar con él), y no una "function".

Necesita verificar si el tipo de la variable es un número, y para verificar el integer yo usaría el module.

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

Para verificar si un integer como el póster quiere:

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

aviso + delante de los datos (convierte cadena en número) y === para exacto.

Aquí hay ejemplos:

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

El estándar ECMA-262 6.0 (ES6) incluye la function Number.isInteger .

Para agregar soporte para el viejo browser, recomiendo usar una solución sólida y compatible con la comunidad desde:

https://github.com/paulmillr/es6-shim

que es una biblioteca de polyfills ES6 JS pura.

Tenga en count que esta lib requiere es5-shim, solo siga README.md.

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

Puedes probar Number.isInteger(Number(value)) si value puede ser un integer en forma de cadena, por ejemplo var value = "23" y quieres que esto se evalúe como true . Evite probar Number.isInteger(parseInt(value)) porque esto no siempre devolverá el valor correcto. por ejemplo, si var value = "23abc" y utiliza la implementación parseInt , aún así devolvería true.

Pero si desea valores estrictamente integers, probablemente Number.isInteger(value) debería hacer el truco.

La solución pre-ECMAScript-6 más simple y limpia (que también es lo suficientemente robusta para devolver falsa, incluso si un valor no numérico como una cadena o un valor nulo se pasa a la function) sería la siguiente:

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

La siguiente solución también funcionaría, aunque no tan elegante como la de arriba:

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

Tenga en count que Math.ceil () o Math.floor () podrían usarse igualmente bien (en lugar de Math.round ()) en la implementación anterior.

O alternativamente:

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

Una solución incorrecta bastante común es la siguiente:

 function isInteger(x) { return parseInt(x, 10) === x; } 

Si bien este enfoque basado en parseInt funcionará bien para muchos valores de x, una vez que x se vuelve bastante grande, no funcionará correctamente. El problema es que parseInt () coacciona su primer parámetro a una cadena antes de analizar los dígitos. Por lo tanto, una vez que el número sea suficientemente grande, su representación de cadena se presentará en forma exponencial (por ejemplo, 1e + 21). En consecuencia, parseInt () intentará analizar 1e + 21, pero dejará de analizar cuando scope el carácter e y, por lo tanto, devolverá un valor de 1. Observe:

 > String(1000000000000000000000) '1e+21' > parseInt(1000000000000000000000, 10) 1 > parseInt(1000000000000000000000, 10) === 1000000000000000000000 false 

Compruebe si la variable es igual a esa misma variable networkingondeada a un integer, como este:

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

Number.isInteger() es la mejor manera si su browser lo admite, de lo contrario, creo que hay muchas maneras de hacerlo:

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

o:

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

o:

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

o:

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

ahora podemos probar los resultados:

 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 

Entonces, todos estos methods son trabajos, pero cuando el número es muy grande, el operador parseInt y ^ no funcionaría bien.

Además, Number.isInteger() . Tal vez Number.isSafeInteger() sea ​​otra opción aquí utilizando el ES6-especificado.

Para Number.isSafeInteger(..) en browseres anteriores a ES6:

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

Puedes usar regexp para esto:

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

Puede usar esta function:

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

Devolverá verdadero incluso si el valor es una cadena que contiene un valor integer.
Entonces, los resultados serán:

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

Desde http://www.toptal.com/javascript/interview-questions :

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

Encontré que es la mejor manera de hacer esto.

Use el | operador:

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

Entonces, una function de testing podría verse así:

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

Esto resolverá un escenario más ( 121. ), un punto al final

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

Para valores integers positivos sin separadores:

 return ( data !== '' && data === data.replace(/\D/, '') ); 

Pruebas 1. si no están vacías y 2. si el valor es igual al resultado de un reemploop de un carácter no digito en su valor.

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

la function isInteger (x) {return (x ^ 0) === x; } La siguiente solución también funcionaría, aunque no tan elegante como la

encima:

la function isInteger (x) {return Math.round (x) === x; } Tenga en count que Math.ceil () o Math.floor () podrían usarse igualmente bien (en lugar de Math.round ()) en la implementación anterior.

O alternativamente: la function es el contenido (x) {retorno (tipo de x === 'número') && (x% 1 === 0); }

Una solución incorrecta bastante común es la siguiente:

la function isInteger (x) {return parseInt (x, 10) === x; }

Si bien este enfoque basado en parseInt funcionará bien para muchos valores de x, una vez que x se vuelve bastante grande, no funcionará correctamente. El problema es que parseInt () coacciona su primer parámetro a una cadena antes de analizar los dígitos. Por lo tanto, una vez que el número sea suficientemente grande, su representación de cadena se presentará en forma exponencial (por ejemplo, 1e + 21). En consecuencia, parseInt () intentará analizar 1e + 21, pero dejará de analizar cuando scope el carácter e y, por lo tanto, devolverá un valor de 1. Observe:

Cadena (1000000000000000000000) '1e + 21'

parseInt (1000000000000000000000, 10) 1

parseInt (1000000000000000000000, 10) === 1000000000000000000000 falso

Tuve que verificar si una variable (cadena o número) es un número integer y utilicé esta condición:

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

http://jsfiddle.net/e267369d/1/

Algunas de las otras respuestas tienen una solución similar (confíe en parseFloat combinado con isNaN ), pero la mía debería ser más directa y autoexplicativa.


Editar: descubrí que mi método falla para las cadenas que contienen coma (como "1,2") y también me di count de que en mi caso particular quiero que la function falle si una cadena no es un integer válido (debe fallar en cualquier flotador) , incluso 1.0). Así que aquí está mi function Mk II:

 function isInt(a){ return !isNaN(a) && parseInt(a) == parseFloat(a) && (typeof a != 'string' || (a.indexOf('.') == -1 && a.indexOf(',') == -1)); } 

http://jsfiddle.net/e267369d/3/

Por supuesto, en caso de que realmente necesite la function para aceptar flotadores integers (1.0 cosas), siempre puede eliminar la condición de punto a.indexOf('.') == -1 .

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

Uso:

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

o:

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

Uso:

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

Lodash https://lodash.com/docs#isInteger (desde 4.0.0) tiene una function para verificar si la variable es un número integer:

 _.isInteger(3); // → true _.isInteger(Number.MIN_VALUE); // → false _.isInteger(Infinity); // → false _.isInteger('3'); // → false 

Después de algunos éxitos y fracasos, se me ocurrió esta solución:

 const isInt = (value) => { return String(parseInt(value, 10)) === String(value) } 

Me gustó la idea anterior de comprobar el valor de no ser NaN y usar parseFloat, pero cuando lo intenté en la infraestructura de React, no funcionó por algún motivo.

Editar: encontré una manera más agradable sin usar cadenas:

 var isInt = function (str) { return str === '0' || !!~~str; } 

Creo que es la respuesta más corta. Tal vez incluso el más eficiente, pero podría ser corregido. 🙂

Funciona para mí. Prueba este …

 $(document).on("input", ".numOnly", function(e) { this.value = this.value.replace(/[^0-9\$]/g,''); }); 

Puede usar la tecla, keyboards, keyboards, etc., en lugar de la input.

Pruebe la siguiente function:

 function isInteger (num) { return num == parseInt(+num,10) && !isNaN(parseInt(num)); } console.log ( isInteger(42)); // true console.log ( isInteger("42")); // true console.log ( isInteger(4e2)); // true console.log ( isInteger("4e2")); // true console.log ( isInteger(" 1 ")); // true console.log ( isInteger("")); // false console.log ( isInteger(" ")); // false console.log ( isInteger(42.1)); // false console.log ( isInteger("1a")); // false console.log ( isInteger("4e2a")); // false console.log ( isInteger(null)); // false console.log ( isInteger(undefined)); // false console.log ( isInteger(NaN)); // false console.log ( isInteger(false)); // false console.log ( isInteger(true)); // false console.log ( isInteger(Infinity)); // false 
Javascript tiene muchos buenos JS marco (como Node.js AngularJS Vue.js React.js) es el mejor lenguaje de script.