parse - replace javascript
¿Cómo verificar si una variable es un entero en JavaScript? (30)
¿Por qué nadie ha mencionado Number.isInteger() ?
Funciona perfectamente para mí y resuelve el problema con el NaN comenzando un número.
¿Cómo verifico si una variable es un número entero en JavaScript y emito una alerta si no lo es? Intenté esto, pero no funciona:
<html>
<head>
<script type="text/javascript">
var data = 22;
alert(NaN(data));
</script>
</head>
</html>
Además, Number.isInteger() . Quizás Number.isSafeInteger() es otra opción here usando el ES6-especificado.
Para hacer un polyfill Number.isSafeInteger(..) en los navegadores pre-ES6:
Number.isSafeInteger = Number.isSafeInteger || function(num) {
return typeof num === "number" &&
isFinite(num) &&
Math.floor(num) === num &&
Math.abs( num ) <= Number.MAX_SAFE_INTEGER;
};
Compruebe si la variable es igual a esa misma variable redondeada a un entero, como esto:
if(Math.round(data) != data) {
alert("Variable is not an integer!");
}
Desde http://www.toptal.com/javascript/interview-questions :
function isInteger(x) { return (x^0) === x; }
Encontré que es la mejor manera de hacer esto.
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 verificar el valor de no ser NaN y usar parseFloat, pero cuando lo probé en la infraestructura React no funcionó por alguna razón.
Edición: 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. :)
El estándar ECMA-262 6.0 (ES6) incluye la función Number.isInteger .
Para agregar soporte para el navegador antiguo, recomiendo usar una solución sólida y compatible con la comunidad de:
https://github.com/paulmillr/es6-shim
que es puro ES6 JS polyfills biblioteca .
Tenga en cuenta que esta biblioteca requiere es5-shim, simplemente siga README.md.
En primer lugar, NaN es un "número" (sí, sé que es raro, solo tira con él), y no una "función".
Debe verificar tanto si el tipo de la variable es un número, y para verificar el número entero, yo usaría módulo.
alert(typeof data === ''number'' && data%1 == 0);
Eso depende, ¿también quieres lanzar cadenas como enteros potenciales también?
Esto lo hara:
function isInt(value) {
return !isNaN(value) &&
parseInt(Number(value)) == value &&
!isNaN(parseInt(value, 10));
}
Con operaciones bitwise
Parse simple y cheque
function isInt(value) {
var x = parseFloat(value);
return !isNaN(value) && (x | 0) === x;
}
Cortocircuito y guardar 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 en una sola toma:
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/
Actuación
Las pruebas revelan que la solución de cortocircuito tiene el mejor rendimiento (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 referencia: 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, sugiero dejar que el minificador se encargue de eso.
Esta solución funcionará para todos los navegadores.
1. Convierta su número en una cadena, por ejemplo, 123 => Cadena (123)
2. Verifique si hay algún (punto) disponible en una cadena dada o no utilizando la función indexOf de cadena.
"123" .indexOf (".") => -1 // entero
"123.1" .indexOf (".") => 3 // no entero
O
Utilice la función de abajo
function isInt(val) {
return String(val).indexOf(''.'') === -1;
}
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;
}
La solución pre-ECMAScript-6 más simple y limpia (que también es lo suficientemente robusta para devolver falso incluso si se pasa un valor no numérico como una cadena o un nulo a la función) 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 anterior:
function isInteger(x) { return Math.round(x) === x; }
Tenga en cuenta que Math.ceil () o Math.floor () se podrían usar 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 sea bastante grande, no funcionará correctamente. El problema es que parseInt () convierte su primer parámetro en una cadena antes de analizar los dígitos. Por lo tanto, una vez que el número sea lo 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 alcance 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
Lodash https://lodash.com/docs#isInteger (desde 4.0.0) tiene una función para verificar si la variable es un entero:
_.isInteger(3);
// → true
_.isInteger(Number.MIN_VALUE);
// → false
_.isInteger(Infinity);
// → false
_.isInteger(''3'');
// → false
Ok, tengo menos, porque no describí mi ejemplo, así que más ejemplos :):
Yo uso la expresión regular y el método de prueba:
var isInteger = /^[0-9]/d*$/;
isInteger.test(123); //true
isInteger.test(''123''); // true
isInteger.test(''sdf''); //false
isInteger.test(''123sdf''); //false
// If u want to avoid string value:
typeof testVal !== ''string'' && isInteger.test(testValue);
Para comprobar si el entero como el cartel quiere:
if (+data===parseInt(data)) {return true} else {return false}
note + delante de los datos (convierte la cadena en número), y === para la exacta.
Aquí hay algunos ejemplos:
data=10
+data===parseInt(data)
true
data="10"
+data===parseInt(data)
true
data="10.2"
+data===parseInt(data)
false
Para valores enteros 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 una sustitución de un carácter sin dígitos en su valor.
Podrías comprobar si el número tiene un resto:
var data = 22;
if(data % 1 === 0){
// yes it''s an integer.
}
Tenga en cuenta que si su entrada también puede ser texto y desea verificar primero que no lo es, entonces puede verificar primero el tipo:
var data = 22;
if(typeof data === ''number''){
// yes it is numeric
if(data % 1 === 0){
// yes it''s an integer.
}
}
Podrías usar esta función:
function isInteger(value) {
return (value == parseInt(value));
}
Devolverá verdadero incluso si el valor es una cadena que contiene un valor entero.
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
Puede probar Number.isInteger(Number(value)) si el value puede ser un entero en forma de cadena, por ejemplo, var value = "23" y desea que esto se evalúe como true . Evite intentar Number.isInteger(parseInt(value)) porque esto no siempre devolverá el valor correcto. por ejemplo, si var value = "23abc" y usa la implementación parseInt , todavía devolverá true.
Pero si desea valores estrictamente enteros, probablemente Number.isInteger(value) debería hacer el truco.
Puedes usar regexp para esto:
function isInteger(n) {
return (typeof n == ''number'' && /^-?/d+$/.test(n+''''));
}
Puedes usar una expresión regular simple:
function isInt(value) {
var er = /^-?[0-9]+$/;
return er.test(value);
}
Suponiendo que no sepa nada sobre la variable en cuestión, debe adoptar 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
}
Tuve que verificar si una variable (cadena o número) es un número entero y usé 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.
Edición: descubrí que mi método falla para cadenas que contienen comas (como "1,2") y también me di cuenta de que en mi caso particular quiero que la función falle si una cadena no es un número entero válido (debería fallar en cualquier flotante , incluso 1.0). Así que aquí está mi función 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 función para aceptar flotadores de enteros (1.0 cosas), siempre puede eliminar la condición de punto a.indexOf(''.'') == -1 .
Utilice 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")
Utilizar el | operador:
(5.3 | 0) === 5.3 // => false
(5.0 | 0) === 5.0 // => true
Por lo tanto, una función de prueba podría verse así:
var isInteger = function (value) {
if (typeof value !== ''number'') {
return false;
}
if ((value | 0) !== value) {
return false;
}
return true;
};
Number.isInteger() es la mejor manera si su navegador lo admite, si no, 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
Por lo tanto, todos estos métodos son trabajos, pero cuando el número es muy grande, parseInt y ^ operator no funcionan bien.
Number.isInteger() parece ser el camino a seguir.
MDN también ha proporcionado el siguiente polyfill para los navegadores que no admiten Number.isInteger() , principalmente todas las versiones de IE.
Number.isInteger = Number.isInteger || function(value) {
return typeof value === "number" &&
isFinite(value) &&
Math.floor(value) === value;
};
Tenga cuidado al usar
num% 1
La cadena vacía ('''') o boolean (verdadero o falso) se devolverá como entero. Puede 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
construir en función en el navegador. Dosnt soporta navegadores antiguos
Alternativas:
Math.round(num)=== num
Sin embargo, Math.round () también fallará para una cadena vacía y un valor booleano
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>
if(Number.isInteger(Number(data))){
//-----
}
var x = 1.5;
if(!isNaN(x)){
console.log(''Number'');
if(x % 1 == 0){
console.log(''Integer'');
}
}else {
console.log(''not a number'');
}