solo - validar numeros decimales javascript

Validar números decimales en JavaScript-IsNumeric() (30)

¿Cuál es la forma más limpia y efectiva de validar números decimales en JavaScript?

Puntos de bonificación por:

Claridad. La solución debe ser limpia y simple.
Multiplataforma

Casos de prueba:

01. IsNumeric(''-1'') => true 02. IsNumeric(''-1.5'') => true 03. IsNumeric(''0'') => true 04. IsNumeric(''0.42'') => true 05. IsNumeric(''.42'') => true 06. IsNumeric(''99,999'') => false 07. IsNumeric(''0x89f'') => false 08. IsNumeric(''#abcdef'') => false 09. IsNumeric(''1.2.3'') => false 10. IsNumeric('''') => false 11. IsNumeric(''blah'') => false

¡Arrrgh! No escuches las respuestas de expresiones regulares. RegEx es difícil por esto, y no estoy hablando solo de rendimiento. Es tan fácil cometer errores sutiles, imposibles de detectar con tu expresión regular.

Si no puedes usar isNaN() , esto debería funcionar mucho mejor:

function IsNumeric(input) { return (input - 0) == input && (''''+input).trim().length > 0; }

Así es como funciona:

La expresión (input - 0) obliga a JavaScript a realizar coacción de tipo en su valor de entrada; primero debe interpretarse como un número para la operación de resta. Si esa conversión a un número falla, la expresión resultará en NaN . Este resultado numérico se compara con el valor original que se le pasó. Dado que el lado izquierdo ahora es numérico, se usa nuevamente el tipo de coerción. Ahora que la entrada de ambos lados fue forzada al mismo tipo desde el mismo valor original, usted pensaría que siempre deberían ser iguales (siempre cierto). Sin embargo, hay una regla especial que dice que NaN nunca es igual a NaN , por lo que un valor que no se puede convertir en un número (y solo los valores que no se pueden convertir en números) resultará en falso.

La verificación de la longitud es para un caso especial que involucra cadenas vacías. También tenga en cuenta que cae en su prueba 0x89f, pero eso se debe a que en muchos entornos es una buena manera de definir un número literal. Si desea detectar ese escenario específico, puede agregar una verificación adicional. Aún mejor, si esa es la razón por la que no usas isNaN() entonces envuelve tu propia función alrededor de isNaN() que también puede hacer la verificación adicional.

En resumen, si desea saber si un valor se puede convertir en un número, intente convertirlo en un número.

Regresé e investigué un poco por qué una cadena de espacios en blanco no tenía el resultado esperado, y creo que ahora lo entiendo: una cadena vacía se fuerza a 0 lugar de NaN . Simplemente recortar la cadena antes de la verificación de longitud manejará este caso.

Ejecutar las pruebas unitarias contra el nuevo código y solo falla en los infinitos y en los literales booleanos, y el único momento en que debería ser un problema es si estás generando código (en realidad, ¿quién escribiría un literal y verificaría si es numérico? Deberías saberlo , y ese sería un código extraño para generar.

Pero, nuevamente, la única razón para usar esto es si, por alguna razón, tiene que evitar isNaN ().

Aquí hay una versión mejorada (probablemente la forma más rápida de salir) que uso en lugar de la variante jQuery exacta, realmente no sé por qué no usan esta:

function isNumeric(val) { return !isNaN(+val) && isFinite(val); }

La desventaja de la versión de jQuery es que si pasas una cadena con números y letras finales como "123abc" el parseFloat | parseInt parseFloat | parseInt extraerá la fracción numérica y devolverá 123, PERO, la segunda guarda es isFinite , de cualquier forma fallará. Con el operador unario + , morirá en la primera guardia ya que + lanza NaN para tales híbridos :) Un poco de rendimiento, sin embargo, creo que es una ganancia semántica sólida.

Desde jQuery 1.7, puedes usar api.jquery.com/jQuery.isNumeric :

$.isNumeric(''-1''); // true $.isNumeric(''-1.5''); // true $.isNumeric(''0''); // true $.isNumeric(''0.42''); // true $.isNumeric(''.42''); // true $.isNumeric(''0x89f''); // true (valid hexa number) $.isNumeric(''99,999''); // false $.isNumeric(''#abcdef''); // false $.isNumeric(''1.2.3''); // false $.isNumeric(''''); // false $.isNumeric(''blah''); // false

Solo tenga en cuenta que, a diferencia de lo que dijo, 0x89f es un número válido (hexa)

El único problema que tuve con la answer @ CMS es la exclusión de NaN e Infinity, que son números útiles para muchas situaciones. Una forma de verificar los NaN es verificar los valores numéricos que no son iguales, NaN != NaN ¡ NaN != NaN ! Entonces hay 3 pruebas con las que te gustaría lidiar ...

function isNumber(n) { n = parseFloat(n); return !isNaN(n) || n != n; } function isFiniteNumber(n) { n = parseFloat(n); return !isNaN(n) && isFinite(n); } function isComparableNumber(n) { n = parseFloat(n); return (n >=0 || n < 0); } isFiniteNumber(''NaN'') false isFiniteNumber(''OxFF'') true isNumber(''NaN'') true isNumber(1/0-1/0) true isComparableNumber(''NaN'') false isComparableNumber(''Infinity'') true

My isComparableNumber es bastante similar a otra answer elegante, pero maneja representaciones hexadecimales y de otras cadenas de números.

Esta manera parece funcionar bien:

function IsNumeric(input){ var RE = /^-{0,1}/d*/.{0,1}/d+$/; return (RE.test(input)); }

Y para probarlo:

// alert(TestIsNumeric()); function TestIsNumeric(){ var results = '''' results += (IsNumeric(''-1'')?"Pass":"Fail") + ": IsNumeric(''-1'') => true/n"; results += (IsNumeric(''-1.5'')?"Pass":"Fail") + ": IsNumeric(''-1.5'') => true/n"; results += (IsNumeric(''0'')?"Pass":"Fail") + ": IsNumeric(''0'') => true/n"; results += (IsNumeric(''0.42'')?"Pass":"Fail") + ": IsNumeric(''0.42'') => true/n"; results += (IsNumeric(''.42'')?"Pass":"Fail") + ": IsNumeric(''.42'') => true/n"; results += (!IsNumeric(''99,999'')?"Pass":"Fail") + ": IsNumeric(''99,999'') => false/n"; results += (!IsNumeric(''0x89f'')?"Pass":"Fail") + ": IsNumeric(''0x89f'') => false/n"; results += (!IsNumeric(''#abcdef'')?"Pass":"Fail") + ": IsNumeric(''#abcdef'') => false/n"; results += (!IsNumeric(''1.2.3'')?"Pass":"Fail") + ": IsNumeric(''1.2.3'') => false/n"; results += (!IsNumeric('''')?"Pass":"Fail") + ": IsNumeric('''') => false/n"; results += (!IsNumeric(''blah'')?"Pass":"Fail") + ": IsNumeric(''blah'') => false/n"; return results; }

Tomé prestada esa expresión regular de http://www.codetoad.com/javascript/isnumeric.asp . Explicación:

/^ match beginning of string -{0,1} optional negative sign /d* optional digits /.{0,1} optional decimal point /d+ at least one digit $/ match end of string

Esto debería funcionar. Algunas de las funciones proporcionadas aquí son defectuosas, también deberían ser más rápidas que cualquier otra función aquí.

function isNumeric(n) { var n2 = n; n = parseFloat(n); return (n!=''NaN'' && n2==n); }

Explicado:

Cree una copia de sí mismo, luego convierte el número en flotante, luego se compara con el número original, si aún es un número (ya sea entero o flotante), y coincide con el número original, es decir, es un número.

Funciona con cadenas numéricas, así como con números lisos. No funciona con números hexadecimales.

Advertencia: utilizar bajo su propio riesgo, sin garantías.

La respuesta aceptada falló tu prueba # 7 y supongo que es porque cambiaste de opinión. Así que esta es una respuesta a la respuesta aceptada, con la que tuve problemas.

Durante algunos proyectos he necesitado validar algunos datos y estar lo más seguro posible de que es un valor numérico de javascript que se puede usar en operaciones matemáticas.

jQuery y algunas otras bibliotecas de javascript ya incluyen dicha función, generalmente llamada isNumeric . También hay una publicación en que ha sido ampliamente aceptada como la respuesta, la misma rutina general que las bibliotecas mencionadas anteriormente están utilizando.

function isNumber(n) { return !isNaN(parseFloat(n)) && isFinite(n); }

Primero, el código anterior devolvería verdadero si el argumento fuera una matriz de longitud 1, y ese único elemento era de un tipo considerado como numérico por la lógica anterior. En mi opinión, si es una matriz, entonces no es numérica.

Para aliviar este problema, agregué un cheque para descontar arreglos de la lógica

function isNumber(n) { return Object.prototype.toString.call(n) !== ''[object Array]'' &&!isNaN(parseFloat(n)) && isFinite(n); }

Por supuesto, también puede usar Array.isArray , jquery $.isArray o prototype Object.isArray lugar de Object.prototype.toString.call(n) !== ''[object Array]''

Mi segundo problema fue que las cadenas literales enteras hexadecimales negativas ("-0xA" -> -10) no se consideraban numéricas. Sin embargo, las cadenas literales enteras hexadecimales positivas ("0xA" -> 10) se trataron como numéricas. Necesitaba que ambos fueran numéricos válidos.

Luego modifiqué la lógica para tener esto en cuenta.

function isNumber(n) { return Object.prototype.toString.call(n) !== ''[object Array]'' &&!isNaN(parseFloat(n)) && isFinite(n.toString().replace(/^-/, '''')); }

Si está preocupado por la creación de la expresión regular cada vez que se llama a la función, podría reescribirla dentro de un cierre, algo como esto

var isNumber = (function () { var rx = /^-/; return function (n) { return Object.prototype.toString.call(n) !== ''[object Array]'' &&!isNaN(parseFloat(n)) && isFinite(n.toString().replace(rx, '''')); }; }());

Luego tomé CMSs +30 casos de prueba y cloné las pruebas en jsfiddle. Agregué mis casos de prueba adicionales y mi solución descrita anteriormente.

Es posible que no reemplace la respuesta ampliamente aceptada / utilizada, pero si esto es más de lo que espera como resultado de su función isNumeric, entonces espero que esto sea de alguna ayuda.

EDITAR: Como señaló Bergi , hay otros objetos posibles que podrían considerarse numéricos y sería mejor hacer una lista blanca que una lista negra. Con esto en mente me gustaría añadir a los criterios.

Quiero que mi función isNumeric considere solo números o cadenas

Con esto en mente, sería mejor usar

function isNumber(n) { return (Object.prototype.toString.call(n) === ''[object Number]'' || Object.prototype.toString.call(n) === ''[object String]'') &&!isNaN(parseFloat(n)) && isFinite(n.toString().replace(/^-/, '''')); }

Probar las soluciones

Me doy cuenta de que la pregunta original no mencionó jQuery, pero si usas jQuery, puedes hacerlo:

$.isNumeric(val)

Sencillo.

https://api.jquery.com/jQuery.isNumeric/ (a partir de jQuery 1.7)

Mi solución,

function isNumeric(input) { var number = /^/-{0,1}(?:[0-9]+){0,1}(?:/.[0-9]+){0,1}$/i; var regex = RegExp(number); return regex.test(input) && input.length>0; }

Parece funcionar en todas las situaciones, pero podría estar equivocado.

Para mí, esta es la mejor manera:

isNumber : function(v){ return typeof v === ''number'' && isFinite(v); }

Sí, el isNaN(object) será mucho más rápido que cualquier análisis de isNaN(object) regulares, porque está integrado y compilado, en lugar de interpretarse sobre la marcha.

Aunque los resultados son algo diferentes a lo que estás buscando ( pruébalo ):

// IS NUMERIC document.write(!isNaN(''-1'') + "<br />"); // true document.write(!isNaN(''-1.5'') + "<br />"); // true document.write(!isNaN(''0'') + "<br />"); // true document.write(!isNaN(''0.42'') + "<br />"); // true document.write(!isNaN(''.42'') + "<br />"); // true document.write(!isNaN(''99,999'') + "<br />"); // false document.write(!isNaN(''0x89f'') + "<br />"); // true document.write(!isNaN(''#abcdef'') + "<br />"); // false document.write(!isNaN(''1.2.3'') + "<br />"); // false document.write(!isNaN('''') + "<br />"); // true document.write(!isNaN(''blah'') + "<br />"); // false

Se puede hacer sin RegExp como

function IsNumeric(data){ return parseFloat(data)==data; }

Si no me equivoco, este debe coincidir con cualquier valor de número de JavaScript válido, excluyendo las constantes ( Infinity , NaN ) y los operadores de signo + / - (porque en realidad no son parte del número en lo que a mí respecta, son operadores independientes ):

Necesitaba esto para un tokenizer, donde enviar el número a JavaScript para evaluación no era una opción ... Definitivamente no es la expresión regular más corta posible, pero creo que capta todas las sutilezas más finas de la sintaxis numérica de JavaScript.

/^(?:(?:(?:[1-9]/d*|/d)/./d*|(?:[1-9]/d*|/d)?/./d+|(?:[1-9]/d*|/d)) (?:[e]/d+)?|0[0-7]+|0x[0-9a-f]+)$/i

Los números válidos incluirían:

- 0 - 00 - 01 - 10 - 0e1 - 0e01 - .0 - 0. - .0e1 - 0.e1 - 0.e00 - 0xf - 0Xf

Los números inválidos serían

- 00e1 - 01e1 - 00.0 - 00x0 - . - .e0

Un par de pruebas para agregar:

IsNumeric(''01.05'') => false IsNumeric(''1.'') => false IsNumeric(''.'') => false

Se me ocurrió esto:

function IsNumeric(input) { return /^-?(0|[1-9]/d*|(?=/.))(/./d+)?$/.test(input); }

La solución cubre:

Un signo negativo opcional al principio.
Un solo cero, o uno o más dígitos que no comiencen con 0, o nada mientras siga un período
Un período que es seguido por 1 o más números

Un valor entero puede ser verificado por:

function isNumeric(value) { var bool = isNaN(+value)); bool = bool || (value.indexOf(''.'') != -1); bool = bool || (value.indexOf(",") != -1); return !bool; };

¡Así es más fácil y más rápido! Todas las pruebas son revisadas!

Usa la función isNaN . Creo que si haces la prueba para !isNaN(yourstringhere) funciona bien en cualquiera de estas situaciones.

Respuesta de @CMS : su fragmento de código falló en casos de espacios en blanco en mi máquina usando nodejs. Así que lo combiné con la respuesta de @ joel a lo siguiente:

is_float = function(v) { return !isNaN(v) && isFinite(v) && (typeof(v) == ''number'' || v.replace(/^/s+|/s+$/g, '''').length > 0); }

Lo probé con aquellos casos que son flotadores:

var t = [ 0, 1.2123, ''0'', ''2123.4'', -1, ''-1'', -123.423, ''-123.432'', 07, 0xad, ''07'', ''0xad'' ];

y aquellos casos que no son flotantes (incluidos espacios en blanco vacíos y objetos / arrays):

var t = [ ''hallo'', [], {}, ''jklsd0'', '''', "/t", "/n", '' '' ];

Todo funciona como se espera aquí. Tal vez esto ayude.

El código fuente completo para esto se puede encontrar here .

La respuesta de @ Joel es bastante cercana, pero fallará en los siguientes casos:

// Whitespace strings: IsNumeric('' '') == true; IsNumeric(''/t/t'') == true; IsNumeric(''/n/r'') == true; // Number literals: IsNumeric(-1) == false; IsNumeric(0) == false; IsNumeric(1.1) == false; IsNumeric(8e5) == false;

Hace algún tiempo tuve que implementar una función IsNumeric , para averiguar si una variable contenía un valor numérico, independientemente de su tipo , podría ser una String contenga un valor numérico (tuve que considerar también la notación exponencial, etc.), una Number objeto Number , prácticamente cualquier cosa podría pasarse a esa función, no podía hacer suposiciones de tipo, teniendo cuidado de la coacción de tipo (por ejemplo, +true == 1; pero true no debería considerarse como "numeric" ).

Creo que vale la pena compartir este conjunto de pruebas de +30 unidades realizadas para numerosas implementaciones de funciones, y también compartir la que pasa todas mis pruebas:

function isNumeric(n) { return !isNaN(parseFloat(n)) && isFinite(n); }

PS isNaN y isFinite tienen un comportamiento confuso debido a la conversión forzada a número. En ES6, Number.isNaN & Number.isFinite arreglaría estos problemas. Tenlo en cuenta al usarlos.

Actualización : Así es como jQuery lo hace ahora (2.2 estable) :

isNumeric: function(obj) { var realStringObj = obj && obj.toString(); return !jQuery.isArray(obj) && (realStringObj - parseFloat(realStringObj) + 1) >= 0; }

Actualización : Angular 4.3 :

export function isNumeric(value: any): boolean { return !isNaN(value - parseFloat(value)); }

Yahoo! La interfaz de usuario utiliza esto:

isNumber: function(o) { return typeof o === ''number'' && isFinite(o); }

knockoutJs Inbuild funciones de validación de la biblioteca

Al ampliarlo se valida el campo.

1) número

self.number = ko.observable(numberValue) .extend ({number: true}) ;

Caso de prueba

numberValue = ''0.0'' --> true numberValue = ''0'' --> true numberValue = ''25'' --> true numberValue = ''-1'' --> true numberValue = ''-3.5'' --> true numberValue = ''11.112'' --> true numberValue = ''0x89f'' --> false numberValue = '''' --> false numberValue = ''sfsd'' --> false numberValue = ''dg##$'' --> false

2) dígito

self.number = ko.observable(numberValue) .extend ({digit: true}) ;

Caso de prueba

numberValue = ''0'' --> true numberValue = ''25'' --> true numberValue = ''0.0'' --> false numberValue = ''-1'' --> false numberValue = ''-3.5'' --> false numberValue = ''11.112'' --> false numberValue = ''0x89f'' --> false numberValue = '''' --> false numberValue = ''sfsd'' --> false numberValue = ''dg##$'' --> false

3) min y max

self.number = ko.observable(numberValue) .extender ({min: 5}). extender ({max: 10}) ;

Este campo acepta valores entre 5 y 10 solamente.

Caso de prueba

numberValue = ''5'' --> true numberValue = ''6'' --> true numberValue = ''6.5'' --> true numberValue = ''9'' --> true numberValue = ''11'' --> false numberValue = ''0'' --> false numberValue = '''' --> false

Estoy usando una solución más simple:

function isNumber(num) { return parseFloat(num).toString() == num }

Lo siguiente parece funcionar bien para muchos casos:

function isNumeric(num) { return (num > 0 || num === 0 || num === ''0'' || num < 0) && num !== true && isFinite(num); }

Esto se basa en esta respuesta (que también es para esta respuesta): https://.com/a/1561597/1985601

Me doy cuenta de que esto se ha respondido muchas veces, pero el siguiente es un candidato decente que puede ser útil en algunos escenarios.

debe tenerse en cuenta que asume que ''.42'' NO es un número, y ''4''. NO es un número, por lo que debe tenerse en cuenta.

function isDecimal(x) { return '''' + x === '''' + +x; } function isInteger(x) { return '''' + x === '''' + parseInt(x); }

La isDecimalpasa la siguiente prueba:

function testIsNumber(f) { return f(''-1'') && f(''-1.5'') && f(''0'') && f(''0.42'') && !f(''.42'') && !f(''99,999'') && !f(''0x89f'') && !f(''#abcdef'') && !f(''1.2.3'') && !f('''') && !f(''blah''); }

La idea aquí es que cada número o entero tiene una representación de cadena "canónica", y toda representación no canónica debe ser rechazada. Así que hacemos una conversión a un número y viceversa, y vemos si el resultado es la cadena original.

Si estas funciones son útiles para usted depende del caso de uso. Una característica es que las cadenas distintas representan números distintos (si ambas pasan la isNumber()prueba).

Esto es relevante, por ejemplo, para números como nombres de propiedades de objetos.

var obj = {}; obj[''4''] = ''canonical 4''; obj[''04''] = ''alias of 4''; obj[4]; // prints ''canonical 4'' to the console.

Me gustaría añadir lo siguiente:

1. IsNumeric(''0x89f'') => true 2. IsNumeric(''075'') => true

Los números hexadecimales positivos comienzan con 0xy los números hexadecimales negativos comienzan con -0x. Los números de oct. Positivos comienzan con 0y los números de oct negativo comienzan con -0. Éste toma en consideración la mayor parte de lo que ya se ha mencionado, pero incluye números hexadecimales y octales, negativo científico, Infinito y ha eliminado el decimal científico ( 4e3.2no es válido).

function IsNumeric(input){ var RE = /^-?(0|INF|(0[1-7][0-7]*)|(0x[0-9a-fA-F]+)|((0|[1-9][0-9]*|(?=[/.,]))([/.,][0-9]+)?([eE]-?/d+)?))$/; return (RE.test(input)); }

Puede minimizar esta función de muchas maneras, y también puede implementarla con una expresión regular personalizada para valores negativos o gráficos personalizados:

$(''.number'').on(''input'',function(){ var n=$(this).val().replace(/ /g,'''').replace(//D/g,''''); if (!$.isNumeric(n)) $(this).val(n.slice(0, -1)) else $(this).val(n) });

Ninguna de las respuestas vuelve falsepara cadenas vacías, una solución para eso ...

function is_numeric(n) { return (n != '''' && !isNaN(parseFloat(n)) && isFinite(n)); }

Para verificar si una variable contiene un número válido y no solo una cadena que se parece a un número, Number.isFinite(value)se puede usar.

Esto es parte del lenguaje desde ES2015

Ejemplos:

Number.isFinite(Infinity) // false Number.isFinite(NaN) // false Number.isFinite(-Infinity) // false Number.isFinite(0) // true Number.isFinite(2e64) // true Number.isFinite(''0'') // false Number.isFinite(null) // false

function IsNumeric(num) { return (num >=0 || num < 0); }

Esto funciona para números de tipo 0x23 también.

function inNumeric(n){ return Number(n).toString() === n; }

Si n es numérico Number(n)devolverá el valor numérico y toString()lo convertirá de nuevo en una cadena. Pero si n no es numérico Number(n), volverá NaNpara que no coincida con el originaln

return (input - 0) == input && input.length > 0;

no funciono para mi Cuando puse una alerta y probé, input.length estaba undefined . Creo que no hay ninguna propiedad para verificar la longitud del número entero. Así que lo que hice fue

var temp = '''' + input; return (input - 0) == input && temp.length > 0;

Funcionó bien