regex - regulares - permitir solo un punto decimal en javascript
Expresión regular para unir números con o sin comas y decimales en el texto (8)
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 (?<!/S) y $ con (?!/S) y está listo para ir:
(?<!/S)(/d*/.?/d+|/d{1,3}(,/d{3})*(/./d+)?)(?!/S)
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:
(?<!/S)(?=.)(0|([1-9](/d*|/d{0,2}(,/d{3})*)))?(/./d*[1-9])?(?!/S)
Y esto es lo que significa:
(?<!/S) to (?!/S) #The whole match must be surrounded by either whitespace or line boundaries. So if you see something bogus like :;:9.:, ignore the 9.
(?=.) #The whole thing can''t be blank.
( #Rules for the integer part:
0 #1. The integer part could just be 0...
| #
[1-9] # ...otherwise, it can''t have leading zeroes.
( #
/d* #2. It could use no commas at all...
| #
/d{0,2}(,/d{3})* # ...or it could be comma-separated groups of 3 digits each.
) #
)? #3. Or there could be no integer part at all.
( #Rules for the decimal part:
/. #1. It must start with a decimal point...
/d* #2. ...followed by a string of numeric digits only.
[1-9] #3. It can''t be just the decimal point, and it can''t end in 0.
)? #4. The whole decimal part is also optional. Remember, we checked at the beginning to make sure the whole thing wasn''t blank.
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.
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.
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:
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!
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.
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.
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.
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.
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.
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. The second group (,/d{3})+ matches a 4 character group (a comma followed by exactly three digits) and this group can match one or more times (no matches means no commas!). Finally, (./d*)? matches nothing, or matches . by itself, or matches a 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
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
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(''(?<![/d.])(?!/./.)(?<![/d.][eE][+-])(?<![/d.][eE])(?<!/d[.,])''
'''' #---------------------------------
''([+-]?)''
''(?![/d,]*?/.[/d,]*?/.[/d,]*?)''
''(?:0|,(?=0)|(?<!/d),)*''
''(?:''
''((?:/d(?!/.[1-9])|,(?=/d))+)[.,]?''
''|/.(0)''
''|((?<!/.)/./d+?)''
''|([/d,]+/./d+?))''
''0*''
'''' #---------------------------------
''(?:''
''([eE][+-]?)(?:0|,(?=0))*''
''(?:''
''(?!0+(?=/D|/Z))((?:/d(?!/.[1-9])|,(?=/d))+)[.,]?''
''|((?<!/.)/.(?!0+(?=/D|/Z))/d+?)''
''|([/d,]+/.(?!0+(?=/D|/Z))/d+?))''
''0*''
'')?''
'''' #---------------------------------
''(?![.,]?/d)'')
def dzs_numbs(x,regx = regx): # ds = detect and zeros-shave
if not regx.findall(x):
yield (''No match,'', ''No catched string,'', ''No groups.'')
for mat in regx.finditer(x):
yield (mat.group(), ''''.join(mat.groups('''')), mat.groups(''''))
def dzs_numbs2(x,regx = regx): # ds = detect and zeros-shave
if not regx.findall(x):
yield (''No match,'', ''No catched string,'', ''No groups.'')
for mat in regx.finditer(x):
yield (mat.group(),
''''.join((''0'' if n.startswith(''.'') else '''')+n for n in mat.groups('''')),
mat.groups(''''))
NS = ['' 23456000and23456000. or23456000.000 00023456000 s000023456000. 000023456000.000 '',
''arf 10000 sea10000.+10000.000 00010000-00010000. kant00010000.000 '',
'' 24: 24, 24. 24.000 24.000, 00024r 00024. blue 00024.000 '',
'' 8zoom8. 8.000 0008 0008. and0008.000 '',
'' 0 00000M0. = 000. 0.0 0.000 000.0 000.000 .000000 .0 '',
'' .0000023456 .0000023456000 ''
'' .0005872 .0005872000 .00503 .00503000 '',
'' .068 .0680000 .8 .8000 .123456123456 .123456123456000 '',
'' .657 .657000 .45 .4500000 .7 .70000 0.0000023230000 000.0000023230000 '',
'' 0.0081000 0000.0081000 0.059000 0000.059000 '',
'' 0.78987400000 snow 00000.78987400000 0.4400000 00000.4400000 '',
'' -0.5000 -0000.5000 0.90 000.90 0.7 000.7 '',
'' 2.6 00002.6 00002.60000 4.71 0004.71 0004.7100 '',
'' 23.49 00023.49 00023.490000 103.45 0000103.45 0000103.45000 '',
'' 10003.45067 000010003.45067 000010003.4506700 '',
'' +15000.0012 +000015000.0012 +000015000.0012000 '',
'' 78000.89 000078000.89 000078000.89000 '',
'' .0457e10 .0457000e10 00000.0457000e10 '',
'' 258e8 2580000e4 0000000002580000e4 '',
'' 0.782e10 0000.782e10 0000.7820000e10 '',
'' 1.23E2 0001.23E2 0001.2300000E2 '',
'' 432e-102 0000432e-102 004320000e-106 '',
'' 1.46e10and0001.46e10 0001.4600000e10 '',
'' 1.077e-300 0001.077e-300 0001.077000e-300 '',
'' 1.069e10 0001.069e10 0001.069000e10 '',
'' 105040.03e10 000105040.03e10 105040.0300e10 '',
'' +286E000024.487900 -78.4500e.14500 .0140E789. '',
'' 081,12.40E07,95.0120 0045,78,123.03500e-0.00 '',
'' 0096,78,473.0380e-0. 0008,78,373.066000E0. 0004512300.E0000 '',
'' ..18000 25..00 36...77 2..8 '',
'' 3.8..9 .12500. 12.51.400 '',
'' 00099,111.8713000 -0012,45,83,987.26+0.000,099,88,44.or00,00,00.00must'',
'' 00099,44,and 0000,099,88,44.bom'',
''00,000,00.587000 77,98,23,45., this,that '',
'' ,111 145.20 +9,9,9 0012800 .,,. 1 100,000 '',
''1,1,1.111 000,001.111 -999. 0. 111.110000 1.1.1.111 9.909,888'']
for ch in NS:
print ''string: ''+repr(ch)
for strmatch, modified, the_groups in dzs_numbs2(ch):
print strmatch.rjust(20),'''',modified,'''',the_groups
print
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 los dos números de tu ejemplo.
/b/d[/d,.]*/b
Devolverá 5000 y 99.999.99998713, según sus requisitos.
Tomando cierta libertad con los requisitos, estás buscando
/d+([/d,]?/d)*(/./d+)?
Pero observe que esto coincidirá, por ejemplo, 11,11,1
Here''s a regex:
(?:/d+)((/d{1,3})*([/,/ ]/d{3})*)(/./d+)?
that accepts numbers:
- sin espacios y / o decimales, ej.
123456789,123.123 - con comas o espacios como separador de miles y / o decimales, ej.
123 456 789,123 456 789.100,123,456,3,232,300,000.00
Pruebas: http://regexr.com/3h1a2
/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.