RegEx para precios?

Question

Estoy buscando un RegEx para los precios. Por lo tanto, debe tener X números en frente, que un "," y al final 2 números máx.

¿Alguien me puede apoyar y publicarlo por favor?

Answer 1

¿En qué idioma se va a usar?

Debería ser algo como:

^\d+(,\d{1,2})?$ 

Explicación:

número X delante es: ^\d+ donde ^ significa el inicio de la cadena, \d significa un dígito y + significa uno o más

Usamos el grupo () con un signo de interrogación, un ? significa: matc h lo que está dentro del grupo una o ninguna vez.

dentro del grupo sólo existe ,\d{1,2}, el , es la coma que escribió, \d sigue siendo un dígito {1,2} significa coincide con el dígito anterior una o dos veces.

El $ final coincide con el final de la cadena.

Answer 2

^\d+,\d{1,2}$ 

Answer 3

algo como \ d +, \ d {2} es incorrecto porque \ d coincide [0-9 \.] Es decir 12.34,1.

debe ser: [0-9] +, [0-9] {2} (o [0-9] +, [0-9] {1,2} para permitir lugar solamente 1 decimal)

Answer 4

Así que me encontré con un problema similar, la necesidad de validar si una cadena arbitraria es un precio, pero necesitaba mucha más capacidad de recuperación que las expresiones regulares proporcionadas en este hilo y muchos otros hilos.

necesitaba una expresión regular que coincida con todos los siguientes:

• 5,00
• 1.000
• 1,000,000.99
• 5,99 (precio europeo)
• 5.999, 99 (precio europeo)
• 0.11
• 0.00

Y no hacer coincidir cosas como las direcciones IP. No pude encontrar una sola expresión regular para hacer frente a las cosas europeo y no europeo de un solo golpe así que escribí un poco de código Ruby para normalizar los precios:

if value =~ /^([1-9][0-9]{,2}(,[0-9]{3})*|[0-9]+)(\.[0-9]{1,9})?$/ 
    Float(value.delete(",")) 
elsif value =~ /^([1-9][0-9]{,2}(\.[0-9]{3})*|[0-9]+)(,[0-9]{1,9})?$/ 
    Float(value.delete(".").gsub(",", ".")) 
else 
    false 
end 

La única diferencia entre las dos expresiones regulares es el lugar decimal y la coma intercambiados.Voy a tratar de romper lo que esto está haciendo:

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

La primera parte:

([1-9][0-9]{,2}(,[0-9]{3})* 

Ésta es una declaración de los números que siguen a este formulario: 1000000 1000 100 12. Pero no lo hace permitir ceros a la izquierda. Es para los números formateados correctamente que tienen grupos de 3 números separados por el separador de miles.

Segunda parte:

[0-9]+ 

Sólo coinciden con cualquier número multiplicado por 1 o más. Usted puede hacer esto a 0 o más veces si desea hacer coincidir: 0.11 0.34 0.00 etc.

La última parte:

(\.[0-9]{1,9})? 

Este es el lugar poco decimal. ¿Por qué hasta 9 números, preguntas? Lo he visto suceder Se supone que esta expresión regular es capaz de manejar cualquier precio extraño y maravilloso que vea y he visto que algunos minoristas usan hasta 9 decimales en los precios. Por lo general, todos los años 0, pero no queremos perdernos los datos^_^

Esperamos que esto ayude a la siguiente persona que necesite procesar cadenas de precios mal formateadas arbitrariamente o en formato europeo o no europeo :)

Answer 5

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

para cubrir todas

• 5,00

  1.000

  1,000,000.99

  5,99 (precio europeo)

  5.999,99 (precio europeo)

  0,11

  0,00

Answer 6

Actualmente estoy trabajando en una pequeña función usando expresiones regulares para obtener la cantidad de precio dentro de una cadena:

private static String getPrice(String input) 
{ 
    String output = ""; 

    Pattern pattern = Pattern.compile("\\d{1,3}[,\\.]?(\\d{1,2})?"); 
    Matcher matcher = pattern.matcher(input); 
    if (matcher.find()) 
    { 
     output = matcher.group(0); 
    } 

    return output; 
} 

esto parece funcionar con un precio pequeño (0,00 a 999,99) y varias monedas:

$ 12.34 -> 12,34

$ 12,34 -> 12,34

$ 12,00 -> 12.00

$ 12 -> 12

12 € -> 12

12,11 € -> 12,11

12,999 € -> 12,99

12,9 € -> 12,9

999.99 £

€ -> 999,99

...

Answer 7

^[0-9] + [0-9] {2} $

aquí es una que permite:.??

0,12, 12,01, etc

y lo hace no permite 12., 12.1, 19.0.0, etc.

Answer 8

No estaba satisfecho con las respuestas anteriores. Aquí está mi opinión sobre ella:

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

|^^^^^^|^^^^^^^^^^^^^|^^^^^^^^^^^| 
| 1-3 | 3 digits | 2 digits | 
|digits| repeat any |   | 
|  | no. of  |   | 
|  | times  |   | 

(obtener una explicación detallada aquí: https://regex101.com/r/cG6iO8/1)

abarca todos los casos por debajo de

• 5,00
• 1.000
• 1,000,000.99
• 5 , 99 (precio europeo)
• 5.999,99 (precio europeo)
• 0,11
• 0,00

Pero también cosas raras como

• 5.000,000.00

En caso de que desee incluir y 5 1000 (Yo personalmente no he querido combinar TODOS los números), entonces solo agregue un "?" como ese:

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

Answer 9

Estoy trabajando en un problema similar. Sin embargo, solo quiero hacer coincidir si un Símbolo o Cadena de moneda también está incluido en la Cadena como EUR, €, USD o $. El símbolo puede estar al final o al frente. No me importa si hay espacio entre la subcadena Number y the Currency. Basé la coincidencia de números en la discusión anterior y utilicé el Número de precio: \ d {1,3} (?: [.,] \ D {3}) * (?: [.,] \ D {2})?

Aquí está el resultado final:

(USD|EUR|€|\$)\s?(\d{1,3}(?:[.,]\d{3})*(?:[.,]\d{2}))|(\d{1,3}(?:[.,]\d{3})*(?:[.,]\d{2})?)\s?(USD|EUR|€|\$) 

utilizo (\d{1,3}(?:[.,]\d{3})*(?:[.,]\d{2})?)\s?(USD|EUR|€|\$) como un patrón que corresponda contra un símbolo de moneda (aquí con la tolerancia para un espacio inicial).Creo que se puede ajustar fácilmente para cualquier otra moneda

una esencia con la última versión se puede encontrar en https://gist.github.com/wischweh/b6c0ac878913cca8b1ba

Answer 10

Este código funcionó para mí !! (PHP)

preg_match_all('/\d+((,\d+)+)?(.\d+)?(.\d+)?(,\d+)?/',$price[1]->plaintext,$lPrices); 

Answer 11

Hasta ahora he intentado, esta es la mejor

\d{1,3}[,\\.]?(\\d{1,2})?

https://regex101.com/r/xT8aQ7/1

Answer 12

Ésta razonablemente funciona cuando se puede o no puede tener parte decimal, pero una cantidad espectáculos hasta 100.000 - o 100,000.00. Clojure probado utilizando sólo

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