regular - regex test

¿Cuál es el "mejor" registro de divisas de los EE. UU.?

Question

Una búsqueda rápida de expresiones regulares de divisas trae muchos resultados .
MSDN usa ^-?/d+(/./d{2})?$

El problema que tengo al elegir uno de estos es que Regex es difícil de verificar sin probar todos los casos extremos. Podría dedicar mucho tiempo a esto, ya que estoy seguro de que otros cientos de desarrolladores ya lo hicieron.

Entonces ... ¿Alguien tiene una expresión regular para moneda estadounidense que haya sido probada exhaustivamente ?

Mi único requisito es que la cadena coincidente sea la moneda de los EE. UU. Y analice System.Decimal :

[ws][sign][digits,]digits[.fractional-digits][ws] Elements in square brackets ([ and ]) are optional. The following table describes each element. ELEMENT DESCRIPTION ws Optional white space. sign An optional sign. digits A sequence of digits ranging from 0 to 9. , A culture-specific thousands separator symbol. . A culture-specific decimal point symbol. fractional-digits A sequence of digits ranging from 0 to 9.

Answer 1

Aquí hay algunas cosas de los creadores de Regex Buddy. Estos vinieron de la biblioteca, así que estoy seguro de que han sido probados a fondo.

Número: Monto de moneda (centavos obligatorios) Separadores de miles opcionales; fracción obligatoria de dos dígitos

Match; JGsoft:
^[+-]?[0-9]{1,3}(?:,?[0-9]{3})*/.[0-9]{2}$

Número: Monto de moneda (centavos opcionales) Separadores de miles opcionales; fracción opcional de dos dígitos

Match; JGsoft:
^[+-]?[0-9]{1,3}(?:,?[0-9]{3})*(?:/.[0-9]{2})?$

Número: Monto en moneda US y EU (centavos opcionales) Puede usar la notación 123.456.78 al estilo estadounidense y la anotación 123.456,78 al estilo europeo. Separadores de miles opcionales; fracción opcional de dos dígitos

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

Answer 2

En caso de que desee contabilizar un error humano, podría hacer que la expresión regular sea más indulgente al hacer coincidir la moneda. Utilicé la segunda expresión regular de Keng y la hice un poco más robusta para dar cuenta de los errores tipográficos.

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

Esto coincidirá con cualquiera de estas cifras monetarias correctas o arruinadas, pero no recogerá la basura adicional al final después del espacio:

$46,48382
$4,648,382
$ 4,648,382
$4,648,382.20
$4,648,382.2
$4,6483,82.20
$46,48382 70.25PD
$ 46,48382 70.25PD

Answer 3

Encontré esta expresión regular en línea en www.RegExLib.com por Kirk Fuller, Gregg Durishan

Lo he estado usando con éxito durante los últimos años.

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

Answer 4

Esta pregunta tiene algunos años, así que quería dar una respuesta actualizada.

He usado jQuery InputMask y funciona muy bien para enmascaramiento de entrada / formato (como números de teléfono, etc.) pero realmente no funciona bien para moneda según mi experiencia.

Para la moneda, recomiendo el plugin jQuery autoNumeric . Está bien mantenido y básicamente han "pensado en todo" lo que podría desear para la divisa.

De hecho, uso una combinación de estos dos complementos para formatear números de teléfono, formatos de números (ISBN, etc.), así como monedas (principalmente, moneda estadounidense).

Tenga en cuenta que jquery.inputmask trata principalmente de controlar el formato de un valor, mientras que autoNumeric trata de controlar específicamente el formato de la moneda.

Answer 5

Estaba mirando esto también y he llegado a la conclusión de que es mejor construir la expresión regular en función de la cultura actual. Podemos usar el

CurrencyPositivePattern 
CurrencyGroupSeparator
CurrencyDecimalSeparator

propiedades de NumberFormatInfo para obtener el formato requerido.

Editar: algo como esto

NumberFormatInfo nfi = CultureInfo.CurrentCulture.NumberFormat;
      // Assign needed property values to variables.
      string currencySymbol = nfi.CurrencySymbol;
      bool symbolPrecedesIfPositive = nfi.CurrencyPositivePattern % 2 == 0;
      string groupSeparator = nfi.CurrencyGroupSeparator;
      string decimalSeparator = nfi.CurrencyDecimalSeparator;

      // Form regular expression pattern.
      string pattern = Regex.Escape( symbolPrecedesIfPositive ? currencySymbol : "") + 
                       @"/s*[-+]?" + "([0-9]{0,3}(" + groupSeparator + "[0-9]{3})*(" + 
                       Regex.Escape(decimalSeparator) + "[0-9]+)?)" + 
                       (! symbolPrecedesIfPositive ? currencySymbol : ""); 

consulte - http://msdn.microsoft.com/en-us/library/hs600312.aspx

Answer 6

Esto es lo que uso:

Sin liderar + o -

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

Con lead + o - opcional

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

violín neto: https://jsfiddle.net/compsult/9of63cwk/12/

Answer 7

Estoy usando la siguiente expresión regular para la validación de moneda:

^-?0*(?:/d+(?!,)(?:/./d{1,2})?|(?:/d{1,3}(?:,/d{3})*(?:/./d{1,2})?))$

También puede permitir el signo de dólar principal opcional:

^/$?-?0*(?:/d+(?!,)(?:/./d{1,2})?|(?:/d{1,3}(?:,/d{3})*(?:/./d{1,2})?))$

Puede agregar fácilmente pruebas para paréntesis en lugar de firmar agregando

/( and /)

Answer 8

He tenido éxito con esto (tomando partes y piezas de algunas de las expresiones regulares anteriores). Solo maneja hasta miles, pero no debería ser demasiado difícil de extender

case class CurrencyValue(dollars:Int,cents:Int)
def cents = """[/./,]""".r ~> """/d{0,2}""".r ^^ {
  _.toInt
}
def dollarAmount: Parser[Int] = """[1-9]{1}[0-9]{0,2}""".r ~ opt( """[/./,]""".r ~> """/d{3}""".r) ^^ {
  case x ~ Some(y) => x.toInt * 1000 + y.toInt
  case x ~ None => x.toInt
}
def usCurrencyParser = """(/$/s*)?""".r ~> dollarAmount ~ opt(cents) <~ opt( """(?i)dollars?""".r) ^^ {
  case d ~ Some(change) => CurrencyValue(d, change)
  case d ~ None => CurrencyValue(d, 0)
}

Answer 9

La respuesta de Keng es perfecta, solo quiero agregar eso para trabajar con 1 o 2 decimales (para la tercera versión):

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

NET FIDDLE: https://dotnetfiddle.net/1mUpX2

Answer 10

No se ha probado del todo (¡lo acabo de escribir!), Pero parece que se comporta correctamente:

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

Equipo de prueba:

0
1
33
555
4,656
4656
99,785
125,944
7,994,169
7994169
0.00
1.0
33.78795
555.12
4,656.489
99,785.01
125,944.100
-7,994,169
-7994169.23 // Borderline...

Wrong:
000
01
3,3
5.
555,
,656
99,78,5
1,25,944
--7,994,169
0.0,0
.10
33.787,95
4.656.489
99.785,01
1-125,944.1
-7,994E169

Nota: Su System.Decimal depende de la configuración regional, es difícil de crear en expresiones regulares, excepto tal vez al compilarlo. Supuse que los dígitos estaban agrupados por tres, incluso si en algunas culturas (locales) existen diferentes reglas.
Es trivial agregar espacios en blanco a su alrededor.

Answer 11

Utilizando la respuesta de Leandro agregué ^(?:[$]|) principio para permitir un signo de dólar anterior

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

Esto emparejado

136,402.99
25.27
0.33
$584.56
1
00.2
3,254,546.00
$3,254,546.00
00.01
-0.25
+0.85
+100,052.00

No emparejaron

11124.52
234223425.345
234.
.5234
a
a.23
32.a
a.a
z548,452.22
u66.36