Expressão regular simples para um decimal com uma precisão de 2

Qual é a expressão regular de um decimal com uma precisão de 2?

Exemplos válidos :

123.12
2
56754
92929292929292.12
0.21
3.1

Exemplos inválidos:

12.1232
2.23332
e666.76

O ponto decimal pode ser opcional e números inteiros também podem ser incluídos.

Os tokens de regex válidos variam de acordo com a implementação. Um formulário genérico é:

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

Mais compacto:

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

Ambos assumem que ambos têm pelo menos um dígito antes e um após a casa decimal.

Para exigir que a cadeia inteira seja um número desse formulário, envolva a expressão nas tags de início e fim, como (no formulário do Perl):

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

Para corresponder números sem um dígito à esquerda antes do decimal ( .12) e números inteiros com um ponto final ( 12.), excluindo a entrada de um único ponto ( .), tente o seguinte:

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

Adicionado

Enrole a parte fracionária ()?para torná-la opcional. Esteja ciente de que isso exclui formulários como 12. Incluir que seriam mais parecidos ^\d+\\.?\d{0,2}$.

Adicionado

Use ^\d{1,6}(\.\d{1,2})?$para interromper a repetição e restringir a parte inteira do valor decimal.

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

E como as expressões regulares são horríveis de ler, muito menos entender, aqui está o equivalente detalhado:

^                         # 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

Você pode substituir [0-9]com \dna maioria das implementações de expressões regulares (incluindo PCRE , o mais comum). Deixei como [0-9]acho mais fácil de ler.

Além disso, aqui está o script Python simples que eu usei para verificá-lo:

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 um sinal de menos opcional e não permitir números como 015(que podem ser confundidos com números octais), escreva:

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

Para números que não possuem separador de milhares, eu gosto desse regex simples e compacto:

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

ou, para não se limitar a uma precisão de 2:

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

O último corresponde a
1
100
100.
100,74
100,7
0,7
.7
0,72

E não corresponde a uma string vazia (como \ d *.? \ D * faria)

Eu uso este para até duas casas decimais:
(^(\+|\-)(0|([1-9][0-9]*))(\.[0-9]{1,2})?$)|(^(0{0,1}|([1-9][0-9]*))(\.[0-9]{1,2})?$) passa:
0,25
0,25
10,25
0,25

não passa:
-.25
01.25
1.
1.256

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

Vai fazer coisas como 12.aceitas. Não é isso que é comumente aceito, mas se você precisar ser "flexível", esse é um caminho a percorrer. E, claro, [0-9]pode ser substituído por \d, mas acho que é mais legível dessa maneira.

Tente isto

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

Permitirá também sinais positivos e negativos.

A resposta principal está ERRADA porque valida 5.ou 5,insere

este código lida com isso (mas no meu exemplo, números negativos são proibidos):

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

os resultados são abaixo:

verdadeiro => "0" / verdadeiro => "0,00" / verdadeiro => "0,0" / verdadeiro => "0,00" / verdadeiro => "0,0" / verdadeiro => "1,2" verdadeiro => "1.1" / verdadeiro => "1" / verdadeiro => "100" verdadeiro => "100,00" / verdadeiro => "100,0" / verdadeiro => "1,11" / verdadeiro => "1,11" / falso => "-5" / falso => ​​"-0,00" / verdadeiro => "101" / falso => ​​"0,00,0" / verdadeiro => "0,000" / verdadeiro => "000,25" / falso => ​​"0,25" / verdadeiro => "100.01" / verdadeiro => "100.2" / verdadeiro => "00" / falso => ​​"5." / false => "6" / true => "82" / true => "81,3" / true => "

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

Em geral, ou seja, casas decimais ilimitadas:

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

Você não terá que tomar a eem e666.76em conta?

Com

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

adicionando minha resposta também, alguém pode achar útil ou pode estar correto também.

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


alert(getInteger('-11.11'));

Isso funcionou comigo:

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

O grupo 1 é o número do seu float e o grupo 2 é apenas a fração.

Eu tentei um com o meu projeto. Isso permite números com + | -sinais também.

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

O Chrome 56 não está aceitando esse tipo de padrão (o Chrome 56 está aceitando o 11.11. Um adicional.) Com o número do tipo, use o tipo como texto como progresso.

Isso permitirá decimal com exponenciação e até 2 dígitos,

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

Demo

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

A função validará qualquer número decimal que o número do tempo tenha casas decimais ou não; será exibido "Número certo", caso contrário, "Digite apenas números na caixa de texto do valor". a mensagem de alerta será exibida.

Obrigado... :)