2013-12-09 14 views
5

Ho testo sto cercando di estrarre da LogicalID e SupplyChain daPerché il quantificatore di stelle è più avido del quantificatore plus nelle espressioni regolari Java?

<LogicalID>SupplyChain</Logical> 

All'inizio ho utilizzato la seguente espressione regolare:

.*([A-Za-z]+)>([A-Za-z]+)<.* 

Questo abbinato come segue:

["D", "SupplyChain"] 

In un impeto di disperazione, ho provato a usare l'asterisco invece del vantaggio:

.*([A-Za-z]*)>([A-Za-z]+)<.* 

Questo corrisponde perfettamente.

La documentazione dice * corrisponde a zero o più volte e + corrisponde a una o più volte. Perché * è più avido di +?

EDIT: Mi è stato fatto notare che questo non è il caso qui sotto. L'ordine delle operazioni spiega perché il primo gruppo di partite è effettivamente nullo.

+0

Cosa intendi per avido? Hai provato a cambiare i posti '. *' Con '. +'? Sembra che non sia l'avidità, ma l'ordine di collocarli qui conta. – Pshemo

+0

Sembrava avidità, ed è in realtà l'ordine di esecuzione. Ho raccolto questo nella risposta qui sotto da @Airos. – duber

+2

Mettendo '?' Dopo '*' nella tua prima espressione regolare farà funzionare anche questa corrispondenza, cioè '. *? ([A-Za-z] +)> ([A-Za-z] +) <. *' . Lo sottolineo solo perché potrebbe aiutarti a capire come funzionano le cose, ma la risposta di @ anubhava è probabilmente migliore, a seconda delle tue esigenze. – ajb

risposta

5

Non è una differenza di golosità. Nel tuo primo regex:

.*([A-Za-z]+)>([A-Za-z]+)<.* 

Stai chiedendo per qualsiasi quantità di caratteri (.*), almeno una lettera, poi un >. Così il match avido deve essere D, dal momento che * consuma tutto prima di D.

Nel secondo, invece:

.*([A-Za-z]*)>([A-Za-z]+)<.* 

Volete qualsiasi quantità di caratteri, seguito da qualsiasi quantità di lettere, poi la >. Quindi il primo * consuma tutto fino allo > e il primo gruppo di cattura corrisponde a una stringa vuota. Non penso che "corrisponda perfettamente" a tutti.

2

Si dovrebbe davvero utilizzare questa espressione regolare:

<([A-Za-z]+)>([A-Za-z]+)< 

O

<([A-Za-z]*)>([A-Za-z]+)< 

Entrambi saranno abbinare LogicalID e SupplyChain rispettivamente.

PS: L'espressione regolare: .*([A-Za-z]*)>([A-Za-z]+)< corrisponde alla stringa vuota come prima corrispondenza.

lavoro Demo: http://ideone.com/VMsb6n

+3

Non penso che questo risponda alla domanda. –

+0

@kocko: si prega di elaborare perché no. Ho scritto la regex dell'OP '. * ([A-Za-z] *)> ([A-Za-z] +) anubhava

+2

La domanda è" Perché '*' è più avido di '+'? " –

1
Why is * greedier than +? 

Non mostra avidità.

La prima regex .*([A-Za-z]+)>([A-Za-z]+)<.* può essere rappresentato come

enter image description here

Qui Gruppo1 dovrebbe avere bisogno di presentare una o più volte per una partita.

e il secondo .*([A-Za-z]*)>([A-Za-z]+)<.* come

enter image description here

Qui Gruppo1 dovrebbe aver bisogno di presentare Zero o più tempo per una partita.