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

717

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

1.25 --> float  
1 --> integer  
0 --> integer  
0.25 --> float
coure2011
fuente
47
Entiendo lo que está preguntando aquí, pero para ser claros: <nit-pick>JavaScript no tiene diferentes tipos de números enteros y flotantes. Cada número en JavaScript es solo un Number. </nit-pick>
Matt Ball
44
¿Es Infinityun valor entero o no entero en lo que a usted respecta? Las respuestas aquí se distribuyen de manera bastante uniforme en este puntaje.
Mike Samuel
11
@MikeSamuel Para ser matemáticamente exacto: dado que el infinito no es un número real y todos los enteros son números reales, Infinityno puede considerarse un entero.
rvighne
@rvighne, la pregunta se refiere a "flotación", no "real". De cualquier manera, los reales son irrelevantes porque las computadoras solo pueden representar números computables .
Mike Samuel
2
@rvighne, creo que estamos de acuerdo en que el hecho de que los infinitos y NaN no son números reales significa que los flotadores IEEE-754 no son un subconjunto de números reales. Todo análisis numérico basado en IEEE-754 tiene que lidiar con este hecho. Lo que no entiendo es cómo cree que este hecho determina cómo debe comportarse is_integral con las cardinalidades de wrt. Personalmente, creo que ((x% 1) == 0) es un buen proxy y está completamente especificado por IEEE-754, por lo que no hay necesidad de discutir sobre las correspondencias entre diferentes líneas numéricas.
Mike Samuel

Respuestas:

1256

verifique el resto al dividir entre 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;
}

Actualización 2019 5 años después de que se escribió esta respuesta, se estandarizó una solución en ECMA Script 2015. Esa solución se cubre en esta respuesta .

Kennebec
fuente
138
Cuidado, este también volverá cierto para una cadena vacía, una cadena que representa un número entero, true, false, null, una matriz vacía, una matriz que contiene un solo número entero, una matriz que contiene una cadena que representa un número entero, y tal vez más.
Dagg Nabbit
17
Buen truco, pero no es la respuesta correcta, ya que no puede verificar la cadena vacía ""y 1.0 isInt("");&& isInt(1.0);ambos dan como resultado truever esta demostración jsbin.com/elohuq/1/edit
Champ
99
Ina, se recomienda el uso de === sobre == en general, porque conduce a una mayor seguridad de tipo y un comportamiento más predecible y uniforme. Como han respondido los encuestados anteriores, esta respuesta es absolutamente 100% incorrecta. Los valores nulo, cadena vacía, 1.0 y muchos otros se registrarán incorrectamente como enteros (incluso con la comprobación ===).
whoblitz
54
La pregunta era cómo verificar si un número es un entero, no cómo verificar ningún valor.
Kennebec
24
Muchos comentarios hostiles sobre cómo no valida las cadenas. Eso no es parte de la pregunta del OP. Si voy a SO para hacer una pregunta sobre cómo recuperar el último elemento de una matriz y alguien responde function last (array) { return array[array.length - 1]; }, ¿es "simplemente incorrecto" o "La peor respuesta en SO" porque no comprueba si el argumento es una matriz primero? Sí, es una buena práctica verificar los argumentos, pero eso es responsabilidad del desarrollador. Las respuestas SO deben ser breves y responder directamente la pregunta lo más claramente posible.
M Miller
150

Pruebe estas funciones para comprobar si un valor es un valor primitivo numérico que no tiene una parte fraccional y está dentro de los límites de tamaño de lo que se puede representar como un entero exacto.

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

function isInteger(n) {
    return n === +n && n === (n|0);
}
Dagg Nabbit
fuente
55
heh awesom exploit, es más o menos mío ( n===+npara verificar numérico, n|0redondear), pero con operadores integrados. funky
Claudiu
77
@John Hartsock, una cadena nunca será un valor numérico. Es una cuerda. El objetivo de esta función es probar si un valor es un valor numérico de Javascript que no tiene una parte fraccional y está dentro de los límites de tamaño de lo que se puede representar como un entero exacto. Si desea verificar una cadena para ver si contiene una secuencia de caracteres que representan un número, parseFloat()primero debe llamar .
Puntiagudo
44
@ John Hartsock: no devolverá verdadero a menos que se haya pasado un número primitivo. Creo que tiene sentido dados los nombres de las funciones. Cualquier otra cosa debería ser un candidato para isString, isBoolean, etc. si se escriben tales funciones.
Dagg Nabbit
44
@Pointy: los flotantes de doble precisión pueden representar valores enteros exactamente hasta 2 ^ 53. Por lo tanto, depende de si el OP estaba preguntando sobre el entero en el sentido matemático (números enteros) o en el sentido de datos de 32 bits. Si es lo último, su solución es perfecta.
djd
8
en javascript, los operadores bit a bit como |(OR) solo operan en enteros de 32 bits con signo. OP no indica si el objetivo es verificar los valores int32 firmados. Entonces esto no funcionará con números fuera de rango. isInteger(5000000000)volverá lo falseque está mal!
Onur Yıldırım
93

¿Por qué no algo como esto?

var isInt = function(n) { return parseInt(n) === n };
guerras
fuente
Este es realmente el núcleo de una buena solución para mí. Necesitaba permitir enteros positivos y no permitir flotantes, cadenas y enteros negativos.
Imran-UK
44
Esto parece una solución mucho mejor que las otras en este hilo. ¿Podría la comunidad ofrecer algunas críticas, tal vez?
sbichenko
55
var y = 1.00; y === parseInt (y, 10); // esto es cierto para mí, que no es realmente lo que queremos.
whoughton
El único "inconveniente" que veo es que el número dado nse convierte en una cadena por parseInt. Ver MDN . Pero usaré esta solución. :)
RhinoDevel
2
@ekussberg: ¿Por qué eso debería ser falso? 1 es un int. y 02, el segundo argumento, se ignora.
Flimzy
88

Hay un método llamado Number.isInteger()que actualmente se implementa en todo menos en IE. MDN también proporciona un polyfill para otros navegadores:

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

Sin embargo, para la mayoría de los casos de uso, es mejor usar el Number.isSafeInteger que también comprueba si el valor es tan alto / bajo que cualquier lugar decimal se habría perdido de todos modos. MDN también tiene un polyfil para esto. (También necesita el isIntegerpollyfill de arriba).

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) && Math.abs(value) <= Number.MAX_SAFE_INTEGER;
};
paperstreet7
fuente
Esto también funciona en mi Chrome ahora y probablemente sea el camino a seguir en el futuro
Dukeatcoding
1
En mi opinión, la mejor solución.
Automatico
1
Esto con el polyfill es la solución más confiable y simple.
Francesco Pasa
2
@SergeyPanfilov 12.0 ∈ ℤ.
Константин Ван
1
No sé si la especificación ha cambiado desde que se proporcionó esta respuesta, pero tenga en cuenta que la función anterior no es un polyfill correcto para Number.isInteger. Sin embargo, es un polyfill correcto para Number.isSafeInteger. Number.isIntegerno debe verificar si el número es un "entero seguro". Ver en MDN: isInteger y isSafeInteger .
nunocastromartins
33

Puede usar una expresión regular simple:

function isInt(value) {

    var er = /^-?[0-9]+$/;

    return er.test(value);
}

O también puede usar las siguientes funciones, según sus necesidades. Son desarrollados por el Proyecto PHPJS .

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

is_float() => Verifique si el tipo de variable es flotante y si su contenido es flotante

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

Actualización 1

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

Marcio Mazzucato
fuente
1
Perfecto para probar enteros simples sin signo.
tothemario
77
One liner:/^[0-9]+$/.test(String(value))
tothemario
/^[0-9]+$/.test(''+value)
One
3
No maneja enteros negativos. Tampoco necesita el operador ternario ya que test () devuelve un booleano. Esto debería hacerlo:return /^-?\d+$/.test(String(value));
Chris Bartley
@ ChrisBartley, ¡Gracias! Hice una actualización, incluidos sus créditos. Por favor, compruebe si todo está bien ahora.
Marcio Mazzucato
19

Aquí hay funciones eficientes que verifican si el valor es un número o se puede convertir de manera segura a 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 enteros (devolvería falso si el valor es 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 en cadenas primero 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!

Tal Liron
fuente
3
Esta función falla en la cadena vacía: isNumber ('') es verdadero.
Jason Grout
14
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
shime
fuente
44
Aparentemente, los flotantes que terminan con .0 se convierten automáticamente en Int en JavaScript.
fallado con 1.2. Siempre pruebe las funciones numéricas con 0.1 0.2 0.3
Lukas Liesis
@LukasLies no es para mí.
doubleOrt
No hay necesidad de ninguno de los operadores de igualdad estricta aquí.
doubleOrt
isFloat (1563457121531) devuelve falso
Aalex Gabi
9
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.

Deepak Yadav
fuente
2
+1 Esto es bueno. isInt('1')vuelve truecomo se esperaba (al menos para mí). Bastante raro, sin embargo, esto vuelve truea isInt([5])también. No me importó a mí, pero sí a ti, así que ten cuidado.
acdcjunior
2
isFloat (12.0) es falso
django
6

Como otros mencionaron, solo tienes dobles en JS. Entonces, ¿cómo define un número como un número entero? Simplemente verifique 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); }
Claudiu
fuente
3
Es posible que desee comprobar que el valor es numérico ... isFloat('abc')devuelvetrue
Dagg Nabbit
isFloat(NaN) // true
shime
@shime: Buena captura. NaN es técnicamente un número de coma flotante, aunque ... depende del caso de uso, supongo.
Claudiu
6

¿Que tal este?

isFloat(num) {
    return typeof num === "number" && !Number.isInteger(num);
}
Goehybrid
fuente
Pruebe los console.log(isFloat(1.0));resultados falsos.
Fabian Picone
5

Esto es lo que uso para los enteros:

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

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

Arman McHitarian
fuente
Me gusta esta porque es una respuesta corta y simple que no se basa en operaciones crípticas bit a bit.
Jim
¿Por qué parseFloat?
doubleOrt
4

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

Usando algo como lo que Claudiu proporcionó:

isInteger( 1.0 ) -> verdadero

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

gblazex
fuente
4

Cualquier número Float con una parte decimal cero (p. Ej. 1.0, 12.00, 0.0) se convierte implícitamente en Integer, por lo que no es posible verificar si son Float o no.

Mike Mancini
fuente
4
!!(24%1) // false
!!(24.2%1) // true
Виктор Дакалов
fuente
!!(24.0%1)es falso
Rohmer
3

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á verificaciones de cadenas y, por lo tanto, no es estricto. Si desea una solución de tipo fuerte (es decir, no funcionará con cadenas):

function is_int(value){ return !isNaN(parseInt(value * 1) }
SpYk3HH
fuente
isInteger (12.0) es cierto
django
3
var isInt = function (n) { return n === (n | 0); };

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

ankr
fuente
hey perdon por que esto devuelve falso? console.log (isInt (7932938942839482938));
itsme
44
Porque eso excede a MaxInt.
ankr
pero puedes establecer una longitud máxima int nop? ¿Qué pasa si no sé que se devuelve la longitud int?
itsme
1
@ekussberg Sí porque 2es un número entero y 23se considera un segundo argumento para la función. En javascript, los decimales se escriben usando punto como separador, por lo que debería ser así 2.23.
ankr
1
O es una gran oportunidad para aprender sobre operaciones bit a bit. Obtendrá muchos beneficios de eso en adelante.
ankr
2

ESTE ES EL CÓDIGO FINAL PARA VERIFICAR TANTO 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;   
}   
Ken Le
fuente
Esto solo prueba la flotación si n es un número
hacklikecrack
2
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');
}
Vitim.us
fuente
¿Un entero no es un flotador? Noticias para mi.
Maarten Bodewes
2

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. Cada vez que algo es .0, ya no es un flotador. Es un entero. O simplemente puede llamarlo "una cosa numérica", ya que no existe una distinción estricta como en aquel entonces en C. Los viejos tiempos.

Básicamente, todo lo que puede hacer es verificar el número entero aceptando el hecho de que 1,000 es un número entero.

Nota al margen interesante

Hubo un comentario sobre grandes números. Los números enormes no significan ningún problema para este enfoque; cada vez 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á FALSE. Esto es algo bueno porque si considera que algo es un "número", normalmente espera que JS pueda calcular con él, así que sí, los números son limitados y parseInt lo tendrá en cuenta , para decirlo 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", que es exactamente debido al gran número en b. El límite puede variar, pero supongo que 20 dígitos "deberían ser suficientes para cualquiera", por citar un clásico :)

dkellner
fuente
Esto está bien si solo necesita verificar números enteros (desde un punto de vista matemático), pero si desea asegurarse de que realmente funcionen como números enteros (desde un punto de vista informático) será incorrecto para números grandes. Ver este comentario .
Dagg Nabbit
Mmmmmmm ... ¿Por qué piensas eso? Quiero decir, si parseInt devuelve algo y parece igual a la variable en sí, puede estar seguro de que su n realmente funciona como un entero. Descubrí que 99999999999999999999 (es decir, 20 veces "9") es un número, mientras que agregar un "9" más hace que parseInt falle (devuelve 1). Puede depender del navegador; sin embargo, SÍ, hay un límite y NO, lo que esté fuera de ese límite no será válido para la verificación anterior.
dkellner
Lo que quiero decir es que los operadores bit a bit (que tratan los números como entradas de 32 bits) no darán los resultados esperados en números que no pueden representarse como entradas de 32 bits, por lo que esos números no deben identificarse como entradas. Esto está en línea con el funcionamiento de la propuesta Number.isInteger.
Dagg Nabbit
Algo puede ser un verdadero número entero sin ser almacenado de una manera específica. Veo su punto, pero los enteros son enteros porque no tienen una parte fraccionaria y se pueden sumar / restar arbitrariamente sin obtener resultados flotantes. Si trata los números como campos de bits, está suponiendo algo sobre cómo se almacenan, lo cual es, en mi opinión, una forma prácticamente funcional pero no 100% confiable. Si está buscando "un número entero almacenado de cierta manera", bueno, no estoy seguro de que haya una prueba de una sola línea que pueda usar con seguridad en todas las plataformas.
dkellner
Los números que se pueden expresar como entradas de 32 bits funcionan de manera 100% confiable con operadores bit a bit. No estás "suponiendo nada sobre cómo se almacenan"; los números se convierten en enteros complementarios de dos bits big-endian de 32 bits, por especificación Los números que no se pueden representar en este formato no deben considerarse enteros. Nuevamente, esto está en línea con cómo Number.isIntegerfunciona. Una prueba de una sola línea es n === (n | 0)como se muestra en otra respuesta.
Dagg Nabbit
2

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>
Abdelraouf GR
fuente
1

Para enteros uso esto

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

En el script java todos los números son internally 64 bit floating pointiguales al doble en java. No hay tipos diferentes en javascript, todos están representados por tipo number. Por lo tanto, no podrá hacer un instanceofcheque. Sin embargo, puede usar las soluciones anteriores para averiguar si es un número fraccionario. Los diseñadores de Java Script sintieron con un solo tipo que pueden evitar numerosos errores de conversión de tipos.

Punith Raj
fuente
1

Algunas veces, los objetos numéricos no le permiten usar directamente el operador mod (%), 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
   }
}
toddsalpen
fuente
1

Intentando algunas de las respuestas aquí, terminé escribiendo esta solución. Esto funciona también con números dentro de una cadena.

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

Alejandro Hernández
fuente
0

Tal vez esto no sea tan eficaz como el% de respuesta, lo que evita que primero tenga que convertir a una cadena, pero todavía 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;
}
Eje
fuente
Buen enfoque en mi humilde opinión
Sergei Panfilov
Agregaría que el método ES6 incluye () hace que esta respuesta sea aún más simple
Axle
0

Para aquellos curiosos, usando 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
jnthnjns
fuente
0

Aquí está mi código. Comprueba para asegurarse de que no es una cadena vacía (que de lo contrario pasará) y luego la convierte a formato numérico. Ahora, dependiendo de si desea 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;

};
Michael Ryan Soileau
fuente
0

Me gusta esta pequeña función, que devolverá verdadero para los 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 en (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, de nuevo, se niega).

Si solo quieres enteros positivos, existe 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", que evalúa falso. Mientras tanto, isPositiveInt (-1) da como resultado que isNaN () evalúe "0-1", que evalúa 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 el beneficio de regresar temprano si val no es una cadena o número, o si es una cadena vacía, lo que lo hace 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 desea hacer coincidir números literales (y no cadenas)

Editar:

Todavía no puedo publicar comentarios, 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 flotantes, matrices, booleanos y cadenas vacías.

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

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 reescribí el punto de referencia con la función # 8 agregada a la lista. No publicaré el resultado, ya que son un poco vergonzosos (por ejemplo, esa función NO es rápida) ...

Los resultados (abreviado: eliminé las pruebas exitosas, ya que el resultado es bastante largo) 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 en fallas para que pueda ver dónde falla cada función, y el '#' prueba (cadena) para que pueda ver cómo cada función maneja los valores enteros y flotantes en las 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]

KeMBro2012
fuente
0

Condición para 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.

Joe Mike
fuente
0
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.

Mirek Rusin
fuente