Espressione regolare numero decimale, dove la cifra dopo il decimale è facoltativa

Ho bisogno di un'espressione regolare che convalidi un numero, ma non richiede una cifra dopo il decimale. vale a dire.

123
123.
123.4

sarebbero tutti validi

123..

non sarebbe valido

Qualunque sarebbe molto apprezzato!

Utilizza il seguente:

/^\d*\.?\d*$/

• ^ - Inizio della linea;
• \d* - 0 o più cifre;
• \.?- Un punto opzionale (con escape, perché in regex, .è un carattere speciale);
• \d* - 0 o più cifre (la parte decimale);
• $ - Fine della linea.

Ciò consente di 0,5 decimali anziché richiedere lo zero iniziale, ad esempio 0,5

/\d+\.?\d*/

Una o più cifre ( \d+), punto facoltativo ( \.?), zero o più cifre ( \d*).

A seconda dell'utilizzo o del motore regex potrebbe essere necessario aggiungere ancore di linea di inizio / fine:

/^\d+\.?\d*$/

Debuggex Demo

Hai bisogno di un'espressione regolare come la seguente per farlo correttamente:

/^[+-]?((\d+(\.\d*)?)|(\.\d+))$/

La stessa espressione con spazi bianchi, utilizzando il modificatore esteso (come supportato da Perl):

/^  [+-]? ( (\d+ (\.\d*)?)  |  (\.\d+) ) $/x

o con commenti:

/^           # Beginning of string
 [+-]?       # Optional plus or minus character
 (           # Followed by either:
   (           #   Start of first option
     \d+       #   One or more digits
     (\.\d*)?  #   Optionally followed by: one decimal point and zero or more digits
   )           #   End of first option
   |           # or
   (\.\d+)     #   One decimal point followed by one or more digits
 )           # End of grouping of the OR options
 $           # End of string (i.e. no extra characters remaining)
 /x          # Extended modifier (allows whitespace & comments in regular expression)

Ad esempio, corrisponderà a:

• 123
• 23.45
• 34.
• .45
• -123
• -273,15
• -42.
• -.45
• 516
• 9,8
• +2.
• +.5

E rifiuterà questi non numeri:

• . (punto decimale singolo)
• -. (punto decimale negativo)
• +. (più punto decimale)
• (stringa vuota)

Le soluzioni più semplici possono rifiutare erroneamente numeri validi o abbinare questi non numeri.

Prova questa regex:

\d+\.?\d*

\ d + cifre prima del decimale facoltativo
.? decimale facoltativo (facoltativo a causa del? quantificatore)
\ d * cifre facoltative dopo il decimale

Penso che questo sia il migliore perché soddisfa tutti i requisiti:

^\d+(\\.\d+)?$

Ho finito per usare quanto segue:

^\d*\.?\d+$

Ciò rende non valido quanto segue:

.
3.

puoi usare questo:

^\d+(\.\d)?\d*$

partite:
11
11.1
0.2

non corrisponde a:
.2
2.
2.6.9

Quale lingua? In stile Perl:^\d+(\.\d*)?$

Questo è quello che ho fatto. È più rigoroso di quanto sopra (e più corretto di alcuni):

^0$|^[1-9]\d*$|^\.\d+$|^0\.\d*$|^[1-9]\d*\.\d*$

Stringhe che passano:

0
0.
1
123
123.
123.4
.0
.0123
.123
0.123
1.234
12.34

Stringhe che falliscono:

.
00000
01
.0.
..
00.123
02.134

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

dovrebbe riflettere ciò che le persone normalmente pensano come un numero decimale ben formato.

Le cifre prima del punto decimale possono essere una singola cifra, nel qual caso può essere compresa tra 0 e 9, o più di una cifra, nel qual caso non può iniziare con uno 0.

Se sono presenti cifre prima del segno decimale, il decimale e le cifre che seguono sono opzionali. In caso contrario, deve essere presente un decimale seguito da almeno una cifra. Nota che sono consentiti più 0 finali dopo il punto decimale.

grep -E '^[+-]?(([1-9][0-9]*)?[0-9](\.[0-9]*)?|\.[0-9]+)$'

corrisponde correttamente a quanto segue:

9
0
10
10.
0.
0.0
0.100
0.10
0.01
10.0
10.10
.0
.1
.00
.100
.001

così come i loro equivalenti firmati, mentre rifiuta quanto segue:

.
00
01
00.0
01.3

e i loro equivalenti con segno, così come la stringa vuota.

(?<![^d])\d+(?:\.\d+)?(?![^d])

pulito e semplice.

Questo utilizza Suffix e Prefix, caratteristiche RegEx.

Restituisce direttamente true - false per la condizione IsMatch

^\d+(()|(\.\d+)?)$

È venuto con questo. Consente sia numeri interi che decimali, ma forza un decimale completo (numeri iniziali e finali) se si decide di inserire un decimale.

Ciò che hai chiesto ha già una risposta, quindi questa è solo un'informazione aggiuntiva per coloro che vogliono solo 2 cifre decimali se viene inserito il punto decimale opzionale:

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

^: inizio della stringa
\ d: una cifra (uguale a [0-9])
+: una volta e illimitate

Acquisizione del gruppo (. \ D {2})?
? : zero e una volta. : carattere .
\ d: una cifra (uguale a [0-9])
{2}: esattamente 2 volte
$: fine della stringa

1: corrispondenza
123: corrispondenza
123.00: corrispondenza
123.: nessuna corrispondenza
123 ..: nessuna corrispondenza
123.0: nessuna corrispondenza
123.000: nessuna corrispondenza
123.00.00: nessuna corrispondenza

In Perl, usa Regexp :: Common che ti permetterà di assemblare un'espressione regolare finemente sintonizzata per il tuo particolare formato numerico. Se non stai usando Perl, l'espressione regolare generata può ancora essere tipicamente usata da altri linguaggi.

Stampa del risultato della generazione delle espressioni regolari di esempio in Regexp :: Common :: Number:

$ perl -MRegexp::Common=number -E 'say $RE{num}{int}'
(?:(?:[-+]?)(?:[0123456789]+))

$ perl -MRegexp::Common=number -E 'say $RE{num}{real}'
(?:(?i)(?:[-+]?)(?:(?=[.]?[0123456789])(?:[0123456789]*)(?:(?:[.])(?:[0123456789]{0,}))?)(?:(?:[E])(?:(?:[-+]?)(?:[0123456789]+))|))

$ perl -MRegexp::Common=number -E 'say $RE{num}{real}{-base=>16}'
(?:(?i)(?:[-+]?)(?:(?=[.]?[0123456789ABCDEF])(?:[0123456789ABCDEF]*)(?:(?:[.])(?:[0123456789ABCDEF]{0,}))?)(?:(?:[G])(?:(?:[-+]?)(?:[0123456789ABCDEF]+))|))

prova questo. ^[0-9]\d{0,9}(\.\d{1,3})?%?$è testato e ha funzionato per me.