Espressione regolare semplice per un decimale con una precisione di 2

Qual è l'espressione regolare per un decimale con una precisione di 2?

Esempi validi :

123.12
2
56754
92929292929292.12
0.21
3.1

Esempi non validi:

12.1232
2.23332
e666.76

Il punto decimale può essere facoltativo e possono essere inclusi anche numeri interi.

I token regex validi variano in base all'implementazione. Un modulo generico è:

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

Più compatto:

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

Entrambi presumono che entrambi abbiano almeno una cifra prima e una dopo il decimale.

Per richiedere che l'intera stringa sia un numero di questo modulo, avvolgi l'espressione nei tag di inizio e fine come (nel modulo di Perl):

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

Per abbinare i numeri senza una cifra iniziale prima del numero decimale ( .12) e dei numeri interi che hanno un periodo finale ( 12.) mentre si esclude l'inserimento di un singolo punto ( .), provare quanto segue:

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

aggiunto

Avvolto la parte frazionaria ()?per renderla facoltativa. Essere consapevoli del fatto che ciò esclude forme come 12. Includere che sarebbe più simile ^\d+\\.?\d{0,2}$.

aggiunto

Usare ^\d{1,6}(\.\d{1,2})?$per fermare la ripetizione e dare una limitazione a tutta la parte del valore decimale.

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

E poiché le espressioni regolari sono orribili da leggere, tanto meno da capire, ecco l'equivalente dettagliato:

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

Puoi sostituirlo [0-9]con \dnella maggior parte delle implementazioni di espressioni regolari (incluso PCRE , il più comune). L'ho lasciato come [0-9]penso sia più facile da leggere.

Inoltre, ecco il semplice script Python che ho usato per controllarlo:

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

Per includere un segno meno facoltativo e non consentire numeri come 015(che possono essere scambiati per numeri ottali) scrivere:

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

Per i numeri che non hanno un separatore di migliaia, mi piace questa regex semplice e compatta:

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

o, per non essere limitato a una precisione di 2:

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

Quest'ultimo corrisponde a
1
100
100.
100,74
100,7
0,7
.7
.72

E non corrisponde a una stringa vuota (come \ d *.? \ D * sarebbe)

Io uso questo uno per un massimo di due cifre decimali:
(^(\+|\-)(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

non passa:
-.25
01.25
1.
1.256

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

Renderà le cose come 12.accettate. Questo non è ciò che è comunemente accettato, ma se è necessario essere "flessibili", questa è una strada da percorrere. E ovviamente [0-9]può essere sostituito con \d, ma immagino che sia più leggibile in questo modo.

Prova questo

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

Permetterà anche segni positivi e negativi.

La risposta principale è ERRATA perché valida 5.o5, ingressi

questo codice lo gestisce (ma nel mio esempio sono vietati i numeri negativi):

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

i risultati sono sotto:

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)

In generale, cioè decimali illimitati:

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

Non avrete bisogno di prendere il ein e666.76conto?

Con

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

aggiungendo anche la mia risposta, qualcuno potrebbe trovarla utile o potrebbe essere corretta anche la mia.

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


alert(getInteger('-11.11'));

Questo ha funzionato con me:

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

Il gruppo 1 è il numero del float e il gruppo 2 è solo la frazione.

Ne ho provato uno con il mio progetto. Ciò consente anche numeri con + | -segni.

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

Chrome 56 non accetta questo tipo di pattern (Chrome 56 accusa l'11.11. Un ulteriore.) Con il numero di tipo, usa il tipo come testo come progresso.

Ciò consentirà il decimale con esponenziazione e fino a 2 cifre,

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

dimostrazione

 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 funzione convaliderà qualsiasi numero decimale il numero meteorologico ha posizioni decimali o no, dirà "Numero giusto" altro saggio "Inserire solo i numeri nella casella di testo dell'importo". verrà visualizzato un messaggio di avviso.

Grazie... :)