Espressione regolare per abbinare numeri con o senza virgole e decimali nel testo

Sto cercando di individuare e sostituire tutti i numeri in un corpo di testo. Ho trovato alcuni regex di esempio, che quasi risolvono il problema, ma nessuno è ancora perfetto. Il problema che ho è che i numeri nel mio testo possono o non possono avere decimali e virgole. Per esempio:

“La volpe da 5000 libbre è saltata su un recinto del piede da 99,999,9999913”.

La regex dovrebbe restituire ” 5000 ” e ” 99,999.99998713 “. Gli esempi che ho trovato scomporre i numeri sulla virgola o sono limitati a due posizioni decimali. Sto iniziando a capire che regex è abbastanza per capire perché alcuni esempi sono limitati a due cifre decimali, ma non ho ancora imparato come superarlo e includere anche la virgola per ottenere l’intera sequenza.

Ecco la mia ultima versione:

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

Che restituisce ” 5000 “, ” 99,99 “, ” 9.99 ” e ” 998713 ” per il testo sopra.

EDIT: Poiché questo ha ottenuto molti punti di vista, vorrei iniziare dando a tutti quello che cercavano su Google:

 #ALL THESE REQUIRE THE WHOLE STRING TO BE A NUMBER #For numbers embedded in sentences, see discussion below #### NUMBERS AND DECIMALS ONLY #### #No commas allowed #Pass: (1000.0), (001), (.001) #Fail: (1,000.0) ^\d*\.?\d+$ #No commas allowed #Can't start with "." #Pass: (0.01) #Fail: (.01) ^(\d+\.)?\d+$ #### CURRENCY #### #No commas allowed #"$" optional #Can't start with "." #Either 0 or 2 decimal digits #Pass: ($1000), (1.00), ($0.11) #Fail: ($1.0), (1.), ($1.000), ($.11) ^\$?\d+(\.\d{2})?$ #### COMMA-GROUPED #### #Commas required between powers of 1,000 #Can't start with "." #Pass: (1,000,000), (0.001) #Fail: (1000000), (1,00,00,00), (.001) ^\d{1,3}(,\d{3})*(\.\d+)?$ #Commas required #Cannot be empty #Pass: (1,000.100), (.001) #Fail: (1000), () ^(?=.)(\d{1,3}(,\d{3})*)?(\.\d+)?$ #Commas optional as long as they're consistent #Can't start with "." #Pass: (1,000,000), (1000000) #Fail: (10000,000), (1,00,00) ^(\d+|\d{1,3}(,\d{3})*)(\.\d+)?$ #### LEADING AND TRAILING ZEROES #### #No commas allowed #Can't start with "." #No leading zeroes in integer part #Pass: (1.00), (0.00) #Fail: (001) ^([1-9]\d*|0)(\.\d+)?$ #No commas allowed #Can't start with "." #No trailing zeroes in decimal part #Pass: (1), (0.1) #Fail: (1.00), (0.1000) ^\d+(\.\d*[1-9])?$ 

Ora che questo è fuori mano, la maggior parte delle seguenti domande è intesa come commento su come una regex complessa può essere ottenuta se cerchi di essere intelligente con esso, e perché dovresti cercare alternative. Leggi a proprio rischio.


Questo è un compito molto comune, ma tutte le risposte che vedo qui fino ad ora accetteranno input che non corrispondono al tuo formato numerico, come ad esempio ,111 , 9,9,9 o persino .,,. . È abbastanza semplice da risolvere, anche se i numeri sono incorporati in un altro testo. IMHO tutto ciò che non riesce a tirare 1.234.56 e 1234- e solo quei numeri -out di abc22 1,234.56 9.9.9.9 def 1234 è una risposta sbagliata.

Prima di tutto, se non hai bisogno di fare tutto questo in una regex, non farlo. Una singola regex per due diversi formati numerici è difficile da mantenere anche quando non sono incorporati in altri testi. Quello che dovresti fare è dividere l’intera cosa su spazi bianchi, quindi eseguire due o tre regex più piccole sui risultati. Se questa non è un’opzione per te, continua a leggere.

Modello di base

Considerando gli esempi che hai fornito, ecco una semplice regex che consente praticamente qualsiasi intero o decimale nel formato 0000 e blocca tutto il resto:

 ^\d*\.?\d+$ 

Ecco uno che richiede 0,000 formato:

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

Mettili insieme e le virgole diventano facoltative finché sono coerenti:

 ^(\d*\.?\d+|\d{1,3}(,\d{3})*(\.\d+)?)$ 

Numeri incorporati

I modelli sopra richiedono che l’intero input sia un numero. Stai cercando numeri incorporati nel testo, quindi devi allentare quella parte. D’altra parte, non vuoi che veda catch22 e pensi che sia stato trovato il numero 22. Se stai usando qualcosa con supporto lookbehind (come .NET), questo è piuttosto facile: sostituire ^ con (? e $ con (?!\S) e sei a posto:

 (? 

Se stai lavorando con JavaScript o Ruby o qualcosa del genere, le cose iniziano ad apparire più complesse:

 (?:^|\s)(\d*\.?\d+|\d{1,3}(?:,\d{3})*(?:\.\d+)?)(?!\S) 

Dovrai usare i gruppi di cattura; Non riesco a pensare a un'alternativa senza un supporto apparente. I numeri che desideri saranno nel gruppo 1 (assumendo che l'intera corrispondenza sia Gruppo 0).

Validazione e regole più complesse

Penso che riguardi la tua domanda, quindi se è tutto ciò che serve, smetti di leggere ora. Se vuoi diventare più fan, le cose diventano molto complesse molto rapidamente. A seconda della situazione, potresti voler bloccare uno o tutti i seguenti elementi:

  • Input vuoto
  • Zeri iniziali (ad es. 000123)
  • Zero finali (es. 1.2340000)
  • Decimali che iniziano con il punto decimale (ad esempio, 0,001 rispetto a 0,001)

Giusto per il gusto, supponiamo che tu voglia bloccare i primi 3, ma permetti l'ultimo. Cosa dovresti fare? Ti dirò cosa dovresti fare, dovresti usare una regex diversa per ogni regola e ridurre progressivamente le tue partite. Ma per il gusto della sfida, ecco come si fa tutto in un unico modello gigante:

 (? 

Ed ecco cosa significa:

 (? 

Testato qui: http://rextester.com/YPG96786

Ciò consentirà cose come:

 100,000 999.999 90.0009 1,000,023.999 0.111 .111 0 

Bloccherà cose come:

 1,1,1.111 000,001.111 999. 0. 111.110000 1.1.1.111 9.909,888 

Ci sono diversi modi per rendere questa regex più semplice e più breve, ma capisci che la modifica del pattern allenterà ciò che considera un numero.

Poiché molti motori regex (ad es. JavaScript e Ruby) non supportano l'aspetto negativo, l'unico modo per farlo correttamente è con i gruppi di cattura:

 (:?^|\s)(?=.)((?:0|(?:[1-9](?:\d*|\d{0,2}(?:,\d{3})*)))?(?:\.\d*[1-9])?)(?!\S) 

I numeri che stai cercando saranno nel gruppo di cattura 1.

Testato qui: http://rubular.com/r/3HCSkndzhT

Un'ultima nota

Ovviamente, questa è una regex massiccia, complicata, quasi illeggibile. Mi è piaciuta la sfida, ma dovresti considerare se vuoi davvero usarlo in un ambiente di produzione. Invece di provare a fare tutto in un solo passaggio, potresti farlo in due: un'espressione regolare per catturare tutto ciò che potrebbe essere un numero, poi un altro per eliminare tutto ciò che non è un numero. Oppure puoi eseguire alcune operazioni di base, quindi utilizzare le funzioni di analisi dei numeri incorporate nella lingua. La tua scelta.

Alcuni giorni fa, ho lavorato sul problema di rimuovere gli zero finali dalla stringa di un numero .

Nella continuità di questo problema, trovo questo interessante perché allarga il problema ai numeri che contengono virgole.

Ho preso lo schema di regex che avevo scritto in quel problema precedente su cui ho lavorato e l’ho migliorato in modo che potesse trattare i numeri con virgole come risposta a questo problema.

Sono stato portato via con il mio entusiasmo e il mio interesse per le regex. Non so se il risultato si adatta esattamente al bisogno express da Michael Prescott. Sarei interessato a conoscere i punti che sono in eccesso o mancanti nella mia espressione regolare e correggerli per renderlo più adatto a te.

Ora, dopo una lunga sessione di lavoro su questo regex, ho una sorta di peso nel cervello, quindi non sono abbastanza fresco per dare molte spiegazioni. Se i punti sono oscuri e se qualcuno può essere interessato abbastanza, per favore, chiedimi.

Il regex è costruito in modo che possa rilevare i numeri espressi in notazione scientifica 2E10 o addirittura 5,22,454.12E-00.0478 , rimuovendo gli zeri non necessari nelle due parti di tali numeri. Se un esponente è uguale a zero, il numero viene modificato in modo che non ci sia più esponente.

Ho inserito alcune verifiche nello schema in modo che alcuni casi particolari non corrispondano, ad esempio ” 12 .. 57″ non corrisponderà. Ma in ‘, 111’ la stringa ‘111’ corrisponde perché la virgola precedente è considerata una virgola che non si trova in un numero ma in una virgola di frase.

Penso che la gestione delle virgole dovrebbe essere migliorata, perché mi sembra che ci siano solo 2 cifre tra virgole nella numerazione indiana. Presumo, non sarà difficile correggere

Ecco dopo c’è un codice che dimostra come funziona la mia regex. Ci sono due funzioni, secondo se si desidera che i numeri “.1245” siano trasformati in “0.1245” o meno. Non sarei sorpreso se rimarrebbero errori o abbinamenti indesiderati o mancate corrispondenze per determinati casi di stringhe numeriche; quindi mi piacerebbe conoscere questi casi per capire e correggere l’insufficienza.

Mi scuso per questo codice scritto in Python, ma le regex sono trans-langage e penso che tutti saranno in grado di comprendere il pattern del reex

 import re regx = re.compile('(? 

risultato

 string: ' 23456000and23456000. or23456000.000 00023456000 s000023456000. 000023456000.000 ' 23456000 23456000 ('', '23456000', '', '', '', '', '', '', '') 23456000. 23456000 ('', '23456000', '', '', '', '', '', '', '') 23456000.000 23456000 ('', '23456000', '', '', '', '', '', '', '') 00023456000 23456000 ('', '23456000', '', '', '', '', '', '', '') 000023456000. 23456000 ('', '23456000', '', '', '', '', '', '', '') 000023456000.000 23456000 ('', '23456000', '', '', '', '', '', '', '') string: 'arf 10000 sea10000.+10000.000 00010000-00010000. kant00010000.000 ' 10000 10000 ('', '10000', '', '', '', '', '', '', '') 10000. 10000 ('', '10000', '', '', '', '', '', '', '') 10000.000 10000 ('', '10000', '', '', '', '', '', '', '') 00010000 10000 ('', '10000', '', '', '', '', '', '', '') 00010000. 10000 ('', '10000', '', '', '', '', '', '', '') 00010000.000 10000 ('', '10000', '', '', '', '', '', '', '') string: ' 24: 24, 24. 24.000 24.000, 00024r 00024. blue 00024.000 ' 24 24 ('', '24', '', '', '', '', '', '', '') 24, 24 ('', '24', '', '', '', '', '', '', '') 24. 24 ('', '24', '', '', '', '', '', '', '') 24.000 24 ('', '24', '', '', '', '', '', '', '') 24.000 24 ('', '24', '', '', '', '', '', '', '') 00024 24 ('', '24', '', '', '', '', '', '', '') 00024. 24 ('', '24', '', '', '', '', '', '', '') 00024.000 24 ('', '24', '', '', '', '', '', '', '') string: ' 8zoom8. 8.000 0008 0008. and0008.000 ' 8 8 ('', '8', '', '', '', '', '', '', '') 8. 8 ('', '8', '', '', '', '', '', '', '') 8.000 8 ('', '8', '', '', '', '', '', '', '') 0008 8 ('', '8', '', '', '', '', '', '', '') 0008. 8 ('', '8', '', '', '', '', '', '', '') 0008.000 8 ('', '8', '', '', '', '', '', '', '') string: ' 0 00000M0. = 000. 0.0 0.000 000.0 000.000 .000000 .0 ' 0 0 ('', '0', '', '', '', '', '', '', '') 00000 0 ('', '0', '', '', '', '', '', '', '') 0. 0 ('', '0', '', '', '', '', '', '', '') 000. 0 ('', '0', '', '', '', '', '', '', '') 0.0 0 ('', '', '0', '', '', '', '', '', '') 0.000 0 ('', '', '0', '', '', '', '', '', '') 000.0 0 ('', '', '0', '', '', '', '', '', '') 000.000 0 ('', '', '0', '', '', '', '', '', '') .000000 0 ('', '', '0', '', '', '', '', '', '') .0 0 ('', '', '0', '', '', '', '', '', '') string: ' .0000023456 .0000023456000 .0005872 .0005872000 .00503 .00503000 ' .0000023456 0.0000023456 ('', '', '', '.0000023456', '', '', '', '', '') .0000023456000 0.0000023456 ('', '', '', '.0000023456', '', '', '', '', '') .0005872 0.0005872 ('', '', '', '.0005872', '', '', '', '', '') .0005872000 0.0005872 ('', '', '', '.0005872', '', '', '', '', '') .00503 0.00503 ('', '', '', '.00503', '', '', '', '', '') .00503000 0.00503 ('', '', '', '.00503', '', '', '', '', '') string: ' .068 .0680000 .8 .8000 .123456123456 .123456123456000 ' .068 0.068 ('', '', '', '.068', '', '', '', '', '') .0680000 0.068 ('', '', '', '.068', '', '', '', '', '') .8 0.8 ('', '', '', '.8', '', '', '', '', '') .8000 0.8 ('', '', '', '.8', '', '', '', '', '') .123456123456 0.123456123456 ('', '', '', '.123456123456', '', '', '', '', '') .123456123456000 0.123456123456 ('', '', '', '.123456123456', '', '', '', '', '') string: ' .657 .657000 .45 .4500000 .7 .70000 0.0000023230000 000.0000023230000 ' .657 0.657 ('', '', '', '.657', '', '', '', '', '') .657000 0.657 ('', '', '', '.657', '', '', '', '', '') .45 0.45 ('', '', '', '.45', '', '', '', '', '') .4500000 0.45 ('', '', '', '.45', '', '', '', '', '') .7 0.7 ('', '', '', '.7', '', '', '', '', '') .70000 0.7 ('', '', '', '.7', '', '', '', '', '') 0.0000023230000 0.000002323 ('', '', '', '.000002323', '', '', '', '', '') 000.0000023230000 0.000002323 ('', '', '', '.000002323', '', '', '', '', '') string: ' 0.0081000 0000.0081000 0.059000 0000.059000 ' 0.0081000 0.0081 ('', '', '', '.0081', '', '', '', '', '') 0000.0081000 0.0081 ('', '', '', '.0081', '', '', '', '', '') 0.059000 0.059 ('', '', '', '.059', '', '', '', '', '') 0000.059000 0.059 ('', '', '', '.059', '', '', '', '', '') string: ' 0.78987400000 snow 00000.78987400000 0.4400000 00000.4400000 ' 0.78987400000 0.789874 ('', '', '', '.789874', '', '', '', '', '') 00000.78987400000 0.789874 ('', '', '', '.789874', '', '', '', '', '') 0.4400000 0.44 ('', '', '', '.44', '', '', '', '', '') 00000.4400000 0.44 ('', '', '', '.44', '', '', '', '', '') string: ' -0.5000 -0000.5000 0.90 000.90 0.7 000.7 ' -0.5000 -0.5 ('-', '', '', '.5', '', '', '', '', '') -0000.5000 -0.5 ('-', '', '', '.5', '', '', '', '', '') 0.90 0.9 ('', '', '', '.9', '', '', '', '', '') 000.90 0.9 ('', '', '', '.9', '', '', '', '', '') 0.7 0.7 ('', '', '', '.7', '', '', '', '', '') 000.7 0.7 ('', '', '', '.7', '', '', '', '', '') string: ' 2.6 00002.6 00002.60000 4.71 0004.71 0004.7100 ' 2.6 2.6 ('', '', '', '', '2.6', '', '', '', '') 00002.6 2.6 ('', '', '', '', '2.6', '', '', '', '') 00002.60000 2.6 ('', '', '', '', '2.6', '', '', '', '') 4.71 4.71 ('', '', '', '', '4.71', '', '', '', '') 0004.71 4.71 ('', '', '', '', '4.71', '', '', '', '') 0004.7100 4.71 ('', '', '', '', '4.71', '', '', '', '') string: ' 23.49 00023.49 00023.490000 103.45 0000103.45 0000103.45000 ' 23.49 23.49 ('', '', '', '', '23.49', '', '', '', '') 00023.49 23.49 ('', '', '', '', '23.49', '', '', '', '') 00023.490000 23.49 ('', '', '', '', '23.49', '', '', '', '') 103.45 103.45 ('', '', '', '', '103.45', '', '', '', '') 0000103.45 103.45 ('', '', '', '', '103.45', '', '', '', '') 0000103.45000 103.45 ('', '', '', '', '103.45', '', '', '', '') string: ' 10003.45067 000010003.45067 000010003.4506700 ' 10003.45067 10003.45067 ('', '', '', '', '10003.45067', '', '', '', '') 000010003.45067 10003.45067 ('', '', '', '', '10003.45067', '', '', '', '') 000010003.4506700 10003.45067 ('', '', '', '', '10003.45067', '', '', '', '') string: ' +15000.0012 +000015000.0012 +000015000.0012000 ' +15000.0012 +15000.0012 ('+', '', '', '', '15000.0012', '', '', '', '') +000015000.0012 +15000.0012 ('+', '', '', '', '15000.0012', '', '', '', '') +000015000.0012000 +15000.0012 ('+', '', '', '', '15000.0012', '', '', '', '') string: ' 78000.89 000078000.89 000078000.89000 ' 78000.89 78000.89 ('', '', '', '', '78000.89', '', '', '', '') 000078000.89 78000.89 ('', '', '', '', '78000.89', '', '', '', '') 000078000.89000 78000.89 ('', '', '', '', '78000.89', '', '', '', '') string: ' .0457e10 .0457000e10 00000.0457000e10 ' .0457e10 0.0457e10 ('', '', '', '.0457', '', 'e', '10', '', '') .0457000e10 0.0457e10 ('', '', '', '.0457', '', 'e', '10', '', '') 00000.0457000e10 0.0457e10 ('', '', '', '.0457', '', 'e', '10', '', '') string: ' 258e8 2580000e4 0000000002580000e4 ' 258e8 258e8 ('', '258', '', '', '', 'e', '8', '', '') 2580000e4 2580000e4 ('', '2580000', '', '', '', 'e', '4', '', '') 0000000002580000e4 2580000e4 ('', '2580000', '', '', '', 'e', '4', '', '') string: ' 0.782e10 0000.782e10 0000.7820000e10 ' 0.782e10 0.782e10 ('', '', '', '.782', '', 'e', '10', '', '') 0000.782e10 0.782e10 ('', '', '', '.782', '', 'e', '10', '', '') 0000.7820000e10 0.782e10 ('', '', '', '.782', '', 'e', '10', '', '') string: ' 1.23E2 0001.23E2 0001.2300000E2 ' 1.23E2 1.23E2 ('', '', '', '', '1.23', 'E', '2', '', '') 0001.23E2 1.23E2 ('', '', '', '', '1.23', 'E', '2', '', '') 0001.2300000E2 1.23E2 ('', '', '', '', '1.23', 'E', '2', '', '') string: ' 432e-102 0000432e-102 004320000e-106 ' 432e-102 432e-102 ('', '432', '', '', '', 'e-', '102', '', '') 0000432e-102 432e-102 ('', '432', '', '', '', 'e-', '102', '', '') 004320000e-106 4320000e-106 ('', '4320000', '', '', '', 'e-', '106', '', '') string: ' 1.46e10and0001.46e10 0001.4600000e10 ' 1.46e10 1.46e10 ('', '', '', '', '1.46', 'e', '10', '', '') 0001.46e10 1.46e10 ('', '', '', '', '1.46', 'e', '10', '', '') 0001.4600000e10 1.46e10 ('', '', '', '', '1.46', 'e', '10', '', '') string: ' 1.077e-300 0001.077e-300 0001.077000e-300 ' 1.077e-300 1.077e-300 ('', '', '', '', '1.077', 'e-', '300', '', '') 0001.077e-300 1.077e-300 ('', '', '', '', '1.077', 'e-', '300', '', '') 0001.077000e-300 1.077e-300 ('', '', '', '', '1.077', 'e-', '300', '', '') string: ' 1.069e10 0001.069e10 0001.069000e10 ' 1.069e10 1.069e10 ('', '', '', '', '1.069', 'e', '10', '', '') 0001.069e10 1.069e10 ('', '', '', '', '1.069', 'e', '10', '', '') 0001.069000e10 1.069e10 ('', '', '', '', '1.069', 'e', '10', '', '') string: ' 105040.03e10 000105040.03e10 105040.0300e10 ' 105040.03e10 105040.03e10 ('', '', '', '', '105040.03', 'e', '10', '', '') 000105040.03e10 105040.03e10 ('', '', '', '', '105040.03', 'e', '10', '', '') 105040.0300e10 105040.03e10 ('', '', '', '', '105040.03', 'e', '10', '', '') string: ' +286E000024.487900 -78.4500e.14500 .0140E789. ' +286E000024.487900 +286E24.4879 ('+', '286', '', '', '', 'E', '', '', '24.4879') -78.4500e.14500 -78.45e0.145 ('-', '', '', '', '78.45', 'e', '', '.145', '') .0140E789. 0.014E789 ('', '', '', '.014', '', 'E', '789', '', '') string: ' 081,12.40E07,95.0120 0045,78,123.03500e-0.00 ' 081,12.40E07,95.0120 81,12.4E7,95.012 ('', '', '', '', '81,12.4', 'E', '', '', '7,95.012') 0045,78,123.03500 45,78,123.035 ('', '', '', '', '45,78,123.035', '', '', '', '') string: ' 0096,78,473.0380e-0. 0008,78,373.066000E0. 0004512300.E0000 ' 0096,78,473.0380 96,78,473.038 ('', '', '', '', '96,78,473.038', '', '', '', '') 0008,78,373.066000 8,78,373.066 ('', '', '', '', '8,78,373.066', '', '', '', '') 0004512300. 4512300 ('', '4512300', '', '', '', '', '', '', '') string: ' ..18000 25..00 36...77 2..8 ' No match, No catched string, No groups. string: ' 3.8..9 .12500. 12.51.400 ' No match, No catched string, No groups. string: ' 00099,111.8713000 -0012,45,83,987.26+0.000,099,88,44.or00,00,00.00must' 00099,111.8713000 99,111.8713 ('', '', '', '', '99,111.8713', '', '', '', '') -0012,45,83,987.26 -12,45,83,987.26 ('-', '', '', '', '12,45,83,987.26', '', '', '', '') 00,00,00.00 0 ('', '', '0', '', '', '', '', '', '') string: ' 00099,44,and 0000,099,88,44.bom' 00099,44, 99,44 ('', '99,44', '', '', '', '', '', '', '') 0000,099,88,44. 99,88,44 ('', '99,88,44', '', '', '', '', '', '', '') string: '00,000,00.587000 77,98,23,45., this,that ' 00,000,00.587000 0.587 ('', '', '', '.587', '', '', '', '', '') 77,98,23,45. 77,98,23,45 ('', '77,98,23,45', '', '', '', '', '', '', '') string: ' ,111 145.20 +9,9,9 0012800 .,,. 1 100,000 ' ,111 111 ('', '111', '', '', '', '', '', '', '') 145.20 145.2 ('', '', '', '', '145.2', '', '', '', '') +9,9,9 +9,9,9 ('+', '9,9,9', '', '', '', '', '', '', '') 0012800 12800 ('', '12800', '', '', '', '', '', '', '') 1 1 ('', '1', '', '', '', '', '', '', '') 100,000 100,000 ('', '100,000', '', '', '', '', '', '', '') string: '1,1,1.111 000,001.111 -999. 0. 111.110000 1.1.1.111 9.909,888' 1,1,1.111 1,1,1.111 ('', '', '', '', '1,1,1.111', '', '', '', '') 000,001.111 1.111 ('', '', '', '', '1.111', '', '', '', '') -999. -999 ('-', '999', '', '', '', '', '', '', '') 0. 0 ('', '0', '', '', '', '', '', '', '') 111.110000 111.11 ('', '', '', '', '111.11', '', '', '', '') 

Prendendo una certa libertà con i requisiti, stai cercando

 \d+([\d,]?\d)*(\.\d+)? 

Ma nota che questo corrisponderà ad esempio 11,11,1

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

Ciò presuppone che esista sempre almeno una cifra prima o dopo qualsiasi virgola o decimale e presuppone anche che esista al massimo un decimale e che tutte le virgole precedano il decimale.

La regex di seguito corrisponderà a entrambi i numeri del tuo esempio.

 \b\d[\d,.]*\b 

Restituirà 5000 e 99.999.99998713 – corrispondenti ai tuoi requisiti.

Questa espressione regolare:

 (\d{1,3},\d{3}(,\d{3})*)(\.\d*)?|\d+\.?\d* 

Abbinato ogni numero nella stringa:

1 1,0 0,1 1,00 1.000 1.000.000 1000,1 1.000,1 1,323,444.000 1,999 1,222,455,666,0 1,244

Ecco un’altra costruzione che inizia con il formato numero più semplice e quindi, in modo non sovrapposto, aggiunge progressivamente formati di numeri più complessi:

Java regep:

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

Come una stringa Java (notare l’extra \ necessario per l’escape in \ e. Poiché \ e. Hanno un significato speciale in un’espressione regolare, quando da soli):

 String myregexp="(\\d)|([1-9]\\d+)|(\\.\\d+)|(\\d\\.\\d*)|([1-9]\\d+\\.\\d*)|([1-9]\\d{0,2}(,\\d{3})+(\\.\\d*)?)"; 

Spiegazione:

  1. Questa espressione regolare ha la forma A | B | C | D | E | F dove A, B, C, D, E, F sono essi stessi regex che non si sovrappongono. In generale, trovo più facile iniziare con le corrispondenze più semplici possibili, A. Se A manca le corrispondenze desiderate, quindi crea una B che è una modifica minore di A e include un po ‘più di ciò che desideri. Quindi, basato su B, crea una C che cattura di più, ecc. Trovo anche più facile creare espressioni regolari che non si sovrappongano; è più facile capire una regexp con 20 espressioni regex semplici non sovrapposte connesse con OR piuttosto che alcune regex con una corrispondenza più complessa. Ma ognuno per conto proprio!

  2. A è (\ d) e corrisponde esattamente a uno di 0,1,2,3,4,5,6,7,8,9 che non può essere più semplice!

  3. B è ([1-9] \ d +) e corrisponde solo ai numeri con 2 o più cifre, il primo escluso 0. B corrisponde esattamente a uno tra 10,11,12, … B non si sovrappone A ma è una piccola modifica di A.

  4. C è (. \ D +) e corrisponde solo a un decimale seguito da una o più cifre. C corrisponde esattamente a .0 .1 .2 .3 .4 .5 .6 .7 .8 .9 .00 .01 .02 …. .23000 … C consente di trascinare l’eros sulla destra che preferisco: se si tratta di dati di misurazione, il numero di zeri finali indica il livello di precisione. Se non vuoi che gli zeri finali a destra, cambia (. \ D +) in (. \ D * [1-9]) ma questo esclude anche .0 che penso dovrebbe essere permesso. C è anche una piccola modifica di A.

  5. D è (\ d. \ D *) che è A più decimali con gli zeri finali a destra. D corrisponde solo a una singola cifra, seguita da un decimale, seguita da zero o più cifre. D corrisponde a 0. 0.0 0.1 0.2 …. 0.01000 … 9. 9.0 9.1..0.0230000 …. 9.9999999999 … Se si desidera escludere “0.” quindi cambia D in (\ d. \ d +). Se si desidera escludere gli zero finali a destra, modificare D in (\ d. \ D * [1-9]), ma ciò esclude il 2.0 che, a mio avviso, dovrebbe essere incluso. D non si sovrappone A, B o C.

  6. E è ([1-9] \ d +. \ D *) che è B più decimali con zeri finali a destra. Se si desidera escludere “13.”, ad esempio, modificare E su ([1-9] \ d +. \ D +). E non si sovrappone A, B, C o D. E corrisponde a 10. 10.0 10.0100 …. 99.9999999999 … Gli zeri finali possono essere gestiti come in 4. e 5.

  7. F è ([1-9] \ d {0,2} (, \ d {3}) + (. \ D *)?) E corrisponde solo ai numeri con virgole e possibilmente decimali che consentono di inserire zeri a destra. Il primo gruppo ([1-9] \ d {0,2}) corrisponde a una cifra diversa da zero seguita da zero, una o due cifre in più. Il secondo gruppo (, \ d {3}) + corrisponde a un gruppo di 4 caratteri (una virgola seguita da esattamente tre cifre) e questo gruppo può corrispondere una o più volte (nessuna corrispondenza significa nessuna virgola!). Infine, (. \ D *)? non corrisponde a niente, o partite. by itself, or matches a decimal . followed by any number of digits, possibly none. Again, to exclude things like “1,111.”, change (.\d*) to (.\d+). Trailing zeros can be handled as in 4. or 5. F does not overlap A,B,C,D, or E. I couldn’t think of an easier regexp for F.

Let me know if you are interested and I can edit above to handle the trailing zeros on the right as desired.

Here is what matches regexp and what does not:

 0 1 02 <- invalid 20 22 003 <- invalid 030 <- invalid 300 033 <- invalid 303 330 333 0004 <- invalid 0040 <- invalid 0400 <- invalid 4000 0044 <- invalid 0404 <- invalid 0440 <- invalid 4004 4040 4400 0444 <- invalid 4044 4404 4440 4444 00005 <- invalid 00050 <- invalid 00500 <- invalid 05000 <- invalid 50000 00055 <- invalid 00505 <- invalid 00550 <- invalid 05050 <- invalid 05500 <- invalid 50500 55000 00555 <- invalid 05055 <- invalid 05505 <- invalid 05550 <- invalid 50550 55050 55500 . <- invalid .. <- invalid .0 0. .1 1. .00 0.0 00. <- invalid .02 0.2 02. <- invalid .20 2.0 20. .22 2.2 22. .000 0.00 00.0 <- invalid 000. <- invalid .003 0.03 00.3 <- invalid 003. <- invalid .030 0.30 03.0 <- invalid 030. <- invalid .033 0.33 03.3 <- invalid 033. <- invalid .303 3.03 30.3 303. .333 3.33 33.3 333. .0000 0.000 00.00 <- invalid 000.0 <- invalid 0000. <- invalid .0004 0.0004 00.04 <- invalid 000.4 <- invalid 0004. <- invalid .0044 0.044 00.44 <- invalid 004.4 <- invalid 0044. <- invalid .0404 0.404 04.04 <- invalid 040.4 <- invalid 0404. <- invalid .0444 0.444 04.44 <- invalid 044.4 <- invalid 0444. <- invalid .4444 4.444 44.44 444.4 4444. .00000 0.0000 00.000 <- invalid 000.00 <- invalid 0000.0 <- invalid 00000. <- invalid .00005 0.0005 00.005 <- invalid 000.05 <- invalid 0000.5 <- invalid 00005. <- invalid .00055 0.0055 00.055 <- invalid 000.55 <- invalid 0005.5 <- invalid 00055. <- invalid .00505 0.0505 00.505 <- invalid 005.05 <- invalid 0050.5 <- invalid 00505. <- invalid .00550 0.0550 00.550 <- invalid 005.50 <- invalid 0055.0 <- invalid 00550. <- invalid .05050 0.5050 05.050 <- invalid 050.50 <- invalid 0505.0 <- invalid 05050. <- invalid .05500 0.5500 05.500 <- invalid 055.00 <- invalid 0550.0 <- invalid 05500. <- invalid .50500 5.0500 50.500 505.00 5050.0 50500. .55000 5.5000 55.000 550.00 5500.0 55000. .00555 0.0555 00.555 <- invalid 005.55 <- invalid 0055.5 <- invalid 00555. <- invalid .05055 0.5055 05.055 <- invalid 050.55 <- invalid 0505.5 <- invalid 05055. <- invalid .05505 0.5505 05.505 <- invalid 055.05 <- invalid 0550.5 <- invalid 05505. <- invalid .05550 0.5550 05.550 <- invalid 055.50 <- invalid 0555.0 <- invalid 05550. <- invalid .50550 5.0550 50.550 505.50 5055.0 50550. .55050 5.5050 55.050 550.50 5505.0 55050. .55500 5.5500 55.500 555.00 5550.0 55500. .05555 0.5555 05.555 <- invalid 055.55 <- invalid 0555.5 <- invalid 05555. <- invalid .50555 5.0555 50.555 505.55 5055.5 50555. .55055 5.5055 55.055 550.55 5505.5 55055. .55505 5.5505 55.505 555.05 5550.5 55505. .55550 5.5550 55.550 555.50 5555.0 55550. .55555 5.5555 55.555 555.55 5555.5 55555. , <- invalid ,, <- invalid 1, <- invalid ,1 <- invalid 22, <- invalid 2,2 <- invalid ,22 <- invalid 2,2, <- invalid 2,2, <- invalid ,22, <- invalid 333, <- invalid 33,3 <- invalid 3,33 <- invalid ,333 <- invalid 3,33, <- invalid 3,3,3 <- invalid 3,,33 <- invalid ,,333 <- invalid 4444, <- invalid 444,4 <- invalid 44,44 <- invalid 4,444 ,4444 <- invalid 55555, <- invalid 5555,5 <- invalid 555,55 <- invalid 55,555 5,5555 <- invalid ,55555 <- invalid 666666, <- invalid 66666,6 <- invalid 6666,66 <- invalid 666,666 66,6666 <- invalid 6,66666 <- invalid 66,66,66 <- invalid 6,66,666 <- invalid ,666,666 <- invalid 1,111. 1,111.11 1,111.110 01,111.110 <- invalid 0,111.100 <- invalid 11,11. <- invalid 1,111,.11 <- invalid 1111.1,10 <- invalid 01111.11,0 <- invalid 0111.100, <- invalid 1,111,111. 1,111,111.11 1,111,111.110 01,111,111.110 <- invalid 0,111,111.100 <- invalid 1,111,111. 1,1111,11.11 <- invalid 11,111,11.110 <- invalid 01,11,1111.110 <- invalid 0,111111.100 <- invalid 0002,22.2230 <- invalid .,5.,., <- invalid 2.0,345,345 <- invalid 2.334.456 <- invalid 

Here’s a regex:

 (?:\d+)((\d{1,3})*([\,\ ]\d{3})*)(\.\d+)? 

that accepts numbers:

  • without spaces and/or decimals, eg. 123456789 , 123.123
  • with commas or spaces as thousands separator and/or decimals, eg. 123 456 789 , 123 456 789.100 , 123,456 , 3,232,300,000.00

Tests: http://regexr.com/3h1a2