2013-07-25 18 views
5

questo è quello che ho usatoJava espressioni regolari per abbinare dollaro ammonta

\$?[0-9]+\.*[0-9]* 

Ma quando stavo facendo alcuni test ho notato che le cose come

$$$34.00 

sarebbe tornato come un fiammifero (ma matcher.group()) restituisce solo la sottostringa corrispondente. Non voglio che passi anche l'espressione regolare se l'utente inserisce più di un simbolo del dollaro così ho provato questo:

\${1}[0-9]+\.*[0-9]* 

ma questo sembra comportarsi lo stesso che l'espressione regolare ho digitato. In questo momento sto testando questo in Java ma, ho intenzione di usarlo in C++ usando le librerie Boost. Ma per favore non darmi quella soluzione qui perché sto cercando di imparare senza che qualcuno mi dia la risposta.

ma ho bisogno di aiuto rendendo così l'utente può inserire un solo simbolo del dollaro (che è quello che ho pensato \${1} farebbe)

+0

Non consentirebbe anche un mucchio di periodi di fila? –

+0

è possibile specificare l'inizio e la fine di una stringa come^\ $ {1} [0-9] + \. * [0-9] * $ –

+0

L'importo è l'intera stringa? Inoltre, come lo abbini attualmente? Usando '.find()'? – fge

risposta

10

Dal momento che si sta facendo questo per imparare regex ...

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

Ripartizione:

^\$ inizio della stringa con $ un unico simbolo del dollaro

([1-9]\d{0,2}(,\d{3})*) 1-3 cifre dove la prima cifra non è un 0, seguita da 0 o più occorrenze di una virgola con 3 cifre

o

(([1-9]\d*)?\d) 1 o più cifre dove la prima cifra può essere 0 solo se è l'unico cifre

(\.\d\d)?$ con un punto e 2 cifre opzionalmente alla fine della stringa

Risultati:

$4,098.09 
$4098.09 
$0.35 
$0 
$380 

Does non corrispondono:

$098.09 
$0.9 
$10,98.09 
$10,980456 
+0

'(([[1-9] \ d *)? \ D)' fa anche attenzione se l'utente non inserisce virgole, vero? Sono contento che tu abbia postato questa risposta perché ho davvero imparato molto dalla decompressione di me stessa e dalla sua interpretazione pezzo per pezzo – rage

+0

Sì, quella parte è specifica da catturare quando non si usano virgole nella stringa. – Syon

1

Ti manca ^ (inizio della stringa), $ (fine della stringa)

^\$\d+([.][0-9]+)?$ 
2

Si può fare qualcosa di simile [^\$]*\$? all'inizio. Ciò assicurerebbe che non ci sono segni $ duplicati, ma corrisponde anche se non ci sono $ presenti.

Inoltre, se si sta lavorando con moneta (possibile decimale e 2 cifre dopo), si consiglia di utilizzare [\.\d{2}]?.

Questo dice che può essere una partita se è seguito da un'istanza di un periodo e 2 cifre o niente di niente. Come indicato nei commenti, si può anche abbinare più periodi di fila, quindi non è necessario utilizzare il * quantificatore dopo \.

+0

Non volevo forzare l'utente ad aggiungere centesimi se non ne avesse avuto bisogno. . '\. {0,1}' funzionerebbe per quello? – rage

+0

'\.?' È lo stesso di '\. {0,1}'. Il quantificatore '?' Significa che si verifica una volta o meno. Dovresti includere anche le due possibili cifre al centesimo dopo il periodo che ho mostrato nella mia risposta. Senza di loro, '$ 27,50' corrisponderebbe solo a $ 27. –

17

Vorrei suggerire evitando l'uso di espressioni regolari per l'analisi di valuta, specialmente quando Java fornisce modi molto più semplici per risolvere questo problema.

Considerate questo codice:

String str = "$789.11"; // user entered value 
Number number = null; 
try { 
    number = NumberFormat.getCurrencyInstance(Locale.US).parse(str); 
} catch(ParseException pe) { 
    // ignore 
} 

if (number != null) { 
    // proceed as user entered a good value 
} 
else { 
    // user didn't enter a good value 
} 
+2

vergogna Non posso fare +1 più volte – sjr

+1

Questo è abbastanza pulito e lo conserverò sicuramente nella mia cassetta degli attrezzi ma, sto cercando di imparare le espressioni regolari in modo che era il motivo per cui stavo cercando di trovare una soluzione a questo problema. – rage

+0

Sì certo, è una tua prerogativa. Tuttavia, solo per farti sapere che la stringa di valuta può contenere anche una virgola, ad es. '$ 23,456.78' – anubhava

0

so che questo è in arrivo in ritardo, ma questo sembra funzionare per me

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

Non capisco perché non ha funzionato per voi.

0

[$](([1-9]+\.?\d*)|([0]\.\d*)|[0]) modello ideale per questo caso.

Questa è un'espressione regolare di Perl, ma potrebbe essere utilizzata in JAVA con alcune librerie.

Problemi correlati