Regular Expressions
Raggruppamento atomico
Ricerca…
introduzione
I gruppi regolari non acquisiti consentono al motore di rientrare nel gruppo e tentare di far corrispondere qualcosa di diverso (ad esempio un'alternanza diversa o corrispondere a un numero inferiore di caratteri quando viene utilizzato un quantificatore).
I gruppi atomici differiscono dai gruppi regolari non catturanti in quanto il backtracking è vietato. Una volta che il gruppo è uscito, tutte le informazioni di backtracking vengono scartate, quindi non è possibile tentare corrispondenze alternative.
Osservazioni
Un quantificatore possessivo si comporta come un gruppo atomico in quanto il motore non sarà in grado di tornare indietro su un token o un gruppo.
Quanto segue è equivalente in termini di funzionalità, anche se alcuni saranno più veloci di altri:
a*+abc
(?>a*)abc
(?:a+)*+abc
(?:a)*+abc
(?:a*)*+abc
(?:a*)++abc
Raggruppamento con (?>)
Utilizzo di un gruppo atomico
I gruppi atomici hanno il formato (?>...) con un ?> Dopo il paren aperto.
Si consideri il seguente testo di esempio:
ABC
La regex tenterà di far corrispondere l'avvio dalla posizione 0 del testo, che è prima di A in ABC .
Se si utilizzava un'espressione senza distinzione tra maiuscole e minuscole (?>a*)abc , il (?>a*) corrispondeva a 1 carattere A , lasciando
BC
come il testo rimanente da abbinare. Il gruppo (?>a*) viene chiuso e viene tentato abc sul testo rimanente, che non corrisponde.
Il motore non è in grado di tornare indietro nel gruppo atomico e quindi il passaggio corrente non riesce. Il motore si sposta nella posizione successiva nel testo, che si troverà nella posizione 1, che è dopo la A e prima della B ABC .
La regex (?>a*)abc viene tentata di nuovo, e (?>a*) corrisponde A 0 volte, lasciando
BC
come il testo rimanente da abbinare. Il gruppo (?>a*) viene chiuso e viene tentato l' abc , che fallisce.
Di nuovo, il motore non è in grado di tornare indietro nel gruppo atomico, e quindi il passaggio corrente fallisce. La regex continuerà a fallire fino a quando tutte le posizioni nel testo sono state esaurite.
Utilizzo di un gruppo non atomico
I gruppi regolari non catturanti hanno il formato (?:...) con un ?: Dopo il paren aperto.
Dato lo stesso testo di esempio, ma con l'espressione senza distinzione tra maiuscole e minuscole (?:a*)abc , si verificherà una corrispondenza poiché è consentito che il backtracking si verifichi.
All'inizio, (?:a*) consumerà la lettera A nel testo
ABC
in partenza
BC
come il testo rimanente da abbinare. Il gruppo (?:a*) viene chiuso e viene tentato abc sul testo rimanente, che non corrisponde.
Il motore fa il backtrack nel gruppo (?:a*) e tenta di abbinare 1 carattere in meno: invece di far corrispondere 1 carattere A , tenta di far corrispondere i caratteri 0 A e il gruppo (?:a*) viene chiuso. Questo lascia
ABC
come il testo rimanente da abbinare. L'espressione regolare abc ora è in grado di abbinare correttamente il testo rimanente.
Altro testo di esempio
Considera questo testo di esempio, con gruppi sia atomici che non atomici (di nuovo, maiuscole e minuscole):
AAAABC
La regex tenterà di AAAABC partire dalla posizione 0 del testo, che è prima della prima A in AAAABC .
Il modello che utilizza il gruppo atomico (?>a*)abc sarà in grado di eguagliarsi, comportandosi in modo quasi identico all'esempio ABC atomico di cui sopra: tutti e 4 i caratteri A vengono prima abbinati a (?>a*) (lasciando BC come testo rimanente da abbinare), e abc non può corrispondere su quel testo. Il gruppo non può essere reinserito, quindi la partita fallisce.
Lo schema che usa il gruppo non atomico (?:a*)abc sarà in grado di eguagliarsi, comportandosi in modo simile all'esempio ABC non atomico di cui sopra: tutti e 4 i caratteri A vengono prima abbinati a (?:a*) (lasciando BC come testo rimanente da abbinare), e abc non può corrispondere su quel testo. Il gruppo è in grado di essere re-inseriti, quindi uno in meno A viene tentata: 3 A caratteri sono abbinati invece di 4 (lasciando ABC come il testo rimanente per abbinare), e abc è in grado di eguagliare con successo su quel testo.