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 gli interi.

I token di espressioni regolari validi variano in base all’implementazione. La forma più generica che conosco sarebbe:

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

Il più compatto:

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

Entrambi presuppongono che sia necessario avere almeno una cifra prima e una dopo la cifra decimale.

Per richiedere che l’intera stringa sia un numero di questo modulo, avvolgere l’espressione nei tag iniziale e finale come (nel modulo Perl):

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

AGGIUNTA: Avvolto la parte frazionaria in ()? per renderlo opzionale. Essere consapevoli del fatto che questo esclude forms come “12.” Includere quello sarebbe più come ^\d+\.?\d{0,2}$ .

Aggiunto: usa questo formato ^\d{1,6}(\.\d{1,2})?$ Per interrompere la ripetizione e dare una restrizione a tutta la parte del valore decimale.

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

E poiché le espressioni regolari sono orribili da leggere, e tanto meno capire, ecco l’equivalente verboso:

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

È ansible sostituire [0-9] con \d nella maggior parte delle implementazioni di espressioni regolari (incluso PCRE , il più comune). L’ho lasciato come [0-9] perché 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 opzionale e per disabilitare numeri come 015 (che possono essere scambiati per numeri ottali) scrivi:

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

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

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

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

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

Quest’ultimo corrisponde
1
100
100.
100.74
100.7
0.7
.7
.72

E non corrisponde alla stringa vuota (come \ d *.? \ D * would)

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

Farà cose come 12. accettato. Questo non è ciò che è comunemente accettato, ma se nel caso hai bisogno di essere “flessibile”, questo è un modo per andare. E naturalmente [0-9] può essere sostituito con \d , ma immagino che sia più leggibile in questo modo.

Lo uso 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:
.25
0.25
10.25
0,25

non passa:
-.25
01.25
1.
1.256

Prova questo

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

Permetterà anche segni positivi e negativi.

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

In generale, ovvero cifre decimali illimitate:

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

Non è necessario prendere in considerazione la e in e666.76 ?

Con

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

aggiungendo anche la mia risposta, qualcuno potrebbe trovarlo utile o potrebbe essere corretto anche il mio.

 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 float e il gruppo 2 è solo la frazione.

Ho provato uno con il mio progetto. Questo consente numeri con + | - + | - segni anche.

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

Chrome 56 non accetta questo tipo di pattern (Chrome 56 accpette 11.11. Un altro.) Con il numero del tipo, usa il tipo di testo come avanzamento.

Risposta principale valida 5. o 5, ingressi

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

 /^[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 => “7” / true => “7.654”

Ciò consentirà 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 valuterà qualsiasi numero decimale, il numero del tempo ha o meno le cifre decimali, dirà “Numero corretto” altrimenti “Si prega di inserire solo numeri in numero di testo”. verrà visualizzato un messaggio di avviso.

Grazie… 🙂