Expresión regular simple para un decimal con una precisión de 2

¿Cuál es la expresión regular para un decimal con una precisión de 2?

Ejemplos válidos :

123.12
2
56754
92929292929292.12
0.21
3.1

Ejemplos inválidos:

12.1232
2.23332
e666.76

El punto decimal puede ser opcional y también se pueden incluir enteros.

Los tokens regex válidos varían según la implementación. Una forma genérica es:

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

Mas Compacto:

\d+(\.\d{1,2})?

Ambos suponen que ambos tienen al menos un dígito antes y uno después del decimal.

Para requerir que toda la cadena sea un número de esta forma, ajuste la expresión en etiquetas de inicio y fin, como (en la forma de Perl):

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

Para hacer coincidir los números sin un dígito .12inicial antes del decimal ( ) y los números enteros que tienen un punto final ( 12.) mientras excluye la entrada de un solo punto ( .), intente lo siguiente:

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

Adicional

Envuelto la porción fraccional ()?para hacerlo opcional. Tenga en cuenta que esto excluye formas como 12. Incluir que serían más similares ^\d+\\.?\d{0,2}$.

Adicional

Úselo ^\d{1,6}(\.\d{1,2})?$para detener la repetición y restringir toda la parte del valor decimal.

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

Y dado que las expresiones regulares son horribles de leer, mucho menos entender, aquí está el equivalente detallado:

^                         # Start of string
 [0-9]+                   # Require one or more numbers
       (                  # Begin optional group
        \.                # Point must be escaped or it is treated as "any character"
          [0-9]{1,2}      # One or two numbers
                    )?    # End group--signify that it's optional with "?"
                      $   # End of string

Puede reemplazar [0-9]con la \dmayoría de las implementaciones de expresiones regulares (incluidas PCRE , el más común). Lo dejé como [0-9]creo que es más fácil de leer.

Además, aquí está el script simple de Python que utilicé para verificarlo:

import re
deci_num_checker = re.compile(r"""^[0-9]+(\.[0-9]{1,2})?$""")

valid = ["123.12", "2", "56754", "92929292929292.12", "0.21", "3.1"]
invalid = ["12.1232", "2.23332", "e666.76"]

assert len([deci_num_checker.match(x) != None for x in valid]) == len(valid)
assert [deci_num_checker.match(x) == None for x in invalid].count(False) == 0

Para incluir un signo menos opcional y no permitir números como 015(que pueden confundirse con números octales) escriba:

-?(0|([1-9]\d*))(\.\d+)?

Para los números que no tienen un separador de miles, me gusta esta expresión regular simple y compacta:

\d+(\.\d{2})?|\.\d{2}

o, para no limitarse a una precisión de 2:

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

Este último coincide con
1
100
100.
100.74
100.7
0.7
.7
.72

Y no coincide con una cadena vacía (como \ d *.? \ D * would)

Utilizo este para hasta dos decimales:
(^(\+|\-)(0|([1-9][0-9]*))(\.[0-9]{1,2})?$)|(^(0{0,1}|([1-9][0-9]*))(\.[0-9]{1,2})?$) pasa:
.25
0.25
10.25
+0.25

no pasa:
-.25
01.25
1.
1.256

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

Hará cosas como 12.aceptadas. Esto no es lo que comúnmente se acepta, pero si necesita ser "flexible", ese es un camino a seguir. Y, por supuesto, [0-9]se puede reemplazar con \d, pero supongo que es más legible de esta manera.

Prueba esto

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

Permitirá signos positivos y negativos también.

La respuesta principal es INCORRECTA porque es válida 5.o5, entradas

este código lo maneja (pero en mi ejemplo los números negativos están prohibidos):

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

los resultados son abajo:

true => "0" / true => "0.00" / true => "0.0" / true => "0,00" / true => "0,0" / true => "1,2" true => "1.1" / true => "1" / true => "100" true => "100.00" / true => "100.0" / true => "1.11" / true => "1,11" / false => "-5" / false => "-0.00" / true => "101" / false => "0.00.0" / true => "0.000" / true => "000.25" / false => ".25" / true => "100.01" / true => "100.2" / true => "00" / false => "5." / false => "6," / true => "82" / true => "81,3" / true => "

preg_match("/^-?\d+[\.]?\d\d$/", $sum)

En general, es decir, decimales ilimitados:

^-?(([1-9]\d*)|0)(.0*[1-9](0*[1-9])*)?$.

¿No necesitarás tener een e666.76cuenta?

Con

(e|0-9)\d*\d.\d{1,2)

agregando mi respuesta también, alguien puede encontrarla útil o puede ser correcta la mía también.

function getInteger(int){
  var regx = /^[-+]?[\d.]+$/g;
  return regx.test(int);
}


alert(getInteger('-11.11'));

Esto funcionó conmigo:

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

El grupo 1 es su número flotante y el grupo 2 es solo la fracción.

Intenté uno con mi proyecto. Esto permite números con + | -signos también.

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

Chrome 56 no acepta este tipo de patrones (Chrome 56 está aceptando 11.11. Un adicional) con el número de tipo, use el tipo como texto como progreso.

Esto permitirá decimales con exponenciación y hasta 2 dígitos,

^[+-]?\d+(\.\d{2}([eE](-[1-9]([0-9]*)?|[+]?\d+))?)?$

Manifestación

 function DecimalNumberValidation() {
        var amounttext = ;
            if (!(/^[-+]?\d*\.?\d*$/.test(document.getElementById('txtRemittanceNumber').value))){
            alert('Please enter only numbers into amount textbox.')
            }
            else
            {
            alert('Right Number');
            }
    }

la función validará cualquier número decimal, el número de clima tiene decimales o no, dirá "Número correcto" de otra manera "Por favor ingrese solo números en el cuadro de texto de cantidad". aparecerá un mensaje de alerta.

Gracias... :)