Regex para verificar si una cadena contiene solo números

hash = window.location.hash.substr(1); var reg = new RegExp('^[0-9]$'); console.log(reg.test(hash)); 

Me sale falso en ambos "123" y "123f" . Me gustaría comprobar si el hash solo contiene números. ¿Me he perdido algo?

 var reg = /^\d+$/; 

Deberías hacerlo. El original coincide con cualquier cosa que consta exactamente de un dígito.

Como dijiste, quieres que el hash contenga solo números.

 var reg = new RegExp('^[0-9]+$'); 

o

 var reg = new RegExp('^\\d+$'); 

\d y [0-9] ambos significan lo mismo. El + usado significa que busca uno o más de los que ocurren de [0-9].

Este permitirá también para los números firmados y float o cadena vacía:

 var reg = /^-?\d*\.?\d*$/ 

Si no quiere permitir que se vacíe la cadena, use esta:

 var reg = /^-?\d+\.?\d*$/ 
 var validation = { isEmailAddress:function(str) { var pattern =/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/; return pattern.test(str); // returns a boolean }, isNotEmpty:function (str) { var pattern =/\S+/; return pattern.test(str); // returns a boolean }, isNumber:function(str) { var pattern = /^\d+$/; return pattern.test(str); // returns a boolean }, isSame:function(str1,str2){ return str1 === str2; } }; alert(validation.isNotEmpty("dff")); alert(validation.isNumber(44)); alert(validation.isEmailAddress("mf@tl.ff")); alert(validation.isSame("sf","sf")); 

Esto es extremadamente exagerado para su propósito, pero esto es lo que uso:

 var numberReSnippet = "(?:NaN|-?(?:(?:\\d+|\\d*\\.\\d+)(?:[E|e][+|-]?\\d+)?|Infinity))"; var matchOnlyNumberRe = new RegExp("^("+ numberReSnippet + ")$"); 

Que yo sepa, esto coincide con todas las variaciones en los números que Java y JavaScript le lanzarán alguna vez, incluyendo “-Infinito”, “1e-24” y “NaN”. También coincide con los números que podría escribir, como “-.5”.

Tal como está escrito, reSnippet está diseñado para colocarse en otras expresiones regulares, por lo que puede extraer (o evitar) números. A pesar de todos los paréntesis, no contiene grupos de captura. Por lo tanto, “matchOnlyNumberRe” solo coincide con cadenas que son números, y tiene un grupo de captura para toda la cadena.

Aquí están las pruebas de Jasmine, para que pueda ver lo que hace y lo que no maneja:

 describe("Number Regex", function() { var re = new RegExp("^("+ numberReSnippet + ")$"); it("Matches Java and JavaScript numbers", function() { expect(re.test( "1")).toBe(true); expect(re.test( "0.2")).toBe(true); expect(re.test( "0.4E4")).toBe(true); // Java-style expect(re.test( "-55")).toBe(true); expect(re.test( "-0.6")).toBe(true); expect(re.test( "-0.77E77")).toBe(true); expect(re.test( "88E8")).toBe(true); expect(re.test( "NaN")).toBe(true); expect(re.test( "Infinity")).toBe(true); expect(re.test( "-Infinity")).toBe(true); expect(re.test( "1e+24")).toBe(true); // JavaScript-style }); it("Matches fractions with a leading decimal point", function() { expect(re.test( ".3")).toBe(true); expect(re.test( "-.3")).toBe(true); expect(re.test( ".3e-4")).toBe(true); }); it("Doesn't match non-numbers", function() { expect(re.test( ".")).toBe(false); expect(re.test( "9.")).toBe(false); expect(re.test( "")).toBe(false); expect(re.test( "E")).toBe(false); expect(re.test( "e24")).toBe(false); expect(re.test( "1e+24.5")).toBe(false); expect(re.test("-.Infinity")).toBe(false); }); }); 
 ^[0-9]$ 

… es una expresión regular que coincide con cualquier dígito, por lo que 1 regresará verdadero, pero 123 devolverá falso.

Si agrega el * cuantificador,

 ^[0-9]*$ 

la expresión coincidirá con cadenas de longitud arbitraria de dígitos y 123 devolverá verdadero. (123f aún devolverá falso).

Tenga en cuenta que, técnicamente, una cadena vacía es una cadena de dígitos de 0 longitudes, por lo que volverá a ser verdadera con ^ [0-9] * $. Si solo quiere aceptar cadenas que contienen 1 o más dígitos, use + en lugar de *

 ^[0-9]+$ 

Como han señalado muchos otros, hay más que unas pocas formas de lograr esto, pero sentí que era apropiado señalar que el código en la pregunta original solo requiere un único carácter adicional para funcionar como se esperaba.

Esta función comprueba si su entrada es numérica en el sentido clásico, ya que uno espera que funcione una función de detección de número normal.

Es una prueba que se puede usar para la entrada de formularios HTML, por ejemplo.

Pasa por alto todo el folclore de JS, como tipeof (NaN) = number, parseint (‘1 Kg’) = 1, booleanos coaccionados en números y cosas por el estilo.

Lo hace representando el argumento como una cadena y comprobando esa cadena contra una expresión regular como las de @codename, pero permitiendo entradas como 5. y .5

 function isANumber( n ) { var numStr = /^-?(\d+\.?\d*)$|(\d*\.?\d+)$/; return numStr.test( n.toString() ); } not numeric: Logger.log( 'isANumber( "aaa" ): ' + isANumber( 'aaa' ) ); Logger.log( 'isANumber( "" ): ' + isANumber( '' ) ); Logger.log( 'isANumber( "lkjh" ): ' + isANumber( 'lkjh' ) ); Logger.log( 'isANumber( 0/0 ): ' + isANumber( 0 / 0 ) ); Logger.log( 'isANumber( 1/0 ): ' + isANumber( 1 / 0 ) ); Logger.log( 'isANumber( "1Kg" ): ' + isANumber( '1Kg' ) ); Logger.log( 'isANumber( "1 Kg" ): ' + isANumber( '1 Kg' ) ); Logger.log( 'isANumber( false ): ' + isANumber( false ) ); Logger.log( 'isANumber( true ): ' + isANumber( true ) ); numeric: Logger.log( 'isANumber( "0" ): ' + isANumber( '0' ) ); Logger.log( 'isANumber( "12.5" ): ' + isANumber( '12.5' ) ); Logger.log( 'isANumber( ".5" ): ' + isANumber( '.5' ) ); Logger.log( 'isANumber( "5." ): ' + isANumber( '5.' ) ); Logger.log( 'isANumber( "-5" ): ' + isANumber( '-5' ) ); Logger.log( 'isANumber( "-5." ): ' + isANumber( '-5.' ) ); Logger.log( 'isANumber( "-.5" ): ' + isANumber( '-5.' ) ); Logger.log( 'isANumber( "1234567890" ): ' + isANumber( '1234567890' )); 

Explicación de la expresión regular:

 /^-?(\d+\.?\d*)$|(\d*\.?\d+)$/ 

El “^” inicial y el “$” final coinciden con el inicio y el final de la cadena, para garantizar que el cheque abarque toda la cadena. Los “-?” parte es el signo menos con el “?” multiplicador que permite cero o una instancia de este.

Luego hay dos grupos similares, delimitados por paréntesis. La cadena tiene que coincidir con cualquiera de estos grupos. El primero coincide con números como 5. y el segundo .5

El primer grupo es

 \d+\.?\d* 

El “\ d +” coincide con un dígito (\ d) una o más veces.
Los “\.?” es el punto decimal (escapado con “\” para despojarlo de su magia), cero o una vez.

La última parte “\ d *” es nuevamente un dígito, cero o más veces.
Todas las partes son opcionales pero el primer dígito, por lo que este grupo coincide con números como 5. y no .5 que coinciden con la otra mitad.

Si solo necesita números enteros positivos y no necesita ceros a la izquierda (por ejemplo, “0001234” o “00”):

 var reg = /^(?:[1-9]\d*|\d)$/; 

Necesitas el * por lo que dice “cero o más del personaje anterior” y esto debería hacerlo:

 var reg = new RegExp('^\\d*$'); 

¿Por qué no usar algo como:

 $.isNumeric($(input).val()) 

Se prueba jquery y se verifica el caso más común

Si los números no son absurdamente grandes, tal vez use:

 new RegExp( '^' + // No leading content. '[-+]?' + // Optional sign. '(?:[0-9]{0,30}\\.)?' + // Optionally 0-30 decimal digits of mantissa. '[0-9]{1,30}' + // 1-30 decimal digits of integer or fraction. '(?:[Ee][-+]?[1-2]?[0-9])?' + // Optional exponent 0-29 for scientific notation. '$' // No trailing content. ) 

Esto trata de evitar algunos escenarios, por si acaso:

  • Desbordando cualquier búfer que la secuencia original podría pasar.
  • Lentitud o rarezas causadas por números negativos como 1E-323 .
  • Al pasar Infinity cuando se espera un número finito (prueba 1E309 o -1E309 ).

En la entrada, si desea filtrar otros caracteres y solo mostrar números en el campo de entrada, puede reemplazar el valor del campo en la tecla:

  var yourInput = jQuery('#input-field'); yourInput.keyup(function() { yourInput.val((yourInput.val().replace(/[^\d]/g,''))) }) 

Veo que ya ha recibido muchas respuestas, pero si busca una expresión regular que coincida con números enteros y números flotantes, esta le funcionará a usted:

 var reg = /^-?\d*\.?\d+$/; 

Simple Regex javascript

 var cnpj = "12.32.432/1-22".replace(/\D/gm,""); console.log(cnpj); 

* Resultado :

 1232432122 

Cheques para solo números:

 if(cnpj.length > 0){ return true; } 

Ejemplo simple

 if("12.32.432/1-22".replace(/\D/gm,"").length > 0){ console.log("Ok."); } 

También podría usar los siguientes métodos, pero tenga en cuenta su implementación interna y / o los valores de retorno.

 1A isNaN(+'13761123123123'); // returns true 1B isNaN(+'13761123123ABC'); // returns false 2A ~~'1.23'; // returns 1 2B ~~'1.2A'; // returns 0 

Para 1A y 1B, la cadena se coacciona primero con el operador + antes de pasarse a la función isNaN() . Esto funciona porque un tipo de número que incluye valores no numéricos devuelve NaN . Hay consideraciones con los detalles de implementación de isNaN()'s que están documentados aquí . Una consideración es si un valor booleano se pasa como isNaN(+false|true) se fuerza a sus equivalentes numéricos y, por lo tanto, se devuelve false pero se puede esperar que la función devuelva true ya que el valor booleano no es numérico en el sentido de estamos probando

Para 2A y 2B vale la pena señalar que encontrar el complemento del número requiere que el valor dado en cuestión esté dentro del rango de los valores de un entero de 32 bits con signo que se puede referenciar en la especificación .

Mi preferencia personal, aunque podría argumentarse que es menos legible ya que incluyen el operador unario, es 1A y 1B debido a la velocidad y concisión.

Perf https://jsperf.com/numeric-string-test-regexvsisnan/1

 /^[\+\-]?\d*\.?\d+(?:[Ee][\+\-]?\d+)?$/ 

Si desea hacer coincidir los números con valores firmados, puede usar:

 var reg = new RegExp('^(\-?|\+?)\d*$'); 

Validará los números de formato: +1, -1, 1.

Utilizar esta:

 const pattern = new RegExp(/^[+-]?\d+(\.\d+)?([Ee][+-]?\d+)?$/g); 

Número solo de expresiones regulares ( Actualizado )

  var reg = new RegExp('[^0-9]','g'); 
 var pattern = /[0-9!"£$%^&*()_+-=]/; 

Esto trata de evitar algunos escenarios, por si acaso:

Desbordando cualquier búfer que la secuencia original podría pasar. Lentitud o rarezas causadas por números negativos como 1E-323 . Al pasar Infinity cuando se espera un número finito (prueba 1E309 o -1E309 ).