Valori decimali o numerici nella convalida delle espressioni regolari

Sto cercando di utilizzare una convalida di espressioni regolari per verificare solo valori decimali o valori numerici. Ma l’utente inserisce il valore numerico, non è la prima cifra “0”

Come lo faccio?

Una cifra compresa tra 1 e 9 seguita da zero o più altre cifre:

^[1-9]\d*$ 

Per consentire numeri con un punto decimale opzionale seguito da cifre. Una cifra compresa tra 1 e 9 seguita da zero o più altre cifre, seguita opzionalmente da un punto decimale seguito da almeno 1 cifra:

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

Gli appunti:

  • Il ^ e $ anchor all’inizio e alla fine dicono sostanzialmente che l’intera stringa deve corrispondere al modello

  • ()? corrisponde a 0 o 1 dell’intera cosa tra parentesi

Aggiornamento per gestire le virgole:

In espressioni regolari . ha un significato speciale – abbina ogni singolo personaggio. Per abbinare letteralmente a . in una stringa devi sfuggire al . usando \. Questo è il significato del \. nelle regexp sopra. Quindi, se vuoi usare la virgola, il pattern è semplicemente:

 ^[1-9]\d*(,\d+)?$ 

Ulteriore aggiornamento per gestire virgole e punti fermi

Se vuoi consentire a . tra gruppi di cifre e a , tra l’integrale e le parti frazionarie, quindi provare:

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

cioè questa è una cifra compresa tra 1 e 9 seguita da un massimo di 2 altre cifre, quindi zero o più gruppi di un punto, seguiti da 3 cifre, opzionalmente la virgola e le cifre come prima.

Se vuoi consentire a . ovunque tra le cifre quindi provare:

 ^[1-9][\.\d]*(,\d+)?$ 

cioè una cifra 1-9 seguita da zero o più cifre o punti fermi opzionalmente seguiti da una virgola e una o più cifre.

In realtà, nessuna delle risposte fornite copre completamente la richiesta.
Poiché l’OP non ha fornito un caso d’uso specifico o tipi di numeri, cercherò di coprire tutti i possibili casi e permutazioni.

Numeri regolari

Tutto positivo

Questo numero viene solitamente chiamato intero senza segno , ma puoi anche chiamarlo un numero non frazionario positivo, includendo zero. Questo include numeri come 0 , 1 e 99999 .
L’espressione regolare che copre questa convalida è:

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

Prova questo Regex

Tutto positivo e negativo

Questo numero viene solitamente chiamato intero con segno , ma puoi anche chiamarlo un numero non frazionario. Questo include numeri come 0 , 1 , 99999 , -99999 , -1 e -0 .
L’espressione regolare che copre questa convalida è:

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

Prova questo Regex

Come probabilmente avrai notato, ho incluso anche -0 come numero valido. Ma alcuni potrebbero discutere di questo uso e dire che questo non è un numero reale (puoi leggere di più su Signed Zero qui ). Quindi, se vuoi escludere questo numero da questa regex, ecco cosa dovresti usare invece:

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

Prova questo Regex

Tutto quello che ho aggiunto è (? , che significa non includere -0 prima di questa asserzione. Questa (? asserzione chiamata lookbehind negativo , il che significa che qualsiasi frase sostituisce il ... non dovrebbe comparire prima di questa asserzione. Lookbehind ha delle limitazioni, come la frase non può includere quantificatori. Ecco perché, in alcuni casi, userò Lookahead, che è lo stesso, ma in modo opposto.

Molti sapori di espressioni regolari, inclusi quelli usati da Perl e Python, consentono solo stringhe a lunghezza fissa. Puoi utilizzare testo letterale, caratteri escape, escape Unicode diversi da \X e classi di caratteri. Non è ansible utilizzare quantificatori o backreferences. È ansible utilizzare l'alternanza, ma solo se tutte le alternative hanno la stessa lunghezza. Questi aromi valutano il lookbehind risalendo prima attraverso la stringa del sobject per il numero di caratteri richiesto dal lookbehind, e quindi tentando la regex all'interno del lookbehind da sinistra a destra.

Puoi leggere di più le asserzioni Lookaround qui .

Numeri frazionari

Positivo

Questo numero viene solitamente chiamato float senza segno o double senza segno , ma puoi anche chiamarlo un numero frazionario positivo, includere zero. Questo include numeri come 0 , 1 , 0.0 , 0.1 , 1.0 , 99999.000001 , 5.10 .
L'espressione regolare che copre questa convalida è:

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

Prova questo Regex

Alcuni potrebbero dire che numeri come .1 , .0 e .00651 (uguali a 0.1 , 0.0 e 0.00651 rispettivamente) sono anche numeri frazionari validi, e non posso essere in disaccordo con essi. Quindi ecco una regex che supporta ulteriormente questo formato:

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

Prova questo Regex

Negativo e positivo

Questo numero di solito è chiamato float firmato o doppio firmato , ma puoi anche chiamarlo un numero frazionario. Questo include numeri come 0 , 1 , 0.0 , 0.1 , 1.0 , 99999.000001 , 5.10 , -0 , -1 , -0.0 , -0.1 , -99999.000001 , 5.10 .
L'espressione regolare che copre questa convalida è:

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

Prova questo Regex

Per i non credenti -0 :

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

Prova questo Regex

Per coloro che vogliono supportare anche le rappresentazioni zero invisibili, come .1 , -.1 , usa la seguente -.1 :

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

Prova questo Regex

La combinazione di credenti non- -0 e credenti zero invisibili, usa questa regex:

 /^(?!-0?(\.0+)?$)-?(0|[1-9]\d*)?(\.\d+)?(?<=\d)$/ 

Prova questo Regex

Numeri con notazione scientifica (notazione esponenziale AKA)

Alcuni potrebbero voler supportare nelle loro validazioni, numeri con un carattere scientifico e , che è, a proposito, un numero assolutamente valido, è creato per rappresentare a breve numeri molto lunghi. Puoi leggere ulteriori informazioni su Notazione scientifica qui . Questi numeri di solito assomigliano a 1e3 (che è 1000 ), 1e-3 (che è 0.001) e sono pienamente supportati da molti dei principali linguaggi di programmazione (es. JavaScript). Puoi testarlo controllando se l'espressione '1e3'==1000 restituisce true .
Dividerò il supporto per tutte le sezioni precedenti, compresi i numeri con notazione scientifica.

Numeri regolari

Convalida regex di numeri interi positivi, supporta numeri come 6e4 , 16e-10 , 0e0 ma anche numeri regolari come 0 , 11 :

 /^(0|[1-9]\d*)(e-?(0|[1-9]\d*))?$/i 

Prova questo Regex

Tutta la convalida regex di numeri positivi e negativi, supporta numeri come -6e4 , -16e-10 , -0e0 ma anche numeri regolari come -0 , -11 e tutti i numeri positivi -0e0 sopra:

 /^-?(0|[1-9]\d*)(e-?(0|[1-9]\d*))?$/i 

Prova questo Regex

Numero intero positivo e negativo di convalida regex per non-credenti, come sopra, tranne che ora proibisce numeri come -0 , -0e0 , -0e5 e -0e-6 :

 /^(?!-0)-?(0|[1-9]\d*)(e-?(0|[1-9]\d*))?$/i 

Prova questo Regex

Numeri frazionari

Convalida regex del numero positivo, supporta anche i numeri interi sopra, più i numeri come 0.1e3 , 56.0e-3 , 0.0e10 e 1.010e0 :

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

Prova questo Regex

Numero positivo con convalida regex del supporto zero invisibile, supporta anche i numeri positivi sopra, in aggiunta numeri come .1e3 , .0e0 , .0e-5 e .1e-7 :

 /^(0|[1-9]\d*)?(\.\d+)?(?<=\d)(e-?(0|[1-9]\d*))?$/i 

Prova questo Regex

Convalida regex di numeri negativi e positivi, supporta i numeri positivi sopra, ma anche numeri come -0e3 , -0.1e0 , -56.0e-3 e -0.0e10 :

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

Prova questo Regex

Convalida regex di numeri negativi e positivi per non credenti, come sopra, tranne che ora proibisce numeri come -0 , -0.00000 , -0.0e0 , -0.00000e5 e -0e-6 :

 /^(?!-0(\.0+)?(e|$))-?(0|[1-9]\d*)(\.\d+)?(e-?(0|[1-9]\d*))?$/i 

Prova questo Regex

Numero negativo e positivo con convalida regex del supporto zero invisibile, supporta anche i numeri positivi e negativi sopra indicati, in aggiunta numeri come -.1e3 , -.0e0 , -.0e-5 e -.1e-7 :

 /^-?(0|[1-9]\d*)?(\.\d+)?(?<=\d)(e-?(0|[1-9]\d*))?$/i 

Prova questo Regex

Numero negativo e positivo con la combinazione di credenti non- -0 e credenti zero invisibili, come sopra, ma vieta numeri come -.0e0 , -.0000e15 e -.0e-19 :

 /^(?!-0?(\.0+)?(e|$))-?(0|[1-9]\d*)?(\.\d+)?(?<=\d)(e-?(0|[1-9]\d*))?$/i 

Prova questo Regex

Numeri con rappresentazione esadecimale

In molti linguaggi di programmazione, la rappresentazione di stringa del numero esadecimale come 0x4F7A può essere facilmente 0x4F7A nel numero decimale 20346 .
Pertanto, si potrebbe desiderare di supportarlo nel suo script di convalida.
La seguente espressione regolare supporta solo rappresentazioni di numeri esadecimali:

 /^0x[0-9a-f]+$/i 

Prova questo Regex

Tutte le permutazioni

Queste ultime espressioni regolari supportano i numeri zero invisibili.

Significati Zero credenti

 /^(-?(0|[1-9]\d*)?(\.\d+)?(?<=\d)(e-?(0|[1-9]\d*))?|0x[0-9a-f]+)$/i 

Prova questo Regex

Credenti Zero non firmati

 /^((?!-0?(\.0+)?(e|$))-?(0|[1-9]\d*)?(\.\d+)?(?<=\d)(e-?(0|[1-9]\d*))?|0x[0-9a-f]+)$/i 

Prova questo Regex

Spero di aver coperto tutte le permutazioni numeriche supportate in molti linguaggi di programmazione.
In bocca al lupo!


Oh, ho dimenticato di menzionare che chi vuole convalidare un numero include un migliaio di separatori, dovresti pulire tutte le virgole ( , ) per prima cosa, dato che potrebbe esserci qualche tipo di separatore là fuori, non puoi in realtà coprirli tutti.
Ma puoi rimuoverli prima, prima della convalida del numero:

 //JavaScript function clearSeparators(number) { return number.replace(/,/g,''); } 

Ho avuto lo stesso problema, ma volevo anche “.25” per essere un numero decimale valido. Ecco la mia soluzione utilizzando JavaScript:

 function isNumber(v) { // [0-9]* Zero or more digits between 0 and 9 (This allows .25 to be considered valid.) // ()? Matches 0 or 1 things in the parentheses. (Allows for an optional decimal point) // Decimal point escaped with \. // If a decimal point does exist, it must be followed by 1 or more digits [0-9] // \d and [0-9] are equivalent // ^ and $ anchor the endpoints so tthe whole string must match. return v.trim().length > 0 && v.trim().match(/^[0-9]*(\.[0-9]+)?$/); } 

Dove è il mio metodo trim ()

 String.prototype.trim = function() { return this.replace(/(^\s*|\s*$)/g, ""); }; 

Matthew DesVoigne

Ho provato tutte le regex date ma sfortunatamente nessuna di esse supera questi test:

  String []goodNums={"3","-3","0","0.0","1.0","0.1"}; String []badNums={"001","-00.2",".3","3.","a",""," ","-"," -1","--1","-.1","-0", "2..3", "2-", "2...3", "2.4.3", "5-6-7"}; 

Ecco il meglio che ho scritto che supera tutti questi test:

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

inserisci la descrizione dell'immagine qui

Ecco una grande regex di lavoro per i numeri. Questo accetta il numero con virgole e decimali.

 /^-?(?:\d+|\d{1,3}(?:,\d{3})+)?(?:\.\d+)?$/ 

Ecco la mia espressione regolare per la convalida dei numeri:

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

Numeri validi:

 String []validNumbers={"3","-3","0","0.0","1.0","0.1","0.0001","-555","94549870965"}; 

Numeri non validi:

 String []invalidNumbers={"a",""," ","-","001","-00.2","000.5",".3","3."," -1","--1","-.1","-0"}; 

Prova questo codice, spero che ti possa aiutare

 String regex = "(\\d+)(\\.)?(\\d+)?"; for integer and decimal like 232 232.12 

/([0-9]+[.,]*)+/ corrisponde a qualsiasi numero con o senza virgola o punti

può abbinare

  122 122,354 122.88 112,262,123.7678 

bug: corrisponde anche a 262.4377,3883 (ma non importa in modo parcellizzato)

se hai bisogno di convalidare i decimali con punti, virgole, positivi e negativi prova questo:

 Object testObject = "-1.5"; boolean isDecimal = Pattern.matches("^[\\+\\-]{0,1}[0-9]+[\\.\\,]{1}[0-9]+$", (CharSequence) testObject); 

In bocca al lupo.

Di seguito è il perfetto per il requisito menzionato:

 ^[0-9]{1,3}(,[0-9]{3})*(([\\.,]{1}[0-9]*)|())$