Expresión regular para unir números con o sin comas y decimales en el texto

Estoy tratando de localizar y reemplazar todos los números en un cuerpo de texto. He encontrado algunos ejemplos de expresiones regulares, que casi resuelven el problema, pero ninguno es perfecto todavía. El problema que tengo es que los números en mi texto pueden tener o no decimales y comas. Por ejemplo:

“El zorro de 5000 lb. saltó sobre una valla de 99.999.99998713 pies”.

La expresión regular debería devolver ” 5000 ” y ” 99,999.99998713 “. Ejemplos He encontrado la división de los números en la coma o están limitados a dos lugares decimales. Estoy empezando a entender las expresiones regulares lo suficiente como para ver por qué algunos ejemplos están limitados a dos decimales, pero aún no he aprendido cómo superarlo y también incluyo la coma para obtener toda la secuencia.

Aquí está mi última versión:

 [0-9]+(\.[0-9][0-9]?)? 

Que devuelve, ” 5000 “, ” 99,99 “, ” 9.99 ” y ” 998713 ” para el texto anterior.

EDITAR: Dado que esto ha recibido muchas opiniones, permítanme comenzar dando a todos por lo que buscaron en Google:

 #ALL THESE REQUIRE THE WHOLE STRING TO BE A NUMBER #For numbers embedded in sentences, see discussion below #### NUMBERS AND DECIMALS ONLY #### #No commas allowed #Pass: (1000.0), (001), (.001) #Fail: (1,000.0) ^\d*\.?\d+$ #No commas allowed #Can't start with "." #Pass: (0.01) #Fail: (.01) ^(\d+\.)?\d+$ #### CURRENCY #### #No commas allowed #"$" optional #Can't start with "." #Either 0 or 2 decimal digits #Pass: ($1000), (1.00), ($0.11) #Fail: ($1.0), (1.), ($1.000), ($.11) ^\$?\d+(\.\d{2})?$ #### COMMA-GROUPED #### #Commas required between powers of 1,000 #Can't start with "." #Pass: (1,000,000), (0.001) #Fail: (1000000), (1,00,00,00), (.001) ^\d{1,3}(,\d{3})*(\.\d+)?$ #Commas required #Cannot be empty #Pass: (1,000.100), (.001) #Fail: (1000), () ^(?=.)(\d{1,3}(,\d{3})*)?(\.\d+)?$ #Commas optional as long as they're consistent #Can't start with "." #Pass: (1,000,000), (1000000) #Fail: (10000,000), (1,00,00) ^(\d+|\d{1,3}(,\d{3})*)(\.\d+)?$ #### LEADING AND TRAILING ZEROES #### #No commas allowed #Can't start with "." #No leading zeroes in integer part #Pass: (1.00), (0.00) #Fail: (001) ^([1-9]\d*|0)(\.\d+)?$ #No commas allowed #Can't start with "." #No trailing zeroes in decimal part #Pass: (1), (0.1) #Fail: (1.00), (0.1000) ^\d+(\.\d*[1-9])?$ 

Ahora que eso está fuera del camino, la mayoría de los siguientes son comentarios sobre cómo puede obtener regex complejo si intentas ser astuto con él, y por qué debes buscar alternativas. Lea bajo su propio riesgo.


Esta es una tarea muy común, pero todas las respuestas que veo aquí hasta ahora aceptarán entradas que no coinciden con el formato de su número, como ,111 , 9,9,9 o incluso .,,. . Eso es lo suficientemente simple como para solucionarlo, incluso si los números están incrustados en otro texto. En mi humilde opinión, cualquier cosa que no logre tirar 1,234.56 y 1234- y solo esas abc22 1,234.56 9.9.9.9 def 1234 de abc22 1,234.56 9.9.9.9 def 1234 es una respuesta incorrecta.

En primer lugar, si no necesita hacer esto todo en una expresión regular, no lo haga. Una sola expresión regular para dos formatos de números diferentes es difícil de mantener, incluso cuando no están incrustados en otro texto. Lo que realmente debería hacer es dividir todo en espacios en blanco, luego ejecute dos o tres expresiones regulares más pequeñas en los resultados. Si esa no es una opción para ti, sigue leyendo.

Patrón básico

Teniendo en cuenta los ejemplos que ha proporcionado, aquí hay una expresión regular simple que permite casi cualquier número entero o decimal en formato 0000 y bloquea todo lo demás:

 ^\d*\.?\d+$ 

Aquí hay uno que requiere un formato de 0,000 :

 ^\d{1,3}(,\d{3})*(\.\d+)?$ 

Póngalos juntos, y las comas se vuelven opcionales siempre y cuando sean consistentes:

 ^(\d*\.?\d+|\d{1,3}(,\d{3})*(\.\d+)?)$ 

Números incrustados

Los patrones anteriores requieren que toda la entrada sea un número. Está buscando números incrustados en el texto, por lo que debe aflojar esa parte. Por otro lado, no quiere que vea catch22 y piense que se encuentra el número 22. Si está utilizando algo con soporte lookbehind (como .NET), esto es bastante fácil: replace ^ with (? y $ con (?!\S) y está listo para ir:

 (? 

Si trabajas con JavaScript o Ruby o algo así, las cosas empiezan a parecer más complejas:

 (?:^|\s)(\d*\.?\d+|\d{1,3}(?:,\d{3})*(?:\.\d+)?)(?!\S) 

Tendrás que usar grupos de captura; No puedo pensar en una alternativa sin apoyo de look-back. Los números que desee estarán en el Grupo 1 (suponiendo que la coincidencia completa sea Grupo 0).

Validación y reglas más complejas

Creo que cubre tu pregunta, así que si eso es todo lo que necesitas, deja de leer ahora. Si quieres ser más elegante, las cosas se vuelven muy complejas muy rápidamente. Dependiendo de su situación, es posible que desee bloquear alguno o todos los siguientes:

  • Entrada vacía
  • Ceros a la izquierda (p. Ej., 000123)
  • Ceros finales (p. Ej., 1.2340000)
  • Decimales que comienzan con el punto decimal (por ejemplo, .001 en lugar de 0.001)

Solo por el placer de hacerlo, supongamos que quieres bloquear los primeros 3, pero permite el último. ¿Qué deberías hacer? Te diré lo que debes hacer, deberías usar una expresión regular diferente para cada regla y reducir progresivamente tus coincidencias. Pero por el bien del desafío, he aquí cómo lo haces todo en un patrón gigante:

 (? 

Y esto es lo que significa:

 (? 

Probado aquí: http://rextester.com/YPG96786

Esto permitirá cosas como:

 100,000 999.999 90.0009 1,000,023.999 0.111 .111 0 

Bloqueará cosas como:

 1,1,1.111 000,001.111 999. 0. 111.110000 1.1.1.111 9.909,888 

Hay varias formas de hacer que esta expresión regular sea más simple y más corta, pero entiendo que cambiar el patrón aflojará lo que considera un número.

Como muchos motores de expresiones regulares (por ejemplo, JavaScript y Ruby) no son compatibles con el aspecto negativo, la única forma de hacerlo correctamente es con grupos de captura:

 (:?^|\s)(?=.)((?:0|(?:[1-9](?:\d*|\d{0,2}(?:,\d{3})*)))?(?:\.\d*[1-9])?)(?!\S) 

Los números que está buscando estarán en el grupo de captura 1.

Probado aquí: http://rubular.com/r/3HCSkndzhT

Una nota final

Obviamente, esta es una expresión regular masiva, complicada y casi ilegible. Disfruté el desafío, pero debería considerar si realmente desea usar esto en un entorno de producción. En lugar de intentar hacer todo en un solo paso, puedes hacerlo en dos: una expresión regular para capturar cualquier cosa que pueda ser un número, y luego otra para eliminar cualquier cosa que no sea un número. O puede hacer un procesamiento básico y luego usar las funciones de análisis numérico integradas de su idioma. Tu elección.

Hace algunos días, trabajé en el problema de eliminar ceros finales de la cadena de un número .

En la continuidad de ese problema, me parece interesante porque amplía el problema a números que comprenden comas.

Tomé el patrón de expresiones regulares que había escrito en el problema anterior en el que trabajé y lo mejoré para poder tratar los números con comas como respuesta a este problema.

Me he dejado llevar por mi entusiasmo y mi gusto por los regex. No sé si el resultado se ajusta exactamente a la necesidad expresada por Michael Prescott. Me interesaría saber los puntos que están en exceso o en falta en mi expresión regular y corregirlos para que sean más adecuados para ti.

Ahora, después de una larga sesión de trabajo en esta expresión regular, tengo una especie de peso en el cerebro, por lo que no soy lo suficientemente fresca como para dar una gran explicación. Si los puntos son oscuros, y si alguien puede llegar a interesarse lo suficiente, por favor, pregúntame.

La expresión regular está construida para poder detectar los números expresados ​​en notación científica 2E10 o incluso 5,22,454.12E-00.0478 , eliminando ceros innecesarios en las dos partes de dichos números también. Si un exponente es igual a cero, el número se modifica para que no haya más exponente.

Puse un poco de verificación en el patrón para que algunos casos particulares no coincidan, por ejemplo ’12 ..57 ‘ no coincidirá. Pero en ‘, 111’ la cadena ‘111’ coincide porque la coma anterior se considera una coma que no está en un número, sino una coma de oración.

Creo que la gestión de las comas debería mejorarse, ya que me parece que solo hay dos dígitos entre las comas en la numeración india. No será difícil de corregir, supongo

Aquí después hay un código que demuestra cómo funciona mi expresión regular. Hay dos funciones, de acuerdo si uno quiere que los números ‘.1245’ se transformen en ‘0.1245’ o no. No me sorprendería si quedan errores o coincidencias no deseadas o no coincidentes para ciertos casos de cadenas numéricas; entonces me gustaría saber estos casos para comprender y corregir la deficiencia.

Me disculpo por este código escrito en Python, pero las expresiones regulares son trans-lengua y creo que todos serán capaces de rescatar el patrón del reexamen

 import re regx = re.compile('(? 

resultado

 string: ' 23456000and23456000. or23456000.000 00023456000 s000023456000. 000023456000.000 ' 23456000 23456000 ('', '23456000', '', '', '', '', '', '', '') 23456000. 23456000 ('', '23456000', '', '', '', '', '', '', '') 23456000.000 23456000 ('', '23456000', '', '', '', '', '', '', '') 00023456000 23456000 ('', '23456000', '', '', '', '', '', '', '') 000023456000. 23456000 ('', '23456000', '', '', '', '', '', '', '') 000023456000.000 23456000 ('', '23456000', '', '', '', '', '', '', '') string: 'arf 10000 sea10000.+10000.000 00010000-00010000. kant00010000.000 ' 10000 10000 ('', '10000', '', '', '', '', '', '', '') 10000. 10000 ('', '10000', '', '', '', '', '', '', '') 10000.000 10000 ('', '10000', '', '', '', '', '', '', '') 00010000 10000 ('', '10000', '', '', '', '', '', '', '') 00010000. 10000 ('', '10000', '', '', '', '', '', '', '') 00010000.000 10000 ('', '10000', '', '', '', '', '', '', '') string: ' 24: 24, 24. 24.000 24.000, 00024r 00024. blue 00024.000 ' 24 24 ('', '24', '', '', '', '', '', '', '') 24, 24 ('', '24', '', '', '', '', '', '', '') 24. 24 ('', '24', '', '', '', '', '', '', '') 24.000 24 ('', '24', '', '', '', '', '', '', '') 24.000 24 ('', '24', '', '', '', '', '', '', '') 00024 24 ('', '24', '', '', '', '', '', '', '') 00024. 24 ('', '24', '', '', '', '', '', '', '') 00024.000 24 ('', '24', '', '', '', '', '', '', '') string: ' 8zoom8. 8.000 0008 0008. and0008.000 ' 8 8 ('', '8', '', '', '', '', '', '', '') 8. 8 ('', '8', '', '', '', '', '', '', '') 8.000 8 ('', '8', '', '', '', '', '', '', '') 0008 8 ('', '8', '', '', '', '', '', '', '') 0008. 8 ('', '8', '', '', '', '', '', '', '') 0008.000 8 ('', '8', '', '', '', '', '', '', '') string: ' 0 00000M0. = 000. 0.0 0.000 000.0 000.000 .000000 .0 ' 0 0 ('', '0', '', '', '', '', '', '', '') 00000 0 ('', '0', '', '', '', '', '', '', '') 0. 0 ('', '0', '', '', '', '', '', '', '') 000. 0 ('', '0', '', '', '', '', '', '', '') 0.0 0 ('', '', '0', '', '', '', '', '', '') 0.000 0 ('', '', '0', '', '', '', '', '', '') 000.0 0 ('', '', '0', '', '', '', '', '', '') 000.000 0 ('', '', '0', '', '', '', '', '', '') .000000 0 ('', '', '0', '', '', '', '', '', '') .0 0 ('', '', '0', '', '', '', '', '', '') string: ' .0000023456 .0000023456000 .0005872 .0005872000 .00503 .00503000 ' .0000023456 0.0000023456 ('', '', '', '.0000023456', '', '', '', '', '') .0000023456000 0.0000023456 ('', '', '', '.0000023456', '', '', '', '', '') .0005872 0.0005872 ('', '', '', '.0005872', '', '', '', '', '') .0005872000 0.0005872 ('', '', '', '.0005872', '', '', '', '', '') .00503 0.00503 ('', '', '', '.00503', '', '', '', '', '') .00503000 0.00503 ('', '', '', '.00503', '', '', '', '', '') string: ' .068 .0680000 .8 .8000 .123456123456 .123456123456000 ' .068 0.068 ('', '', '', '.068', '', '', '', '', '') .0680000 0.068 ('', '', '', '.068', '', '', '', '', '') .8 0.8 ('', '', '', '.8', '', '', '', '', '') .8000 0.8 ('', '', '', '.8', '', '', '', '', '') .123456123456 0.123456123456 ('', '', '', '.123456123456', '', '', '', '', '') .123456123456000 0.123456123456 ('', '', '', '.123456123456', '', '', '', '', '') string: ' .657 .657000 .45 .4500000 .7 .70000 0.0000023230000 000.0000023230000 ' .657 0.657 ('', '', '', '.657', '', '', '', '', '') .657000 0.657 ('', '', '', '.657', '', '', '', '', '') .45 0.45 ('', '', '', '.45', '', '', '', '', '') .4500000 0.45 ('', '', '', '.45', '', '', '', '', '') .7 0.7 ('', '', '', '.7', '', '', '', '', '') .70000 0.7 ('', '', '', '.7', '', '', '', '', '') 0.0000023230000 0.000002323 ('', '', '', '.000002323', '', '', '', '', '') 000.0000023230000 0.000002323 ('', '', '', '.000002323', '', '', '', '', '') string: ' 0.0081000 0000.0081000 0.059000 0000.059000 ' 0.0081000 0.0081 ('', '', '', '.0081', '', '', '', '', '') 0000.0081000 0.0081 ('', '', '', '.0081', '', '', '', '', '') 0.059000 0.059 ('', '', '', '.059', '', '', '', '', '') 0000.059000 0.059 ('', '', '', '.059', '', '', '', '', '') string: ' 0.78987400000 snow 00000.78987400000 0.4400000 00000.4400000 ' 0.78987400000 0.789874 ('', '', '', '.789874', '', '', '', '', '') 00000.78987400000 0.789874 ('', '', '', '.789874', '', '', '', '', '') 0.4400000 0.44 ('', '', '', '.44', '', '', '', '', '') 00000.4400000 0.44 ('', '', '', '.44', '', '', '', '', '') string: ' -0.5000 -0000.5000 0.90 000.90 0.7 000.7 ' -0.5000 -0.5 ('-', '', '', '.5', '', '', '', '', '') -0000.5000 -0.5 ('-', '', '', '.5', '', '', '', '', '') 0.90 0.9 ('', '', '', '.9', '', '', '', '', '') 000.90 0.9 ('', '', '', '.9', '', '', '', '', '') 0.7 0.7 ('', '', '', '.7', '', '', '', '', '') 000.7 0.7 ('', '', '', '.7', '', '', '', '', '') string: ' 2.6 00002.6 00002.60000 4.71 0004.71 0004.7100 ' 2.6 2.6 ('', '', '', '', '2.6', '', '', '', '') 00002.6 2.6 ('', '', '', '', '2.6', '', '', '', '') 00002.60000 2.6 ('', '', '', '', '2.6', '', '', '', '') 4.71 4.71 ('', '', '', '', '4.71', '', '', '', '') 0004.71 4.71 ('', '', '', '', '4.71', '', '', '', '') 0004.7100 4.71 ('', '', '', '', '4.71', '', '', '', '') string: ' 23.49 00023.49 00023.490000 103.45 0000103.45 0000103.45000 ' 23.49 23.49 ('', '', '', '', '23.49', '', '', '', '') 00023.49 23.49 ('', '', '', '', '23.49', '', '', '', '') 00023.490000 23.49 ('', '', '', '', '23.49', '', '', '', '') 103.45 103.45 ('', '', '', '', '103.45', '', '', '', '') 0000103.45 103.45 ('', '', '', '', '103.45', '', '', '', '') 0000103.45000 103.45 ('', '', '', '', '103.45', '', '', '', '') string: ' 10003.45067 000010003.45067 000010003.4506700 ' 10003.45067 10003.45067 ('', '', '', '', '10003.45067', '', '', '', '') 000010003.45067 10003.45067 ('', '', '', '', '10003.45067', '', '', '', '') 000010003.4506700 10003.45067 ('', '', '', '', '10003.45067', '', '', '', '') string: ' +15000.0012 +000015000.0012 +000015000.0012000 ' +15000.0012 +15000.0012 ('+', '', '', '', '15000.0012', '', '', '', '') +000015000.0012 +15000.0012 ('+', '', '', '', '15000.0012', '', '', '', '') +000015000.0012000 +15000.0012 ('+', '', '', '', '15000.0012', '', '', '', '') string: ' 78000.89 000078000.89 000078000.89000 ' 78000.89 78000.89 ('', '', '', '', '78000.89', '', '', '', '') 000078000.89 78000.89 ('', '', '', '', '78000.89', '', '', '', '') 000078000.89000 78000.89 ('', '', '', '', '78000.89', '', '', '', '') string: ' .0457e10 .0457000e10 00000.0457000e10 ' .0457e10 0.0457e10 ('', '', '', '.0457', '', 'e', '10', '', '') .0457000e10 0.0457e10 ('', '', '', '.0457', '', 'e', '10', '', '') 00000.0457000e10 0.0457e10 ('', '', '', '.0457', '', 'e', '10', '', '') string: ' 258e8 2580000e4 0000000002580000e4 ' 258e8 258e8 ('', '258', '', '', '', 'e', '8', '', '') 2580000e4 2580000e4 ('', '2580000', '', '', '', 'e', '4', '', '') 0000000002580000e4 2580000e4 ('', '2580000', '', '', '', 'e', '4', '', '') string: ' 0.782e10 0000.782e10 0000.7820000e10 ' 0.782e10 0.782e10 ('', '', '', '.782', '', 'e', '10', '', '') 0000.782e10 0.782e10 ('', '', '', '.782', '', 'e', '10', '', '') 0000.7820000e10 0.782e10 ('', '', '', '.782', '', 'e', '10', '', '') string: ' 1.23E2 0001.23E2 0001.2300000E2 ' 1.23E2 1.23E2 ('', '', '', '', '1.23', 'E', '2', '', '') 0001.23E2 1.23E2 ('', '', '', '', '1.23', 'E', '2', '', '') 0001.2300000E2 1.23E2 ('', '', '', '', '1.23', 'E', '2', '', '') string: ' 432e-102 0000432e-102 004320000e-106 ' 432e-102 432e-102 ('', '432', '', '', '', 'e-', '102', '', '') 0000432e-102 432e-102 ('', '432', '', '', '', 'e-', '102', '', '') 004320000e-106 4320000e-106 ('', '4320000', '', '', '', 'e-', '106', '', '') string: ' 1.46e10and0001.46e10 0001.4600000e10 ' 1.46e10 1.46e10 ('', '', '', '', '1.46', 'e', '10', '', '') 0001.46e10 1.46e10 ('', '', '', '', '1.46', 'e', '10', '', '') 0001.4600000e10 1.46e10 ('', '', '', '', '1.46', 'e', '10', '', '') string: ' 1.077e-300 0001.077e-300 0001.077000e-300 ' 1.077e-300 1.077e-300 ('', '', '', '', '1.077', 'e-', '300', '', '') 0001.077e-300 1.077e-300 ('', '', '', '', '1.077', 'e-', '300', '', '') 0001.077000e-300 1.077e-300 ('', '', '', '', '1.077', 'e-', '300', '', '') string: ' 1.069e10 0001.069e10 0001.069000e10 ' 1.069e10 1.069e10 ('', '', '', '', '1.069', 'e', '10', '', '') 0001.069e10 1.069e10 ('', '', '', '', '1.069', 'e', '10', '', '') 0001.069000e10 1.069e10 ('', '', '', '', '1.069', 'e', '10', '', '') string: ' 105040.03e10 000105040.03e10 105040.0300e10 ' 105040.03e10 105040.03e10 ('', '', '', '', '105040.03', 'e', '10', '', '') 000105040.03e10 105040.03e10 ('', '', '', '', '105040.03', 'e', '10', '', '') 105040.0300e10 105040.03e10 ('', '', '', '', '105040.03', 'e', '10', '', '') string: ' +286E000024.487900 -78.4500e.14500 .0140E789. ' +286E000024.487900 +286E24.4879 ('+', '286', '', '', '', 'E', '', '', '24.4879') -78.4500e.14500 -78.45e0.145 ('-', '', '', '', '78.45', 'e', '', '.145', '') .0140E789. 0.014E789 ('', '', '', '.014', '', 'E', '789', '', '') string: ' 081,12.40E07,95.0120 0045,78,123.03500e-0.00 ' 081,12.40E07,95.0120 81,12.4E7,95.012 ('', '', '', '', '81,12.4', 'E', '', '', '7,95.012') 0045,78,123.03500 45,78,123.035 ('', '', '', '', '45,78,123.035', '', '', '', '') string: ' 0096,78,473.0380e-0. 0008,78,373.066000E0. 0004512300.E0000 ' 0096,78,473.0380 96,78,473.038 ('', '', '', '', '96,78,473.038', '', '', '', '') 0008,78,373.066000 8,78,373.066 ('', '', '', '', '8,78,373.066', '', '', '', '') 0004512300. 4512300 ('', '4512300', '', '', '', '', '', '', '') string: ' ..18000 25..00 36...77 2..8 ' No match, No catched string, No groups. string: ' 3.8..9 .12500. 12.51.400 ' No match, No catched string, No groups. string: ' 00099,111.8713000 -0012,45,83,987.26+0.000,099,88,44.or00,00,00.00must' 00099,111.8713000 99,111.8713 ('', '', '', '', '99,111.8713', '', '', '', '') -0012,45,83,987.26 -12,45,83,987.26 ('-', '', '', '', '12,45,83,987.26', '', '', '', '') 00,00,00.00 0 ('', '', '0', '', '', '', '', '', '') string: ' 00099,44,and 0000,099,88,44.bom' 00099,44, 99,44 ('', '99,44', '', '', '', '', '', '', '') 0000,099,88,44. 99,88,44 ('', '99,88,44', '', '', '', '', '', '', '') string: '00,000,00.587000 77,98,23,45., this,that ' 00,000,00.587000 0.587 ('', '', '', '.587', '', '', '', '', '') 77,98,23,45. 77,98,23,45 ('', '77,98,23,45', '', '', '', '', '', '', '') string: ' ,111 145.20 +9,9,9 0012800 .,,. 1 100,000 ' ,111 111 ('', '111', '', '', '', '', '', '', '') 145.20 145.2 ('', '', '', '', '145.2', '', '', '', '') +9,9,9 +9,9,9 ('+', '9,9,9', '', '', '', '', '', '', '') 0012800 12800 ('', '12800', '', '', '', '', '', '', '') 1 1 ('', '1', '', '', '', '', '', '', '') 100,000 100,000 ('', '100,000', '', '', '', '', '', '', '') string: '1,1,1.111 000,001.111 -999. 0. 111.110000 1.1.1.111 9.909,888' 1,1,1.111 1,1,1.111 ('', '', '', '', '1,1,1.111', '', '', '', '') 000,001.111 1.111 ('', '', '', '', '1.111', '', '', '', '') -999. -999 ('-', '999', '', '', '', '', '', '', '') 0. 0 ('', '0', '', '', '', '', '', '', '') 111.110000 111.11 ('', '', '', '', '111.11', '', '', '', '') 

Tomando cierta libertad con los requisitos, estás buscando

 \d+([\d,]?\d)*(\.\d+)? 

Pero observe que esto coincidirá, por ejemplo, 11,11,1

 \d+(,\d+)*(\.\d+)? 

Esto supone que siempre hay al menos un dígito antes o después de cualquier coma o decimal y también supone que hay como máximo un decimal y que todas las comas preceden al decimal.

La expresión regular a continuación coincidirá con los dos números de tu ejemplo.

 \b\d[\d,.]*\b 

Devolverá 5000 y 99.999.99998713, según sus requisitos.

Esta expresión regular:

 (\d{1,3},\d{3}(,\d{3})*)(\.\d*)?|\d+\.?\d* 

Coincide con cada número en la cadena:

1 1.0 0.1 1.001 1,000 1,000,000 1000.1 1,000.1 1,323,444,000 1,999 1,222,455,666.0 1,244

Aquí hay otra construcción que comienza con el formato numérico más simple y luego, de una manera que no se superpone, progresivamente agrega formatos de números más complejos:

Regep de Java:

 (\d)|([1-9]\d+)|(\.\d+)|(\d\.\d*)|([1-9]\d+\.\d*)|([1-9]\d{0,2}(,\d{3})+(\.\d*)?) 

Como un Java String (nótese el extra \ necesario para escapar a \ y, dado que \ y. Tienen un significado especial en una expresión regular cuando están solos):

 String myregexp="(\\d)|([1-9]\\d+)|(\\.\\d+)|(\\d\\.\\d*)|([1-9]\\d+\\.\\d*)|([1-9]\\d{0,2}(,\\d{3})+(\\.\\d*)?)"; 

Explicación:

  1. Esta expresión regular tiene la forma A | B | C | D | E | F donde A, B, C, D, E, F son ellos mismos expresiones regulares que no se superponen. En general, me resulta más fácil comenzar con las coincidencias más simples posibles, A. Si A pierde las coincidencias que desea, cree una B que sea una modificación menor de A e incluya un poco más de lo que desea. Luego, basado en B, creo una C que atrapa más, etc. También me resulta más fácil crear expresiones regulares que no se superpongan; es más fácil entender una expresión regular con 20 expresiones regulares simples no superpuestas conectadas con las RUP en lugar de unas pocas expresiones regulares con una coincidencia más compleja. ¡Pero, cada uno para los suyos!

  2. A es (\ d) y coincide exactamente con uno de 0,1,2,3,4,5,6,7,8,9 que no puede ser más sencillo.

  3. B es ([1-9] \ d +) y solo coincide con números con 2 o más dígitos, el primero excluyendo 0. B coincide exactamente con uno de 10,11,12, … B no se superpone A sino que es una pequeña modificación de A.

  4. C es (. \ D +) y solo coincide con un decimal seguido de uno o más dígitos. C coincide exactamente con uno de .0 .1 .2 .3 .4 .5 .6 .7 .8 .9 .00 .01 .02 …. .23000 … C permite el eros final a la derecha que prefiero: si se trata de datos de medición, el número de ceros finales indica el nivel de precisión. Si no quiere los ceros finales a la derecha, cambie (. \ D +) a (. \ D * [1-9]) pero esto también excluye .0 que creo que debería estar permitido. C también es una pequeña modificación de A.

  5. D es (\ d. \ D *) que es A más decimales con ceros a la derecha. D solo coincide con un solo dígito, seguido de un decimal, seguido de cero o más dígitos. D coincide con 0. 0.0 0.1 0.2 …. 0.01000 … 9. 9.0 9.1..0.0230000 …. 9.9999999999 … Si desea excluir “0”. luego cambie D a (\ d. \ d +). Si desea excluir ceros finales a la derecha, cambie D a (\ d. \ D * [1-9]) pero esto excluye 2.0, que creo que debería incluirse. D no se superpone A, B o C.

  6. E es ([1-9] \ d +. \ D *) que es B más decimales con ceros finales a la derecha. Si quiere excluir “13.”, por ejemplo, cambie E a ([1-9] \ d +. \ D +). E no solapa A, B, C o D. E coincide con 10. 10.0 10.0100 …. 99.9999999999 … Los ceros finales se pueden manejar como en 4. y 5.

  7. F es ([1-9] \ d {0,2} (, \ d {3}) + (. \ D *)?) Y solo coincide con los números con comas y posiblemente decimales que permiten ceros a la derecha. El primer grupo ([1-9] \ d {0,2}) coincide con un dígito distinto de cero seguido de cero, uno o dos dígitos más. El segundo grupo (, \ d {3}) + coincide con un grupo de 4 caracteres (una coma seguida de exactamente tres dígitos) y este grupo puede coincidir una o más veces (¡sin coincidencias significa que no hay comas!). Finalmente, (. \ D *)? no coincide con nada o coincide. por sí mismo, o coincide con un decimal. followed by any number of digits, possibly none. Again, to exclude things like “1,111.”, change (.\d*) to (.\d+). Trailing zeros can be handled as in 4. or 5. F does not overlap A,B,C,D, or E. I couldn’t think of an easier regexp for F.

Let me know if you are interested and I can edit above to handle the trailing zeros on the right as desired.

Here is what matches regexp and what does not:

 0 1 02 <- invalid 20 22 003 <- invalid 030 <- invalid 300 033 <- invalid 303 330 333 0004 <- invalid 0040 <- invalid 0400 <- invalid 4000 0044 <- invalid 0404 <- invalid 0440 <- invalid 4004 4040 4400 0444 <- invalid 4044 4404 4440 4444 00005 <- invalid 00050 <- invalid 00500 <- invalid 05000 <- invalid 50000 00055 <- invalid 00505 <- invalid 00550 <- invalid 05050 <- invalid 05500 <- invalid 50500 55000 00555 <- invalid 05055 <- invalid 05505 <- invalid 05550 <- invalid 50550 55050 55500 . <- invalid .. <- invalid .0 0. .1 1. .00 0.0 00. <- invalid .02 0.2 02. <- invalid .20 2.0 20. .22 2.2 22. .000 0.00 00.0 <- invalid 000. <- invalid .003 0.03 00.3 <- invalid 003. <- invalid .030 0.30 03.0 <- invalid 030. <- invalid .033 0.33 03.3 <- invalid 033. <- invalid .303 3.03 30.3 303. .333 3.33 33.3 333. .0000 0.000 00.00 <- invalid 000.0 <- invalid 0000. <- invalid .0004 0.0004 00.04 <- invalid 000.4 <- invalid 0004. <- invalid .0044 0.044 00.44 <- invalid 004.4 <- invalid 0044. <- invalid .0404 0.404 04.04 <- invalid 040.4 <- invalid 0404. <- invalid .0444 0.444 04.44 <- invalid 044.4 <- invalid 0444. <- invalid .4444 4.444 44.44 444.4 4444. .00000 0.0000 00.000 <- invalid 000.00 <- invalid 0000.0 <- invalid 00000. <- invalid .00005 0.0005 00.005 <- invalid 000.05 <- invalid 0000.5 <- invalid 00005. <- invalid .00055 0.0055 00.055 <- invalid 000.55 <- invalid 0005.5 <- invalid 00055. <- invalid .00505 0.0505 00.505 <- invalid 005.05 <- invalid 0050.5 <- invalid 00505. <- invalid .00550 0.0550 00.550 <- invalid 005.50 <- invalid 0055.0 <- invalid 00550. <- invalid .05050 0.5050 05.050 <- invalid 050.50 <- invalid 0505.0 <- invalid 05050. <- invalid .05500 0.5500 05.500 <- invalid 055.00 <- invalid 0550.0 <- invalid 05500. <- invalid .50500 5.0500 50.500 505.00 5050.0 50500. .55000 5.5000 55.000 550.00 5500.0 55000. .00555 0.0555 00.555 <- invalid 005.55 <- invalid 0055.5 <- invalid 00555. <- invalid .05055 0.5055 05.055 <- invalid 050.55 <- invalid 0505.5 <- invalid 05055. <- invalid .05505 0.5505 05.505 <- invalid 055.05 <- invalid 0550.5 <- invalid 05505. <- invalid .05550 0.5550 05.550 <- invalid 055.50 <- invalid 0555.0 <- invalid 05550. <- invalid .50550 5.0550 50.550 505.50 5055.0 50550. .55050 5.5050 55.050 550.50 5505.0 55050. .55500 5.5500 55.500 555.00 5550.0 55500. .05555 0.5555 05.555 <- invalid 055.55 <- invalid 0555.5 <- invalid 05555. <- invalid .50555 5.0555 50.555 505.55 5055.5 50555. .55055 5.5055 55.055 550.55 5505.5 55055. .55505 5.5505 55.505 555.05 5550.5 55505. .55550 5.5550 55.550 555.50 5555.0 55550. .55555 5.5555 55.555 555.55 5555.5 55555. , <- invalid ,, <- invalid 1, <- invalid ,1 <- invalid 22, <- invalid 2,2 <- invalid ,22 <- invalid 2,2, <- invalid 2,2, <- invalid ,22, <- invalid 333, <- invalid 33,3 <- invalid 3,33 <- invalid ,333 <- invalid 3,33, <- invalid 3,3,3 <- invalid 3,,33 <- invalid ,,333 <- invalid 4444, <- invalid 444,4 <- invalid 44,44 <- invalid 4,444 ,4444 <- invalid 55555, <- invalid 5555,5 <- invalid 555,55 <- invalid 55,555 5,5555 <- invalid ,55555 <- invalid 666666, <- invalid 66666,6 <- invalid 6666,66 <- invalid 666,666 66,6666 <- invalid 6,66666 <- invalid 66,66,66 <- invalid 6,66,666 <- invalid ,666,666 <- invalid 1,111. 1,111.11 1,111.110 01,111.110 <- invalid 0,111.100 <- invalid 11,11. <- invalid 1,111,.11 <- invalid 1111.1,10 <- invalid 01111.11,0 <- invalid 0111.100, <- invalid 1,111,111. 1,111,111.11 1,111,111.110 01,111,111.110 <- invalid 0,111,111.100 <- invalid 1,111,111. 1,1111,11.11 <- invalid 11,111,11.110 <- invalid 01,11,1111.110 <- invalid 0,111111.100 <- invalid 0002,22.2230 <- invalid .,5.,., <- invalid 2.0,345,345 <- invalid 2.334.456 <- invalid 

Here’s a regex:

 (?:\d+)((\d{1,3})*([\,\ ]\d{3})*)(\.\d+)? 

that accepts numbers:

  • without spaces and/or decimals, eg. 123456789 , 123.123
  • with commas or spaces as thousands separator and/or decimals, eg. 123 456 789 , 123 456 789.100 , 123,456 , 3,232,300,000.00

Tests: http://regexr.com/3h1a2