Al fin después de mucho trabajar pudimos encontrar la contestación de este dilema que tantos lectores de este sitio web han presentado. Si tienes algo que aportar puedes dejar tu comentario.
Solución:
EDITAR: Dado que esto ha obtenido muchas visitas, permítanme comenzar dándoles a todos 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+(.d2)?$
#### 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)
^d1,3(,d3)*(.d+)?$
#Commas required
#Cannot be empty
#Pass: (1,000.100), (.001)
#Fail: (1000), ()
^(?=.)(d1,3(,d3)*)?(.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+|d1,3(,d3)*)(.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 parte de lo siguiente es un comentario sobre lo compleja que puede llegar a ser la expresión regular si trata de ser inteligente con ella, y por qué debería 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 coincidan con el formato de su número, como ,111, 9,9,9, o incluso .,,.. Eso es lo suficientemente simple de solucionar, incluso si los números están incrustados en otro texto. En mi humilde opinión, cualquier cosa que no obtenga 1,234.56 y 1234—y solo esos numeros-fuera de abc22 1,234.56 9.9.9.9 def 1234 es una respuesta incorrecta.
En primer lugar, si no necesita hacer todo esto en una sola 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 debe hacer es dividir todo en espacios en blanco, luego ejecutar 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 dado, aquí hay una expresión regular simple que permite prácticamente cualquier número entero o decimal en 0000 formatea y bloquea todo lo demás:
^d*.?d+$
Aquí hay uno que requiere 0,000 formato:
^d1,3(,d3)*(.d+)?$
Júntelos y las comas se vuelven opcionales siempre que sean coherentes:
^(d*.?d+|d1,3(,d3)*(.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 quieres que vea catch22 y creo que ha encontrado el número 22. Si está usando algo con soporte de búsqueda hacia atrás (como .NET), esto es bastante fácil: reemplace ^ con (? y $ con (?!S) y estás listo para ir:
(?Si está trabajando con JavaScript o Ruby o algo así, las cosas comienzan a parecer más complejas:
(?:^|s)(d*.?d+|d1,3(?:,d3)*(?:.d+)?)(?!S)
Tendrás que usar grupos de captura; No puedo pensar en una alternativa sin un apoyo retrospectivo. Los números que desea estarán en el Grupo 1 (asumiendo que todo el partido es el Grupo 0).
Validación y reglas más complejas
Creo que eso 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 iniciales (por ejemplo, 000123)
- Ceros finales (por ejemplo, 1.2340000)
- Decimales que comienzan con el punto decimal (p. Ej., 0,001 en lugar de 0,001)
Por el gusto de hacerlo, supongamos que desea bloquear los primeros 3, pero permita el último. ¿Qué deberías hacer? Le diré lo que debe hacer, debe usar una expresión regular diferente para cada regla y reducir progresivamente sus coincidencias. Pero por el bien del desafío, así es como 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 comprenda que cambiar el patrón aflojará lo que considera un número.
Dado que muchos motores de expresiones regulares (por ejemplo, JavaScript y Ruby) no admiten la búsqueda hacia atrás negativa, la única forma de hacerlo correctamente es con grupos de captura:
(:?^|s)(?=.)((?:0|(?:[1-9](?:d*|d0,2(?:,d3)*)))?(?:.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ías considere si realmente desea utilizar esto en un entorno de producción. En lugar de intentar hacer todo en un solo paso, puede hacerlo en dos: una expresión regular para capturar cualquier cosa que podría ser un número, luego otro para eliminar lo que sea no es 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 los ceros finales de la cadena de un número.
En la continuidad de ese problema, encuentro este 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 que pueda tratar los números con comas como respuesta a este problema.
Me he dejado llevar por mi entusiasmo y mi gusto por las expresiones regulares. No sé si el resultado se ajusta exactamente a la necesidad expresada por Michael Prescott. Me interesaría conocer los puntos que sobran o faltan en mi expresión regular, y corregirlo para que sea más adecuado 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, así que no estoy lo suficientemente fresco como para dar muchas explicaciones. Si los puntos son oscuros, y si alguien puede llegar a estar lo suficientemente interesado, por favor, pregúnteme.
La expresión regular está construida para que pueda 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 alguna verificación en el patrón para que algunos casos particulares no coincidan, por ejemplo '12 ..57 ' no coincidirá. Pero en ', 111' la cuerda '111' coincide porque la coma anterior se considera una coma que no está en un número sino en una coma de oración.
Creo que la gestión de las comas debería mejorarse, porque me parece que solo hay 2 dígitos entre comas en la numeración india. No será difícil de corregir, supongo
A continuación se muestra un código que demuestra cómo funciona mi expresión regular. Hay dos funciones, según se quiera los números '.1245' ser transformado en '0.1245' o no. No me sorprendería que en ciertos casos de cadenas de números persistan errores o coincidencias no deseadas o no coincidentes; entonces me gustaría conocer estos casos para comprender y corregir la deficiencia.
Me disculpo por este código escrito en Python, pero las expresiones regulares son trans-langage y creo que todos serán capaces de entender el patrón de reex
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', '', '', '', '')
La expresión regular a continuación coincidirá con ambos números de su ejemplo.
bd[d,.]*b
Devolverá 5000 y 99,999.99998713, coincidiendo con sus requisitos.
Si estás de acuerdo, eres capaz de dejar una crónica acerca de qué le añadirías a este artículo.