perlre - Online nel cloud

PROGRAMMA:

NOME

perlre - Espressioni regolari Perl

DESCRIZIONE

Questa pagina descrive la sintassi delle espressioni regolari in Perl.

Se non hai mai usato le espressioni regolari prima, è disponibile un'introduzione rapida in
perlrequick, e un'introduzione al tutorial più lunga è disponibile in perlretut.

Per riferimento su come vengono utilizzate le espressioni regolari nelle operazioni di corrispondenza, oltre a varie
esempi dello stesso, vedere le discussioni su "m//", "s///", "qr//" e "??" in "Citazione Regexp-
Like Operators" in perlop.

Novità nella v5.22, "use re 'strict'" applica regole più rigide rispetto a quelle altrimenti durante la compilazione
modelli di espressione regolare. Può trovare cose che, sebbene legali, potrebbero non essere ciò che tu
previsto.

modificatori
Panoramica

Le operazioni di corrispondenza possono avere vari modificatori. Modificatori che riguardano il
l'interpretazione dell'espressione regolare all'interno sono elencate di seguito. Modificatori che alterano
il modo in cui un'espressione regolare viene utilizzata da Perl sono dettagliati in "Operatori simili a virgolette Regexp"
in perlop e "Dettagli cruenti dell'analisi dei costrutti tra virgolette" in perlop.

m Considera la stringa come più righe. Cioè, cambia "^" e "$" dalla corrispondenza dell'inizio
della prima riga della stringa e della fine della sua ultima riga per far corrispondere l'inizio e la fine
di ogni riga all'interno della stringa.

s Tratta la stringa come una riga singola. Cioè, cambia "." per abbinare qualsiasi carattere,
anche una nuova riga, che normalmente non corrisponderebbe.

Usati insieme, come "/ms", lasciano il "." corrisponde a qualsiasi carattere, mentre ancora
consentendo a "^" e "$" di corrispondere, rispettivamente, subito dopo e appena prima delle nuove righe
all'interno della stringa.

i Esegui la corrispondenza del modello senza distinzione tra maiuscole e minuscole.

Se le regole di corrispondenza delle impostazioni locali sono in vigore, la mappa dei casi viene presa dalla locale corrente
per punti di codice inferiori a 255 e dalle regole Unicode per punti di codice più grandi.
Tuttavia, le corrispondenze che attraverserebbero il confine delle regole Unicode/regole non Unicode (ords
255/256) non avrà successo. Vedi perllocale.

Ci sono un certo numero di caratteri Unicode che corrispondono a più caratteri sotto "/i".
Ad esempio, "LATIN SMALL LIGATURE FI" dovrebbe corrispondere alla sequenza "fi". Perl non lo è
attualmente in grado di farlo quando i caratteri multipli sono nel modello e sono
suddivisi tra i gruppi, o quando uno o più sono quantificati. così

"\N{LIGATURE LATINA PICCOLA FI}" =~ /fi/i; # Corrispondenze
"\N{LIGATURE LATINA PICCOLA FI}" =~ /[fi][fi]/i; # Non corrisponde!
"\N{LIGATURE LATINA PICCOLA FI}" =~ /fi*/i; # Non corrisponde!

# Quanto segue non corrisponde e non è chiaro cosa farebbero $1 e $2
# essere anche se lo facesse!!
"\N{LEGATURE LATINA PICCOLA FI}" =~ /(f)(i)/i; # Non corrisponde!

Perl non corrisponde a più caratteri in una classe di caratteri tra parentesi a meno che il
il personaggio che corrisponde a loro è menzionato esplicitamente e non corrisponde affatto a loro
se la classe di caratteri è invertita, che altrimenti potrebbe creare molta confusione. Vedere
"Classi di caratteri tra parentesi" in perlrecharclass e "Negazione" in perlrecharclass.

x Estendi la leggibilità del tuo pattern consentendo spazi bianchi e commenti. Dettagli in
"/ X"

p Conserva la stringa corrispondente in modo che ${^PREMATCH}, ${^MATCH} e ${^POSTMATCH} siano
disponibile per l'uso dopo l'abbinamento.

In Perl 5.20 e versioni successive questo viene ignorato. Grazie a un nuovo meccanismo di copia su scrittura,
${^PREMATCH}, ${^MATCH} e ${^POSTMATCH} saranno disponibili dopo la partita
indipendentemente dal modificatore.

a, d, l e u
Questi modificatori, tutti nuovi in ​​5.14, influenzano le regole del set di caratteri (Unicode, ecc.)
utilizzato, come descritto di seguito in "Modificatori di set di caratteri".

n Impedire l'acquisizione dei metacaratteri di raggruppamento "()". Questo modificatore, nuovo in 5.22,
impedirà la compilazione di $1, $2, ecc....

"ciao" =~ /(ciao|ciao)/; # $1 è "ciao"
"ciao" =~ /(ciao|ciao)/n; # $1 non è definito

Ciò equivale a mettere "?:" all'inizio di ogni gruppo di acquisizione:

"ciao" =~ /(?:ciao|ciao)/; # $1 non è definito

"/n" può essere negato in base al gruppo. In alternativa, le acquisizioni con nome potrebbero ancora essere
Usato.

"ciao" =~ /(?-n:(ciao|ciao))/n; # $1 è "ciao"
"ciao" =~ /(? ciao|ciao)/n; # $1 è "ciao", $+{saluto} è
# "Ciao"

Altri modificatori
Ci sono un certo numero di flag che possono essere trovati alla fine dell'espressione regolare
costrutti che sono non è un flag di espressioni regolari generiche, ma si applicano all'operazione
in corso, come l'abbinamento o la sostituzione ("m//" o "s///" rispettivamente).

I flag descritti ulteriormente in "Uso delle espressioni regolari in Perl" in perlretut sono:

c - mantenere la posizione corrente durante l'abbinamento ripetuto
g - corrisponde globalmente al modello ripetutamente nella stringa

Modificatori specifici per la sostituzione descritti in

"s/PATTERN/REPLACEMENT/msixpodualngcer" in perlop sono:

e - valuta il membro di destra come un'espressione
ee - valuta il lato destro come una stringa, quindi valuta il risultato
o - fingi di ottimizzare il tuo codice, ma in realtà introduci bug
r - esegue la sostituzione non distruttiva e restituisce il nuovo valore

I modificatori delle espressioni regolari sono solitamente scritti nella documentazione come, ad esempio, "il "/x"
modificatore", anche se il delimitatore in questione potrebbe non essere realmente una barra. Il
i modificatori "/imnsxadlup" possono anche essere incorporati all'interno dell'espressione regolare stessa usando
il costrutto "(?...)", vedere "Modelli estesi" di seguito.

Dettagli on alcuni modificatori

Alcuni dei modificatori richiedono più spiegazioni di quelle fornite nella "Panoramica" sopra.

/x

"/x" dice al parser delle espressioni regolari di ignorare la maggior parte degli spazi bianchi che non sono né l'uno né l'altro
barra rovesciata né all'interno di una classe di caratteri tra parentesi. Puoi usarlo per rompere il tuo
espressione regolare in parti (leggermente) più leggibili. Inoltre, il carattere "#" è
trattato come un metacarattere che introduce un commento che arriva fino alla chiusura del pattern
delimitatore o alla fine della riga corrente se il motivo si estende sulla riga successiva.
Quindi, questo è molto simile a un normale commento di codice Perl. (Puoi includere la chiusura
delimitatore all'interno del commento solo se lo precedi con una barra rovesciata, quindi fai attenzione!)

L'uso di "/x" significa che se vuoi spazi bianchi reali o caratteri "#" nel modello
(al di fuori di una classe di caratteri tra parentesi, che non è influenzata da "/x"), allora lo farai
devi evitarli (usando le barre rovesciate o "\Q...\E") o codificarli usando ottale, esadecimale o
"\N{}" esce. È inefficace provare a continuare un commento sulla riga successiva con
l'escape di "\n" con una barra rovesciata o "\Q".

Puoi usare "(?#text)" per creare un commento che termina prima della fine del corrente
riga, ma anche "testo" non può contenere il delimitatore di chiusura a meno che non sia preceduto da una barra rovesciata.

Prese insieme, queste caratteristiche contribuiscono notevolmente alla creazione delle espressioni regolari di Perl
più leggibile. Ecco un esempio:

# Elimina (la maggior parte) dei commenti C.
$programma =~ s {
/\* # Corrisponde al delimitatore di apertura.
.*? # Trova un numero minimo di caratteri.
\*/ # Corrisponde al delimitatore di chiusura.
} []gsx;

Nota che qualsiasi cosa all'interno di "\Q...\E" non viene influenzata da "/x". E nota che "/x"
non influisce sull'interpretazione dello spazio all'interno di un singolo costrutto multi-carattere. Per
esempio in "\x{...}", indipendentemente dal modificatore "/x", non possono esserci spazi. Lo stesso per a
quantificatore come "{3}" o "{5,}". Allo stesso modo, "(?:...)" non può avere uno spazio tra i
"(", "?" e ":". All'interno di qualsiasi delimitatore per tale costrutto, gli spazi consentiti non sono
influenzato da "/x" e dipendono dal costrutto. Ad esempio, "\x{...}" non può avere spazi
perché i numeri esadecimali non contengono spazi. Ma le proprietà Unicode possono avere
spazi, quindi in "\p{...}" possono esserci spazi che seguono le regole Unicode, per le quali vedi
"Proprietà accessibili tramite \p{} e \P{}" in perluniprops.

L'insieme di caratteri che sono considerati spazi bianchi sono quelli che Unicode chiama "Pattern
Spazio Bianco", ovvero:

U+0009 TABULAZIONE DEI PERSONAGGI
ALIMENTAZIONE LINEA U+000A
TABULAZIONE LINEA U+000B
FORMATO U+000C ALIMENTAZIONE
U+000D RITORNO CARROZZERIA
U+0020 SPAZIO
U+0085 RIGA SUCCESSIVA
U+200E SEGNO DA SINISTRA A DESTRA
U+200F SEGNO DA DESTRA A SINISTRA
SEPARATORE DI LINEA U+2028
SEPARATORE DI PARAGRAFI U+2029

Modificatori di set di caratteri

"/d", "/u", "/a" e "/l", disponibili a partire dalla 5.14, sono chiamati set di caratteri
modificatori; influenzano le regole del set di caratteri utilizzate per l'espressione regolare.

È probabile che i modificatori "/d", "/u" e "/l" non siano di grande utilità per te, quindi
non c'è bisogno di preoccuparsi molto per loro. Esistono per uso interno di Perl, quindi quel complesso
le strutture di dati delle espressioni regolari possono essere serializzate automaticamente e successivamente esattamente
ricostituiti, comprese tutte le loro sfumature. Ma, dal momento che Perl non può mantenere un segreto, e
potrebbero esserci rari casi in cui sono utili, sono documentati qui.

Il modificatore "/a", invece, può essere utile. Il suo scopo è quello di consentire il codice che è
lavorare principalmente su dati ASCII per non doversi occupare di Unicode.

In breve, "/l" imposta il set di caratteri su quello di qualunque cosa Locale è in vigore al momento
dell'esecuzione del pattern match.

"/u" imposta il set di caratteri su UNicode.

"/a" imposta anche il set di caratteri su Unicode, MA aggiunge diverse restrizioni per ASCII-sicuro
corrispondenza.

"/d" è il vecchio, problematico, pre-5.14 Dcomportamento del set di caratteri di default. Il suo unico uso è quello di
forza quel vecchio comportamento.

In un dato momento, è attivo esattamente uno di questi modificatori. La loro esistenza permette
Perl per mantenere il comportamento originariamente compilato di un'espressione regolare, indipendentemente da cosa
le regole sono in vigore quando viene effettivamente eseguito. E se è interpolato in un più grande
regex, le regole dell'originale continuano ad applicarsi ad esso e solo a esso.

I modificatori "/l" e "/u" vengono selezionati automaticamente per le espressioni regolari compilate
nell'ambito di vari pragma, e si consiglia in generale di utilizzare quelli
pragma invece di specificare esplicitamente questi modificatori. Per prima cosa, i modificatori
interessano solo la corrispondenza del modello e non si estendono nemmeno a qualsiasi sostituzione eseguita, mentre
l'uso dei pragma fornisce risultati coerenti per tutte le operazioni appropriate all'interno del loro
ambiti. Per esempio,

s/pippo/\Ubar/il

corrisponderà a "pippo" usando le regole del locale per la corrispondenza senza distinzione tra maiuscole e minuscole, ma "/l" lo fa
non influisce sul funzionamento di "\U". Molto probabilmente vuoi che entrambi utilizzino le regole locali.
Per fare ciò, compila invece l'espressione regolare nell'ambito di "usa locale". Questo
entrambi aggiungono implicitamente "/l" e applicano le regole di localizzazione a "\U". La lezione è
"usa locale" e non "/l" esplicitamente.

Allo stesso modo, sarebbe meglio usare "usa la funzione 'unicode_strings'" invece di,

s/pippo/\Lbar/iu

per ottenere regole Unicode, come farebbe "\L" nel primo (ma non necessariamente nel secondo)
utilizzare anche le regole Unicode.

Seguono maggiori dettagli su ciascuno dei modificatori. Molto probabilmente non è necessario che tu lo sappia
dettagli per "/l", "/u" e "/d" e può passare a /a.

/l

significa usare le regole della locale corrente (vedi perllocale) quando si confrontano i modelli. Per
esempio, "\w" corrisponderà ai caratteri "parola" di quella lingua e "/i" non fa distinzione tra maiuscole e minuscole
la corrispondenza corrisponderà in base alle regole di piegatura dei casi della locale. Il locale utilizzato sarà
quello in vigore al momento dell'esecuzione del pattern match. Questo potrebbe non essere lo stesso
come locale al momento della compilazione e può differire da una corrispondenza all'altra se c'è un
chiamata intervenuta del impostalocale() funzione.

L'unico locale non a byte singolo supportato da Perl è (a partire dalla v5.20) UTF-8. Questo significa
che i punti di codice superiori a 255 sono trattati come Unicode, indipendentemente dalle impostazioni internazionali in vigore
(poiché UTF-8 implica Unicode).

Sotto le regole Unicode, ci sono alcune corrispondenze senza distinzione tra maiuscole e minuscole che attraversano il 255/256
confine. Ad eccezione delle versioni locali UTF-8 in Perls v5.20 e successive, queste non sono consentite sotto
"/l". Ad esempio, 0xFF (su piattaforme ASCII) non corrisponde senza maiuscole al carattere in
0x178, "LATIN MAIUSCOLO Y CON DIERESI", perché 0xFF potrebbe non essere "LATIN SMALL
LETTERA Y CON DIERESI" nella localizzazione attuale, e Perl non ha modo di sapere se questo
carattere esiste anche nel locale, molto meno che punto di codice è.

In una locale UTF-8 in v5.20 e versioni successive, l'unica differenza visibile tra locale e non
locale nelle espressioni regolari dovrebbe essere contaminante (vedi perlsec).

Questo modificatore può essere specificato come predefinito da "usa locale", ma vedi "Quale carattere
il modificatore di set è attivo?".

/u

significa utilizzare le regole Unicode durante la corrispondenza dei modelli. Sulle piattaforme ASCII, ciò significa che il
i punti di codice tra 128 e 255 assumono i loro significati Latin-1 (ISO-8859-1) (che sono i
come Unicode). (Altrimenti Perl considera indefiniti i loro significati.) Pertanto,
con questo modificatore, la piattaforma ASCII diventa effettivamente una piattaforma Unicode; e quindi,
ad esempio, "\w" corrisponderà a uno qualsiasi degli oltre 100_000 caratteri di parola in Unicode.

A differenza della maggior parte delle impostazioni locali, che sono specifiche per una coppia di lingua e paese, Unicode classifica
tutti i caratteri che sono lettere da qualche parte nel mondo come "\w". Ad esempio, il tuo
locale potrebbe non pensare che "LATIN SMALL LETTER ETH" sia una lettera (a meno che non ti capiti
parla islandese), ma Unicode sì. Allo stesso modo, tutti i caratteri che sono cifre decimali
da qualche parte nel mondo corrisponderà a "\d"; sono centinaia, non 10, possibili corrispondenze. e
alcune di quelle cifre sembrano alcune delle 10 cifre ASCII, ma significano un numero diverso,
quindi un essere umano potrebbe facilmente pensare che un numero sia una quantità diversa da quella che realmente è. Per
esempio, "BENGALI DIGIT FOUR" (U+09EA) assomiglia molto a un "ASCII DIGIT EIGHT"
(U+0038). E, "\d+", può corrispondere a stringhe di cifre che sono una miscela di diverse
sistemi di scrittura, creando un problema di sicurezza. "numero()" in Unicode::UCD può essere usato per ordinare
questo fuori. Oppure il modificatore "/a" può essere usato per forzare "\d" a far corrispondere solo l'ASCII 0
attraverso 9.

Inoltre, con questo modificatore, la corrispondenza senza distinzione tra maiuscole e minuscole funziona sull'intero set di Unicode
caratteri. Il "SEGNO KELVIN", ad esempio, corrisponde alle lettere "k" e "K"; e "LATINA"
LEGATURE PICCOLE FF" corrisponde alla sequenza "ff", che, se non sei preparato, potrebbe farcela
sembra una costante esadecimale, presentando un altro potenziale problema di sicurezza. Vedere
<http://unicode.org/reports/tr36> per una discussione dettagliata sui problemi di sicurezza di Unicode.

Questo modificatore può essere specificato come predefinito da "use feature 'unicode_strings", "use
locale ':not_characters'", o "use 5.012" (o superiore), ma vedere "Quale set di caratteri
modificatore è in vigore?".

/d

Questo modificatore significa utilizzare le regole native "Predefinite" della piattaforma tranne quando è presente
causare invece di utilizzare le regole Unicode, come segue:

1. la stringa di destinazione è codificata in UTF-8; o

2. il pattern è codificato in UTF-8; o

3. il pattern menziona esplicitamente un punto di codice che è superiore a 255 (diciamo con "\x{100}"); o

4. il pattern usa un nome Unicode ("\N{...}"); o

5. il pattern utilizza una proprietà Unicode ("\p{...}" o "\P{...}"); o

6. il pattern utilizza un'interruzione Unicode ("\b{...}" o "\B{...}"); o

7. il modello usa ""(?[ ])""

Un altro mnemonico per questo modificatore è "Dipende", poiché le regole effettivamente utilizzate dipendono da
varie cose, e di conseguenza si possono ottenere risultati inaspettati. Vedi "Il "bug Unicode""
in perlunicode. Il bug Unicode è diventato piuttosto famigerato, portando a un altro ancora
nome (stampabile) per questo modificatore, "Dodgy".

A meno che il modello o la stringa non siano codificati in UTF-8, solo i caratteri ASCII possono corrispondere
positivamente.

Ecco alcuni esempi di come funziona su una piattaforma ASCII:

$str = "\xDF"; # $str non è in formato UTF-8.
$str =~ /^\w/; # Nessuna corrispondenza, poiché $str non è in formato UTF-8.
$str .= "\x{0e0b}"; # Ora $str è in formato UTF-8.
$str =~ /^\w/; # Corrispondere! $str è ora in formato UTF-8.
tritare $str;
$str =~ /^\w/; # Ancora una partita! $str rimane nel formato UTF-8.

Questo modificatore viene selezionato automaticamente per impostazione predefinita quando nessuno degli altri lo è, quindi ancora
un altro nome è "Predefinito".

A causa dei comportamenti imprevisti associati a questo modificatore, probabilmente dovresti
usalo solo per mantenere strane compatibilità con le versioni precedenti.

/a (e /aa)

Questo modificatore sta per ASCII-restrict (o ASCII-safe). Questo modificatore, a differenza di
altri, possono essere raddoppiati per aumentarne l'effetto.

Quando appare singolarmente, provoca le sequenze "\d", "\s", "\w" e il carattere Posix
classi da abbinare solo nell'intervallo ASCII. Tornano così al loro pre-5.6, pre-Unicode
significati. Sotto "/a", "\d" significa sempre precisamente le cifre da "0" a "9"; "\s" significa il
cinque caratteri "[ \f\n\r\t]" e, a partire da Perl v5.18, la scheda verticale; "\w" significa
i 63 caratteri "[A-Za-z0-9_]"; e allo stesso modo, tutte le classi Posix come
"[[:print:]]" corrisponde solo ai caratteri dell'intervallo ASCII appropriati.

Questo modificatore è utile per le persone che usano Unicode solo occasionalmente e che non lo desiderano
essere gravato dalle sue complessità e preoccupazioni per la sicurezza.

Con "/a", si può scrivere "\d" con la certezza che corrisponderà solo ai caratteri ASCII,
e se dovesse sorgere la necessità di corrispondere oltre ASCII, puoi invece usare "\p{Digit}" (o
"\p{Parola}" per "\w"). Esistono costrutti simili "\p{...}" che possono corrispondere oltre ASCII
sia lo spazio bianco (vedi "Spazio bianco" in perlrecharclass), sia le classi Posix (vedi "POSIX
Classi di caratteri" in perlrecharclass). Quindi, questo modificatore non significa che non puoi usare
Unicode, significa che per ottenere la corrispondenza Unicode devi usare esplicitamente un costrutto
("\p{}", "\P{}") che segnala Unicode.

Come ci si aspetterebbe, questo modificatore fa sì che, ad esempio, "\D" significhi la stessa cosa di
"[^0-9]"; infatti, tutti i caratteri non ASCII corrispondono a "\D", "\S" e "\W". "\b" significa ancora
da abbinare al confine tra "\w" e "\W", usando le definizioni "/a" di essi
(analogamente per "\B").

Altrimenti, "/a" si comporta come il modificatore "/u", in questo caso si usa la corrispondenza senza distinzione tra maiuscole e minuscole
regole Unicode; ad esempio, "k" corrisponderà all'Unicode "\N{KELVIN SIGN}" sotto "/i"
corrispondenza e punti di codice nell'intervallo Latin1, sopra ASCII avranno regole Unicode quando
arriva alla corrispondenza senza distinzione tra maiuscole e minuscole.

Per vietare le corrispondenze ASCII/non ASCII (come "k" con "\N{KELVIN SIGN}"), specifica la "a"
due volte, ad esempio "/aai" o "/aia". (La prima occorrenza di "a" limita il "\d",
ecc., e la seconda occorrenza aggiunge le restrizioni "/i".) Ma, nota che il codice punta
al di fuori dell'intervallo ASCII utilizzerà le regole Unicode per la corrispondenza "/i", quindi il modificatore non lo fa
limita davvero le cose al solo ASCII; proibisce solo la mescolanza di ASCII e non
ASCI.

Per riassumere, questo modificatore fornisce protezione per le applicazioni che non desiderano esserlo
esposto a tutto Unicode. Specificarlo due volte offre una protezione aggiuntiva.

Questo modificatore può essere specificato come predefinito da "use re '/a'" o "use re '/aa'". Se
lo fai, potresti effettivamente avere occasione di usare il modificatore "/u" esplicitamente se ce ne sono
alcune espressioni regolari in cui vuoi regole Unicode complete (ma anche qui, è meglio
se tutto fosse sotto la funzione "unicode_strings", insieme a "use re '/aa'"). Anche
vedere "Quale modificatore di set di caratteri è attivo?".

Quale modificatore di set di caratteri è attivo?

Quale di questi modificatori è attivo in un dato punto in un'espressione regolare dipende
su un insieme abbastanza complesso di interazioni. Questi sono stati progettati in modo che in generale tu
non devi preoccuparti di questo, ma questa sezione fornisce i dettagli cruenti. Come spiegato di seguito
in "Modelli estesi" è possibile specificare in modo esplicito modificatori che si applicano solo a
porzioni di un'espressione regolare. L'intimo ha sempre la priorità su quello esterno,
e uno che si applica all'intera espressione ha la priorità su qualsiasi impostazione predefinita
che sono descritti nel resto di questa sezione.

Il pragma "use re '/foo'" può essere utilizzato per impostare i modificatori predefiniti (inclusi questi) per
espressioni regolari compilate all'interno del suo ambito. Questo pragma ha la precedenza sull'altro
pragma elencati di seguito che modificano anche le impostazioni predefinite.

Altrimenti, "use locale" imposta il modificatore predefinito su "/l"; e "usa funzionalità
'unicode_strings" o "use 5.012" (o superiore) imposta l'impostazione predefinita su "/u" quando non è nello stesso
scope come "usa locale" o "usa byte". ("usa locale ':not_characters'" imposta anche
l'impostazione predefinita è "/u", sovrascrivendo qualsiasi semplice "usa locale".) A differenza dei meccanismi menzionati
sopra, questi influenzano le operazioni oltre alla corrispondenza dei modelli delle espressioni regolari, e quindi danno
risultati più coerenti con altri operatori, incluso l'utilizzo di "\U", "\l", ecc. in
sostituzioni sostitutive.

Se nessuno dei precedenti si applica, per motivi di retrocompatibilità, il modificatore "/d" è il
uno in vigore per impostazione predefinita. Poiché ciò può portare a risultati imprevisti, è meglio specificare
quale altro set di regole dovrebbe essere usato.

Comportamento del modificatore del set di caratteri prima di Perl 5.14

Prima della 5.14, non c'erano modificatori espliciti, ma "/l" era implicito per le espressioni regolari compilate
nell'ambito di "use locale" e "/d" era implicito diversamente. Tuttavia, interpolando
una regex in una regex più grande ignorerebbe la compilazione originale a favore di qualunque cosa fosse
in vigore al momento della seconda compilazione. C'erano una serie di incongruenze
(bug) con il modificatore "/d", dove le regole Unicode verrebbero utilizzate quando inadeguate e
viceversa. "\p{}" non implicava regole Unicode e nemmeno tutte le occorrenze di
"\N{}", fino al 5.12.

Regular Espressioni
Metacaratteri

I pattern utilizzati nel pattern matching Perl si sono evoluti da quelli forniti nella versione 8
routine regolari. (Le routine sono derivate (distantemente) da quelle di Henry Spencer liberamente
reimplementazione ridistribuibile delle routine V8.) Vedere "Espressioni regolari versione 8"
per i dettagli.

In particolare i seguenti metacaratteri hanno il loro standard egrep-ish significati:

\ Cita il prossimo metacarattere
^ Abbina l'inizio della riga
. Trova qualsiasi carattere (tranne la nuova riga)
$ Trova la fine della stringa (o prima di una nuova riga alla fine
della stringa)
| Alternanza
() Raggruppamento
[] Classe di caratteri tra parentesi

Per impostazione predefinita, è garantito che il carattere "^" corrisponda solo all'inizio della stringa, il
Carattere "$" solo alla fine (o prima della nuova riga alla fine) e Perl ne è certo
ottimizzazioni con il presupposto che la stringa contenga solo una riga. Incorporato
le nuove righe non verranno abbinate a "^" o "$". Tuttavia, potresti voler trattare una stringa come un
buffer multilinea, in modo che "^" corrisponda dopo ogni nuova riga all'interno della stringa
(tranne se la nuova riga è l'ultimo carattere nella stringa) e "$" corrisponderà prima di qualsiasi
nuova linea. Al costo di un po' più di sovraccarico, puoi farlo usando il modificatore /m
sull'operatore di corrispondenza del modello. (I programmi più vecchi lo facevano impostando $*, ma questa opzione
è stato rimosso in perl 5.10.)

Per semplificare le sostituzioni su più righe, il "." carattere non corrisponde mai a una nuova riga a meno che tu
usa il modificatore "/s", che in effetti dice a Perl di fingere che la stringa sia una singola
linea, anche se non lo è.

Quantificatori

Sono riconosciuti i seguenti quantificatori standard:

* Abbina 0 o più volte
+ Abbina 1 o più volte
? Abbina 1 o 0 volte
{n} Trova esattamente n volte
{n,} Trova almeno n volte
{n,m} Trova almeno n ma non più di m volte

(Se una parentesi graffa si verifica in qualsiasi altro contesto e non fa parte di una barra rovesciata
sequenza come "\x{...}", viene trattato come un carattere normale. Tuttavia, una deprecazione
viene generato un avviso per tutte queste occorrenze e in Perl v5.26, usi letterali di curly
la parentesi dovrà essere preceduta da caratteri di escape, ad esempio precedendole con una barra rovesciata ("\{") o
racchiudendoli tra parentesi quadre ("[{]"). Questa modifica consentirà la sintassi futura
estensioni (come rendere opzionale il limite inferiore di un quantificatore) e un errore migliore
controllo dei quantificatori.)

Il quantificatore "*" è equivalente a "{0,}", il quantificatore "+" a "{1,}" e il "?"
quantificatore a "{0,1}". n e m sono limitati a valori integrali non negativi minori di a
limite preimpostato definito al momento della creazione di perl. Questo di solito è 32766 sul più comune
piattaforme. Il limite effettivo può essere visto nel messaggio di errore generato dal codice come
Questo:

$_ **= $_ , / {$_} / per 2 .. 42;

Per impostazione predefinita, un sottomodello quantificato è "greedy", ovvero corrisponderà tante volte quanto
possibile (data una particolare posizione di partenza) pur consentendo il resto del
modello da abbinare. Se vuoi che corrisponda al numero minimo di volte possibile, segui
il quantificatore con un "?". Nota che i significati non cambiano, solo "l'avidità":

*? Abbina 0 o più volte, non avidamente
+? Abbina 1 o più volte, non avidamente
?? Abbina 0 o 1 volta, non avidamente
{n}? Abbina esattamente n volte, non avidamente (ridondante)
{n,}? Abbina almeno n volte, non avidamente
{n,m}? Abbina almeno n ma non più di m volte, non avidamente

Normalmente quando un sottomodello quantificato non consente al resto del modello generale di
corrispondenza, Perl tornerà sui propri passi. Tuttavia, questo comportamento a volte è indesiderabile. Così Perl
fornisce anche la forma quantificatore "possessivo".

*+ Abbina 0 o più volte e non restituire nulla
++ Abbina 1 o più volte e non restituire nulla
?+ Abbina 0 o 1 volta e non restituire nulla
{n}+ Trova esattamente n volte senza restituire nulla (ridondante)
{n,}+ Trova almeno n volte senza restituire nulla
{n,m}+ Trova almeno n ma non più di m volte e non restituire nulla

Per esempio,

'aaaa' =~ /a++a/

non corrisponderà mai, poiché "a++" divorerà tutte le "a" nella stringa e non se ne andrà
any per la parte restante del pattern. Questa funzione può essere estremamente utile da dare
perl suggerimenti su dove non dovrebbe tornare sui propri passi. Ad esempio, il tipico "match a double-
Il problema della stringa tra virgolette" può essere eseguito in modo più efficiente se scritto come:

/"(?:[^"\\]++|\\.)*+"/

poiché sappiamo che se la citazione finale non corrisponde, il backtracking non sarà di aiuto. Vedi il
sottoespressione indipendente ""(?>pattern)"" per maggiori dettagli; i quantificatori possessivi sono
solo zucchero sintattico per quel costrutto. Ad esempio, l'esempio sopra potrebbe anche essere
scritto come segue:

/"(?>(?:(?>[^"\\]+)|\\.)*)"/

Si noti che il modificatore del quantificatore possessivo non può essere combinato con il non avido
modificatore. Questo perché non avrebbe senso. Considera la seguente tabella di equivalenza:

Legale illegale
------------ ------
X??+X{0}
X+?+X{1}
X{min,max}?+ X{min}

Fuga sequenze

Poiché i modelli vengono elaborati come stringhe tra virgolette, anche quanto segue funziona:

\t scheda (HT, TAB)
\n nuova riga (LF, NL)
\r ritorno (CR)
\f modulo feed (FF)
\a sveglia (campanello) (BEL)
\e escape (pensa troff) (ESC)
\cK carattere di controllo (esempio: VT)
\x{}, \x00 carattere il cui ordinale è il dato numero esadecimale
\N{nome} denominato carattere Unicode o sequenza di caratteri
\N{U+263D} Carattere Unicode (esempio: PRIMO QUARTO LUNA)
\o{}, \000 carattere il cui ordinale è il numero ottale dato
\l carattere successivo minuscolo (pensa a vi)
\u carattere successivo maiuscolo (pensa a vi)
\L minuscolo fino a \E (pensa a vi)
\U maiuscolo fino a \E (pensa a vi)
\Q quote (disabilita) i metacaratteri del modello fino a \E
\E terminare la modifica del caso o la sezione citata, pensa vi

I dettagli sono in "Quote and Quote-like Operators" in perlop.

Carattere Classi e Altro Special Escapes

Inoltre, Perl definisce quanto segue:

Sequenza Nota Descrizione
[...] [1] Abbina un carattere secondo le regole del
classe di caratteri tra parentesi definita da "...".
Esempio: [az] corrisponde a "a" o "b" o "c" ... o "z"
[[:...:]] [2] Abbina un carattere secondo le regole del POSIX
classe di caratteri "..." all'interno delle parentesi quadre outer
classe di caratteri. Esempio: [[:upper:]] corrisponde a any
carattere maiuscolo.
(?[...]) [8] Classe di caratteri tra parentesi estesa
\w [3] Trova un carattere "parola" (alfanumerico più "_", più
altri caratteri di punteggiatura del connettore più Unicode
segni)
\W [3] Trova un carattere non "parola"
\s [3] Trova un carattere di spazio bianco
\S [3] Trova un carattere che non sia uno spazio bianco
\d [3] Corrisponde a un carattere di cifra decimale
\D [3] Trova un carattere non numerico
\pP [3] Corrisponde a P, denominata proprietà. Usa \p{Prop} per nomi più lunghi
\PP [3] Corrispondenza non-P
\X [4] Corrisponde a Unicode "cluster di grafemi esteso"
\C Trova un singolo carattere in linguaggio C (ottetto) anche se questo è
parte di un carattere UTF-8 più grande. Così si rompe
caratteri nei loro byte UTF-8, quindi potresti finire
con pezzi malformati di UTF-8. Non supportato in
guarda dietro. (Deprecato.)
\1 [5] Backreference a uno specifico gruppo di acquisizione o buffer.
'1' può effettivamente essere un qualsiasi numero intero positivo.
\g1 [5] Backreference a un gruppo specifico o precedente,
\g{-1} [5] Il numero può essere negativo indicando un parente
gruppo precedente e può facoltativamente essere avvolto in
parentesi graffe per un'analisi più sicura.
\g{nome} [5] Backreference denominato
\K [5] Backreference denominato
\K [6] Mantieni le cose a sinistra di \K, non includerle in $&
\N [7] Qualsiasi carattere tranne \n. Non influenzato dal modificatore /s
\v [3] Spazio bianco verticale
\V [3] Non spazi bianchi verticali
\h [3] Spazi orizzontali
\H [3] Spazi non orizzontali
\R [4] Interruzione di riga

[1] Vedere "Classi di caratteri tra parentesi" in perlrecharclass per i dettagli.

[2] Vedere "Classi di caratteri POSIX" in perlrecharclass per i dettagli.

[3] Vedere "Sequenze di barra rovesciata" in perlrecharclass per i dettagli.

[4] Vedere "Varie" in perlrebackslash per i dettagli.

[5] Per i dettagli, vedere "Cattura gruppi" di seguito.

[6] Per i dettagli, vedere "Modelli estesi" di seguito.

[7] Nota che "\N" ha due significati. Quando della forma "\N{NAME}", corrisponde al
carattere o sequenza di caratteri il cui nome è "NOME"; e similmente quando della forma
"\N{U+esadecimale}", corrisponde al carattere il cui punto di codice Unicode è hex. Altrimenti
corrisponde a qualsiasi carattere tranne "\n".

[8] Vedere "Classi di caratteri tra parentesi estese" in perlrecharclass per i dettagli.

Asserzioni

Perl definisce le seguenti asserzioni di larghezza zero:

\b{} Corrispondenza al limite Unicode del tipo specificato
\B{} Corrisponde a dove \b{} corrispondente non corrisponde
\b Trova il confine di una parola
\B Corrispondenza tranne al confine di una parola
\A Corrisponde solo all'inizio della stringa
\Z Corrisponde solo alla fine della stringa o prima della nuova riga alla fine
\z Trova solo alla fine della stringa
\G Corrisponde solo alla posizione() (es. alla posizione di fine partita
di precedenti m//g)

Un confine Unicode ("\b{}"), disponibile a partire dalla v5.22, è un punto tra due
caratteri, o prima del primo carattere nella stringa, o dopo il carattere finale in
la stringa in cui vengono soddisfatti determinati criteri definiti da Unicode. Vedi "\b{}, \b, \B{}, \B" in
perlrebackslash per i dettagli.

Un confine di parola ("\b") è un punto tra due caratteri che ha una "\w" su un lato
e una "\W" dall'altra parte (in qualsiasi ordine), contando i caratteri immaginari
all'inizio e alla fine della stringa come corrispondenza di un "\W". (All'interno delle classi di caratteri
"\b" rappresenta il backspace piuttosto che un confine di parola, proprio come fa normalmente in qualsiasi
stringa tra virgolette.) "\A" e "\Z" sono proprio come "^" e "$", tranne che
non corrisponderà più volte quando viene utilizzato il modificatore "/m", mentre "^" e "$" corrisponderanno a
ogni confine di linea interna. Per far corrispondere la fine effettiva della stringa e non ignorare an
newline finale opzionale, usa "\z".

L'asserzione "\G" può essere usata per concatenare corrispondenze globali (usando "m//g"), come descritto in
"Operatori Regexp Quote-Like" in perlop. È anche utile quando si scrive "lex"-like
scanner, quando si dispone di diversi modelli che si desidera confrontare con conseguenti
sottostringhe della tua stringa; vedere il riferimento precedente. La posizione effettiva in cui "\G"
will match può anche essere influenzato usando "pos()" come lvalue: vedi "pos" in perlfunc.
Nota che la regola per le corrispondenze di lunghezza zero (vedi "Schemi ripetuti che corrispondono a una lunghezza zero
Sottostringa") viene leggermente modificato, in quanto i contenuti a sinistra di "\G" non vengono conteggiati
quando si determina la durata della partita. Pertanto quanto segue non corrisponderà per sempre:

mia $stringa = 'ABC';
pos($stringa) = 1;
while ($stringa =~ /(.\G)/g) {
stampa $1;
}

Stamperà 'A' e quindi terminerà, poiché considera la corrispondenza di larghezza zero, e quindi
non corrisponderà alla stessa posizione due volte di seguito.

Vale la pena notare che "\G" utilizzato in modo improprio può causare un ciclo infinito. Stai attento
quando si utilizzano modelli che includono "\G" in un'alternanza.

Nota anche che "s///" rifiuterà di sovrascrivere parte di una sostituzione che ha già
stato sostituito; quindi per esempio questo si fermerà dopo la prima iterazione, piuttosto che
iterando all'indietro attraverso la stringa:

$_ = "123456789";
posizione = 6;
s/.(?=.\G)/X/g;
Stampa; # stampe 1234X6789, non XXXXX6789

Catturare gruppi

Il costrutto di parentesi "( ... )" crea gruppi di cattura (noto anche come cattura
tamponi). Per fare riferimento ai contenuti correnti di un gruppo in un secondo momento, all'interno dello stesso schema,
usa "\g1" (o "\g{1}") per il primo, "\g2" (o "\g{2}") per il secondo e così via. Questo
si chiama a riferimento indietro.

Non c'è limite al numero di sottostringhe catturate che puoi usare. I gruppi sono
numerato con la parentesi aperta più a sinistra che è il numero 1, ecc. Se un gruppo non lo ha fatto
match, anche il backreference associato non corrisponderà. (Questo può accadere se il gruppo è
facoltativo, o in un ramo diverso di un'alternanza.) Puoi omettere la "g" e scrivere
"\1", ecc., ma ci sono alcuni problemi con questo modulo, descritti di seguito.

Puoi anche fare riferimento ai gruppi di acquisizione relativamente, utilizzando un numero negativo, in modo che
"\g-1" e "\g{-1}" si riferiscono entrambi al gruppo di cattura immediatamente precedente, e "\g-2" e
"\g{-2}" si riferiscono entrambi al gruppo precedente. Per esempio:

/
(Y) # gruppo 1
(# gruppo 2
(X) # gruppo 3
\g{-1} # backref al gruppo 3
\g{-3} # backref al gruppo 1
)
/x

corrisponderebbe a "/(Y) ( (X) \g3 \g1 )/x". Questo ti permette di interpolare le regex
in regex più grandi e non devi preoccuparti che i gruppi di cattura vengano rinumerati.

Puoi fare a meno dei numeri e creare gruppi di cattura con nome. La notazione è
"(?nome>...)" dichiarare e "\g{nome}" fare riferimento. (Per essere compatibile con .Net
espressioni regolari, "\g{nome}" può anche essere scritto come "\k{nome}", "\Knome>" or
"\K'nome'".) Nome non deve iniziare con un numero, né contenere trattini. Quando diverso
gruppi all'interno dello stesso modello hanno lo stesso nome, qualsiasi riferimento a quel nome assume il
gruppo definito più a sinistra. I gruppi denominati contano nella numerazione assoluta e relativa, quindi possono
essere indicato anche con quei numeri. (È possibile fare cose con l'acquisizione denominata
gruppi che altrimenti richiederebbero "(??{})".)

I contenuti del gruppo di acquisizione sono dinamicamente scoperti e disponibili al di fuori del modello
fino alla fine del blocco allegato o fino alla successiva corrispondenza riuscita, a seconda di quale evento si verifica
primo. (Vedi "Dichiarazioni composte" in perlsyn.) Puoi fare riferimento ad esse per numero assoluto
(usando "$1" invece di "\g1", ecc); o per nome tramite l'hash "%+", utilizzando "$+{nome}".

Le parentesi graffe sono obbligatorie in riferimento a gruppi di acquisizione denominati, ma sono facoltative per assoluto o
relativi numerati. Le parentesi graffe sono più sicure quando si crea un'espressione regolare concatenando più piccoli
stringhe. Ad esempio se hai "qr/$a$b/", e $a contiene "\g1" e $b contiene
"37", otterresti "/\g137/" che probabilmente non è quello che volevi.

Le notazioni "\g" e "\k" sono state introdotte in Perl 5.10.0. Prima di allora non c'erano
gruppi di cattura denominati né relativi numerati. Si faceva riferimento ai gruppi numerati assoluti
usando "\1", "\2", ecc., e questa notazione è ancora accettata (e probabilmente lo sarà sempre).
Ma porta ad alcune ambiguità se ci sono più di 9 gruppi di cattura, come potrebbe "\10"
significare il decimo gruppo di cattura o il carattere il cui ordinale in ottale è 010 (a
backspace in ASCII). Perl risolve questa ambiguità interpretando "\10" come a
backreference solo se prima di esso sono state aperte almeno 10 parentesi sinistre. Allo stesso modo "\11"
è un backreference solo se prima di esso sono state aperte almeno 11 parentesi sinistre. E così via.
Da "\1" a "\9" vengono sempre interpretati come backreference. Ci sono diversi esempi
sotto che illustrano questi pericoli. Puoi evitare l'ambiguità usando sempre "\g{}" o
"\g" se intendi catturare gruppi; e per le costanti ottali usando sempre "\o{}", o for
"\077" e inferiori, utilizzando 3 cifre riempite con zeri iniziali, poiché uno zero iniziale implica
una costante ottale.

Il "\cifra" la notazione funziona anche in determinate circostanze al di fuori del modello. Vedere
"Avviso su \1 invece di $ 1" di seguito per i dettagli.

Esempi:

s/^([^ ]*) *([^ ]*)/$2 $1/; # scambia le prime due parole

/(.)\g1/ # trova il primo carattere raddoppiato
e print "'$1' è il primo carattere raddoppiato\n";

/(? .)\K / # ... in un modo diverso
e print "'$+{char}' è il primo carattere raddoppiato\n";

/(?'char'.)\g1/ # ... mescola e abbina
e print "'$1' è il primo carattere raddoppiato\n";

if (/Time: (..):(..):(..)/) { # analizza i valori
$ore = $1;
$minuti = $2;
$secondi = $3;
}

/(.)(.)(.)(.)(.)(.)(.)(.)(.)\g10/ # \g10 è un backreference
/(.)(.)(.)(.)(.)(.)(.)(.)(.)\10/ # \10 è ottale
/((.)(.)(.)(.)(.)(.)(.)(.)(.))\10/ # \10 è un backreference
/((.)(.)(.)(.)(.)(.)(.)(.)(.))\010/ # \010 è ottale

$a = '(.)\1'; # Crea problemi quando concatenato.
$b = '(.)\g{1}'; # Evita i problemi.
"aa" =~ /${a}/; # Vero
"aa" =~ /${b}/; # Vero
"aa0" =~ /${a}0/; # Falso!
"aa0" =~ /${b}0/; # Vero
"aa\x08" =~ /${a}0/; # Vero!
"aa\x08" =~ /${b}0/; # Falso

Diverse variabili speciali si riferiscono anche a parti della partita precedente. $+ restituisce
qualunque sia l'ultima partita di parentesi abbinata. $& restituisce l'intera stringa corrispondente. (all'una
anche il punto $0 lo ha fatto, ma ora restituisce il nome del programma.) "$`" restituisce tutto
prima della stringa corrispondente. "$'" restituisce tutto ciò che segue la stringa corrispondente. E $^N
contiene tutto ciò che è stato trovato nel gruppo chiuso più di recente (sottocorrispondenza). $^N può essere
utilizzato nei modelli estesi (vedi sotto), ad esempio per assegnare una sottocorrispondenza a una variabile.

Queste variabili speciali, come l'hash "%+" e le variabili di corrispondenza numerate ($ 1, $ 2, $ 3,
ecc.) sono dinamicamente scoperti fino alla fine del blocco che lo racchiude o fino al successivo
partita riuscita, a seconda dell'evento che si verifica per primo. (Vedi "Dichiarazioni composte" in perlsyn.)

NOTANota: le corrispondenze non riuscite in Perl non reimpostano le variabili di corrispondenza, il che rende più facile
scrivere codice che verifichi una serie di casi più specifici e ricordi la migliore corrispondenza.

AVVERTIMENTO: Se il tuo codice deve essere eseguito su Perl 5.16 o versioni precedenti, fai attenzione che una volta che Perl lo vede
hai bisogno di uno di $&, "$`" o "$'" in qualsiasi parte del programma, deve fornirli per
ogni corrispondenza di modello. Questo potrebbe rallentare notevolmente il tuo programma.

Perl usa lo stesso meccanismo per produrre $1, $2, ecc., quindi anche tu paghi un prezzo per ciascuno
pattern che contiene parentesi di cattura. (Per evitare questo costo mantenendo il
comportamento di raggruppamento, usa invece l'espressione regolare estesa "(?: ... )".) Ma se tu
non usare mai $&, "$`" o "$'", quindi pattern senza catturare le parentesi non sarà
penalizzato. Quindi evita $&, "$'" e "$`" se puoi, ma se non puoi (e alcuni algoritmi
li apprezzo molto), una volta che li hai usati una volta, usali a piacimento, perché hai
già pagato il prezzo.

Perl 5.16 ha introdotto un meccanismo leggermente più efficiente che rileva separatamente se
ciascuno di "$`", $& e "$'" è stato visto, e quindi potrebbe essere necessario copiare solo parte del
corda. Perl 5.20 ha introdotto un meccanismo di copia su scrittura molto più efficiente che
elimina ogni rallentamento.

Come un'altra soluzione per questo problema, Perl 5.10.0 ha introdotto "${^PREMATCH}", "${^MATCH}"
e "${^POSTMATCH}", che sono equivalenti a "$`", $& e "$'", con l’esclusione di che sono solo
garantito per essere definito dopo una corrispondenza riuscita che è stata eseguita con "/p"
(preservare) modificatore. L'uso di queste variabili non comporta alcuna penalizzazione delle prestazioni globali,
a differenza dei loro equivalenti caratteri di punteggiatura, tuttavia al compromesso che devi dire
perl quando vuoi usarli. A partire da Perl 5.20, queste tre variabili sono equivalenti a
"$`", $& e "$'", e "/p" vengono ignorati.

Quoting metacaratteri
I metacaratteri con barra rovesciata in Perl sono alfanumerici, come "\b", "\w", "\n". a differenza di
alcuni altri linguaggi di espressioni regolari, non ci sono simboli con barra rovesciata che non lo siano
alfanumerico. Quindi qualsiasi cosa che assomigli a \\, \(, \), \[, \], \{ o \} è sempre
interpretato come un carattere letterale, non un metacarattere. Questo una volta era usato in un comune
idioma per disabilitare o citare i significati speciali dei metacaratteri delle espressioni regolari in a
stringa che si desidera utilizzare per un modello. Cita semplicemente tutti i caratteri non "parola":

$modello =~ s/(\W)/\\$1/g;

(Se è impostato "usa locale", allora questo dipende dal locale corrente.) Oggi è più
comune usare il quotameta() funzione o la sequenza di escape metaquotazione "\Q" per disabilitare
significati speciali di tutti i metacaratteri come questo:

/$non quotato\Q$citato\E$non quotato/

Attenzione che se si mettono le barre rovesciate letterali (quelle non all'interno delle variabili interpolate)
tra "\Q" e "\E", l'interpolazione con barra rovesciata doppia tra virgolette può creare confusione
risultati. Se tu bisogno per utilizzare le barre rovesciate letterali all'interno di "\Q...\E", consultare "Dettagli Gory
dell'analisi dei costrutti tra virgolette" in perlop.

"quotemeta()" e "\Q" sono completamente descritti in "quotemeta" in perlfunc.

estesa Modelli
Perl definisce anche una sintassi di estensione coerente per le funzionalità non presenti negli strumenti standard
piace awk e lex. La sintassi per la maggior parte di questi è un paio di parentesi con una domanda
segnalo come prima cosa tra parentesi. Il personaggio dopo il punto interrogativo
indica l'estensione.

La stabilità di queste estensioni varia ampiamente. Alcuni hanno fatto parte del linguaggio principale
per molti anni. Altri sono sperimentali e possono cambiare senza preavviso o essere completamente
RIMOSSO. Controllare la documentazione su una singola funzione per verificarne lo stato attuale.

È stato scelto un punto interrogativo per questo e per il costrutto di corrispondenza minima perché 1)
i punti interrogativi sono rari nelle vecchie espressioni regolari e 2) ogni volta che ne vedi uno, tu
dovrebbe fermarsi e "interrogare" esattamente cosa sta succedendo. Questa è psicologia....

"(?#testo)"
Un commento. Il testo viene ignorato. Nota che Perl chiude il commento non appena lo vede
a ")", quindi non c'è modo di inserire un ")" letterale nel commento. Lo schema si sta chiudendo
il delimitatore deve essere preceduto da una barra rovesciata se compare nel commento.

Vedere "/x" per un altro modo per avere commenti nei pattern.

"(?adlupimnsx-imnsx)"
"(?^alupimnsx)"
Uno o più modificatori di pattern-match incorporati, da attivare (o disattivare, se
preceduto da "-") per il resto del modello o il resto dell'allegato
gruppo di modelli (se presente).

Ciò è particolarmente utile per i modelli dinamici, come quelli letti da a
file di configurazione, preso da un argomento o specificato in una tabella da qualche parte.
Considera il caso in cui alcuni modelli vogliono distinguere tra maiuscole e minuscole e altri no:
quelli senza distinzione tra maiuscole e minuscole devono semplicemente includere "(?i)" nella parte anteriore del modello. Per
esempio:

$modello = "foobar";
if ( /$modello/i ) { }

# più flessibile:

$modello = "(?i)foobar";
if ( /$modello/ ) { }

Questi modificatori vengono ripristinati alla fine del gruppo di inclusione. Per esempio,

( (?i) bla ) \s+ \g1

corrisponderà a "blah" in ogni caso, alcuni spazi e un esatto (Compreso , il Custodie!)
ripetizione della parola precedente, assumendo il modificatore "/x" e nessun modificatore "/i"
al di fuori di questo gruppo.

Questi modificatori non vengono trasferiti in sottoschemi denominati chiamati nell'allegato
gruppo. In altre parole, un modello come "((?i)(?&NAME))" non cambia il caso-
sensibilità del pattern "NAME".

Ognuno di questi modificatori può essere impostato per essere applicato globalmente a tutte le espressioni regolari
compilato nell'ambito di un "use re". Vedere "Modalità '/flags'" in re.

A partire da Perl 5.14, un "^" (accento circonflesso o accento circonflesso) subito dopo il "?" è
una scorciatoia equivalente a "d-imnsx". Le bandiere (eccetto "d") possono seguire l'accento circonflesso per
sovrascriverlo. Ma un segno meno non è legale con esso.

Nota che i modificatori "a", "d", "l", "p" e "u" sono speciali in quanto possono
essere abilitato, non disabilitato, e i modificatori "a", "d", "l" e "u" sono mutuamente
esclusivo: specificando uno de-specifica gli altri, e un massimo di uno (o due "a")
può apparire nel costrutto. Così, ad esempio, "(?-p)" avviserà quando compilato sotto
"usa avvisi"; "(?-d:...)" e "(?dl:...)" sono errori fatali.

Nota anche che il modificatore "p" è speciale in quanto la sua presenza ovunque in un pattern
ha un effetto globale.

"(?:modello)"
"(?adluimnsx-imnsx: modello)"
"(?^aluimnsx:modello)"
Questo è per il clustering, non per l'acquisizione; raggruppa sottoespressioni come "()", ma non lo fa
fare backreference come fa "()". Così

@fields = diviso(/\b(?:a|b|c)\b/)

è come

@fields = diviso(/\b(a|b|c)\b/)

ma non sputa campi extra. È anche più economico non catturare personaggi se lo fai
non è necessario.

Eventuali lettere tra "?" e ":" agiscono come modificatori di flag come con "(?adluimnsx-imnsx)".
Per esempio,

/(?si:più.*di).*milioni/i

è equivalente al più verboso

/(?:(?si)più.*di).*milioni/i

Nota che qualsiasi costrutto "(...)" racchiuso in questo verrà comunque catturato a meno che
il modificatore "/n" è attivo.

A partire da Perl 5.14, un "^" (accento circonflesso o accento circonflesso) subito dopo il "?" è
una scorciatoia equivalente a "d-imnsx". Eventuali flag positivi (tranne "d") possono seguire il
caret, quindi

(?^x:pippo)

è equivalente

(?x-imns:pippo)

Il caret dice a Perl che questo cluster non eredita i flag di nessun ambiente
pattern, ma utilizza i valori predefiniti di sistema ("d-imnsx"), modificati da qualsiasi flag specificato.

L'accento circonflesso consente una stringa più semplice delle espressioni regolari compilate. Queste
una

(?^:modello)

con eventuali flag non predefiniti visualizzati tra il cursore e i due punti. Un test che
esamina tale stringificazione, quindi non è necessario che i flag predefiniti di sistema siano rigidi-
codificato in esso, solo il caret. Se vengono aggiunti nuovi flag a Perl, il significato di
l'espansione del cursore cambierà per includere l'impostazione predefinita per quei flag, quindi il test lo farà
funziona ancora, invariato.

Specificare un flag negativo dopo l'accento circonflesso è un errore, poiché il flag è ridondante.

Mnemonico per "(?^...)": un nuovo inizio poiché il solito uso di un accento circonflesso è quello di abbinare
all'inizio.

"(?|modello)"
Questo è il modello di "ripristino del ramo", che ha la proprietà speciale che la cattura
i gruppi sono numerati dallo stesso punto di partenza in ogni ramo di alternanza. è
disponibile a partire da perl 5.10.0.

I gruppi di cattura sono numerati da sinistra a destra, ma all'interno di questo costrutto il
la numerazione viene riavviata per ogni ramo.

La numerazione all'interno di ogni ramo sarà normale, e tutti i gruppi successivi a questa
il costrutto sarà numerato come se il costrutto contenesse solo un ramo, che
essendo quello con il maggior numero di gruppi di cattura al suo interno.

Questo costrutto è utile quando vuoi catturare una delle numerose alternative
partite.

Considera il seguente schema. I numeri sottostanti mostrano in quale gruppo il
i contenuti acquisiti verranno archiviati.

# prima ---------------reset-diramazione----------- dopo
/ ( a ) (?| x ( y ) z | (p (q) r) | (t) u (v) ) ( z ) /x
#1 2 2 3 2 3 4

Prestare attenzione quando si utilizza lo schema di ripristino del ramo in combinazione con acquisizioni denominate.
Le acquisizioni con nome vengono implementate come alias per i gruppi numerati che detengono il
acquisizioni e ciò interferisce con l'implementazione del modello di ripristino del ramo. Se
stai utilizzando acquisizioni denominate in un modello di ripristino del ramo, è meglio usare lo stesso
nomi, nello stesso ordine, in ciascuna delle alternanze:

/(?| (? x ) (? y )
| (? z ) (? w )) /x

Non farlo può portare a sorprese:

"12" =~ /(?| (? \d+ ) | (? \D+))/x;
dire $+ {a}; # Stampa '12'
dire $+ {b}; # *Anche* stampa '12'.

Il problema qui è che sia il gruppo denominato "a" che il gruppo denominato "b" sono alias
per il gruppo appartenente a $1.

Asserzioni da guardare intorno
Le asserzioni look-around sono modelli di larghezza zero che corrispondono a un modello specifico senza
includendolo in $&. Le asserzioni positive corrispondono quando il loro sottoschema corrisponde, negativo
le asserzioni corrispondono quando il loro modello secondario fallisce. Look-behind corrisponde al testo fino a
posizione di corrispondenza corrente, look-ahead corrisponde al testo che segue la posizione di corrispondenza corrente.

"(?=schema)"
Un'asserzione di previsione positiva di larghezza zero. Ad esempio, "/\w+(?=\t)/" corrisponde a a
parola seguita da una tabulazione, senza includere la tabulazione in $&.

"(?!modello)"
Un'asserzione look-ahead negativa di larghezza zero. Ad esempio "/foo(?!bar)/" corrisponde
qualsiasi occorrenza di "foo" che non sia seguita da "bar". Nota però che guarda-
avanti e dietro NON sono la stessa cosa. Non puoi usarlo per guardare-
dietro a.

Se stai cercando un "bar" che non sia preceduto da un "foo", "/(?!foo)bar/"
non fare quello che vuoi. Questo perché il "(?!foo)" sta solo dicendo che il prossimo
cosa non può essere "foo" - e non lo è, è un "bar", quindi "foobar" corrisponderà. Uso
guarda indietro invece (vedi sotto).

"(?<=schema)" "\K"
Un'asserzione look-behind positiva di larghezza zero. Ad esempio, "/(?<=\t)\w+/" corrisponde a
una parola che segue una tabulazione, senza includere la tabulazione in $&. Funziona solo per fisso-
larghezza guarda dietro.

C'è una forma speciale di questo costrutto, chiamata "\K" (disponibile da Perl
5.10.0), che fa sì che il motore regex "mantenga" tutto ciò che aveva trovato in precedenza
al "\K" e non includerlo in $&. Ciò fornisce effettivamente una lunghezza variabile
guarda dietro. È consentito l'uso di "\K" all'interno di un'altra asserzione look-around,
ma il comportamento non è attualmente ben definito.

Per vari motivi "\K" può essere significativamente più efficiente dell'equivalente
"(?<=...)" costrutto, ed è particolarmente utile in situazioni in cui si desidera
rimuovere in modo efficiente qualcosa che segue qualcos'altro in una stringa. Ad esempio

s/(pippo)bar/$1/g;

può essere riscritto come molto più efficiente

s/pippo\Kbar//g;

"(?
Un'asserzione look-behind negativa di larghezza zero. Per esempio "/(?
qualsiasi occorrenza di "foo" che non segue "bar". Funziona solo per larghezza fissa
guarda dietro.

"(?'NOME'modello)"
"(? modello)"
Un gruppo di acquisizione denominato. Identico sotto ogni aspetto alle normali parentesi di cattura "()"
ma per il fatto aggiuntivo che il gruppo può essere indicato per nome in vari
costrutti di espressioni regolari (come "\g{NAME}") e si può accedere per nome dopo a
corrispondenza riuscita tramite "%+" o "%-". Vedi perlvar per maggiori dettagli su "%+" e "%-"
hash.

Se più gruppi di acquisizione distinti hanno lo stesso nome, $+{NAME} farà riferimento a
il gruppo definito più a sinistra nella partita.

Le forme "(?'NAME'pattern)" e "(? modello)" sono equivalenti.

NOTA: Mentre la notazione di questo costrutto è la stessa della funzione simile in .NET
regex, il comportamento no. In Perl i gruppi sono numerati in sequenza a prescindere
di essere nominato o meno. Così nel modello

/(X)(? y)(z)/

$+{pippo} sarà uguale a $2 e $3 conterrà 'z' invece dell'opposto che
è ciò che un hacker regex potrebbe aspettarsi.

Attualmente NAME è limitato ai soli identificatori semplici. In altre parole, deve
corrisponde a "/^[_A-Za-z][_A-Za-z0-9]*\z/" o alla sua estensione Unicode (vedi utf8), sebbene
non è esteso dalla localizzazione (vedi perllocale).

NOTA: Per rendere le cose più facili ai programmatori con esperienza con Python
o motori regex PCRE, il modello "(?P pattern)" può essere usato al posto di
"(? pattern)"; tuttavia questo modulo non supporta l'uso di virgolette singole come a
delimitatore per il nome.

"\K "
"\k'NOME'"
Backreference denominato. Simile ai backreference numerici, tranne per il fatto che il gruppo è
designato per nome e non per numero. Se più gruppi hanno lo stesso nome, allora
si riferisce al gruppo definito più a sinistra nella corrispondenza corrente.

È un errore fare riferimento a un nome non definito da un "(? )" in precedenza nel modello.

Entrambe le forme sono equivalenti.

NOTA: Per rendere le cose più facili ai programmatori con esperienza con Python
o motori regex PCRE, il pattern "(?P=NAME)" può essere usato al posto di "\k ".

"(?{ codice })"
AVVERTIMENTO: L'utilizzo sicuro di questa funzione richiede la comprensione dei suoi limiti. Codice
eseguito che ha effetti collaterali potrebbe non funzionare in modo identico da versione a versione a causa
all'effetto di future ottimizzazioni nel motore regex. Per maggiori informazioni su
questo, vedere "Frequenza di esecuzione del codice incorporato".

Questa asserzione di larghezza zero esegue qualsiasi codice Perl incorporato. Ci riesce sempre e
il suo valore di ritorno è impostato come $^R.

Nei modelli letterali, il codice viene analizzato contemporaneamente al codice circostante.
All'interno del pattern, il controllo viene passato temporaneamente di nuovo al parser perl, finché
si incontra la parentesi graffa di chiusura che bilancia logicamente. Questo è simile al modo in cui
viene gestita un'espressione di indice di array in una stringa letterale, ad esempio

"abc$array[ 1 + f('[') + g()]def"

In particolare, le parentesi graffe non devono essere bilanciate:

s/abc(?{ f('{'); })/def/

Anche in un modello che viene interpolato e compilato in fase di esecuzione, blocchi di codice letterale
sarà compilato una volta, al momento della compilazione di perl; la seguente stampa "ABCD":

stampa "D";
my $qr = qr/(?{ BEGIN { print "A" } })/;
mio $pippo = "pippo";
/$pippo$qr(?{ BEGIN { print "B" } })/;
INIZIO { stampa "C" }

Nei modelli in cui il testo del codice è derivato da informazioni di runtime piuttosto
che apparire letteralmente in un codice sorgente /pattern/, il codice viene compilato allo stesso modo
momento in cui il modello viene compilato e, per motivi di sicurezza, "use re 'eval'" deve
essere nell'ambito. Questo serve per fermare i pattern forniti dall'utente che contengono snippet di codice da
essere eseguibile.

Nelle situazioni in cui è necessario abilitarlo con "use re 'eval'", dovresti anche avere
controllo contaminazioni abilitato. Meglio ancora, usa la valutazione attentamente vincolata all'interno di a
Scomparto sicuro. Vedere perlsec per i dettagli su entrambi questi meccanismi.

Dal punto di vista dell'analisi, dell'ambito delle variabili lessicali e delle chiusure,

/AAA(?{ BBB })CCC/

si comporta approssimativamente come

/AAA/ && fai { BBB } && /CCC/

Analogamente,

qr/AAA(?{ BBB })CCC/

si comporta approssimativamente come

sub { /AAA/ && fai { BBB } && /CCC/ }

In particolare:

{ il mio $i = 1; $r = qr/(?{ print $i })/ }
mio $i = 2;
/$r/; # stampa "1"

All'interno di un blocco "(?{...})", $_ si riferisce alla stringa a cui corrisponde l'espressione regolare
contro. Puoi anche usare "pos()" per sapere qual è la posizione corrente della corrispondenza
all'interno di questa stringa.

Il blocco di codice introduce un nuovo ambito dal punto di vista della variabile lessicale
dichiarazioni, ma non è un dal punto di vista della localizzazione "locale" e similare
comportamenti. Quindi i blocchi di codice successivi all'interno dello stesso modello vedranno ancora i valori
che erano localizzati in blocchi precedenti. Queste localizzazioni accumulate vengono annullate
o alla fine di una partita riuscita, o se l'asserzione è tornata indietro (confronta
"Tornare indietro"). Per esempio,

$_ = 'un' x 8;
m<
(?{ $cnt = 0 }) # Inizializza $cnt.
(
a
(?{
locale $cnt = $cnt + 1; # Aggiorna $cnt,
# backtracking sicuro.
})
)*
aaaa
(?{ $res = $cnt }) # In caso di successo copia in
# posizione non localizzata.
>x;

inizialmente incrementerà $cnt fino a 8; quindi durante il backtracking, il suo valore sarà
svolto fino a 4, che è il valore assegnato a $res. Alla fine della regex
esecuzione, $cnt verrà riportato al suo valore iniziale di 0.

Questa affermazione può essere usata come condizione in a

(?(condizione)sì-schema|no-schema)

interruttore. Se non è un utilizzato in questo modo, il risultato della valutazione del "codice" viene inserito nel
variabile speciale $^R. Questo accade immediatamente, quindi $^R può essere usato da altri "(?{
codice })" asserzioni all'interno della stessa espressione regolare.

L'assegnazione a $^R sopra è localizzata correttamente, quindi viene ripristinato il vecchio valore di $^R
se l'asserzione è tornata indietro; confrontare "Backtracking".

Nota che la variabile speciale $^N è particolarmente utile con i blocchi di codice da catturare
i risultati delle sottocorrispondenze nelle variabili senza dover tenere traccia del numero di
parentesi nidificate. Per esempio:

$_ = "La volpe marrone salta sopra il cane pigro";
/il (\S+)(?{ $colore = $^N }) (\S+)(?{ $animale = $^N })/i;
print "colore = $colore, animale = $animale\n";

"(??{ codice })"
AVVERTIMENTO: L'utilizzo sicuro di questa funzione richiede la comprensione dei suoi limiti. Codice
eseguito che ha effetti collaterali potrebbe non funzionare in modo identico da versione a versione a causa
all'effetto di future ottimizzazioni nel motore regex. Per maggiori informazioni su
questo, vedere "Frequenza di esecuzione del codice incorporato".

Questa è una sottoespressione regolare "rinviata". Si comporta in di preciso allo stesso modo di a
Blocco di codice "(?{ codice })" come descritto sopra, tranne che il suo valore restituito, anziché
essendo assegnato a $^R, è trattato come un modello, compilato se è una stringa (o usato come-
è se è un oggetto qr//), quindi abbinato come se fosse stato inserito al posto di questo
costruire.

Durante l'abbinamento di questo sotto-modello, ha il proprio set di acquisizioni che sono
valide durante la sottopartita, ma vengono scartate una volta che il controllo torna alla partita principale
modello. Ad esempio, le seguenti corrispondenze, con il motivo interno che cattura "B" e
corrispondenza "BB", mentre il modello esterno cattura "A";

my $inner = '(.)\1';
"ABBA" =~ /^(.)(??{ $interno })\1/;
stampa $1; # stampa "A";

Nota che questo significa che non c'è modo per il modello interno di fare riferimento a una cattura
gruppo definito all'esterno. (Il blocco di codice stesso può utilizzare $1, ecc., per fare riferimento a
che racchiude i gruppi di cattura del modello.) Pertanto, sebbene

('a' x 100)=~/(??{'(.)' x 100})/

andrete a partita, sarà non è un imposta $ 1 in uscita.

Il modello seguente corrisponde a un gruppo tra parentesi:

$re = qr{
\(
(?:
(?> [^()]+ ) # Non-parentesi senza backtracking
|
(??{ $re }) # Raggruppa con parentesi corrispondenti
)*
\)
}X;

Guarda anche "(?PARNO)" per un modo diverso e più efficiente di svolgere lo stesso compito.

Esecuzione di un'espressione regolare posticipata 50 volte senza consumare alcuna stringa di input
risulterà in un errore fatale. La profondità massima è compilata in perl, quindi cambiala
richiede una build personalizzata.

"(?PARNO)" "(?-PARNO)" "(?+PARNO)" "(?R)" "(?0)"
Sottoschema ricorsivo. Tratta il contenuto di un dato buffer di acquisizione nella corrente
modello come sottoschema indipendente e tentare di abbinarlo alla posizione corrente
nella stringa. Informazioni sullo stato di acquisizione dal chiamante per cose come
backreferences è disponibile per il sottopattern, ma cattura i buffer impostati da
il modello secondario non è visibile al chiamante.

Simile a "(??{ code })" tranne per il fatto che non comporta l'esecuzione di alcun codice o
potenzialmente compilare una stringa di pattern restituita; invece tratta la parte del
modello corrente contenuto all'interno di un gruppo di acquisizione specificato come modello indipendente
che deve corrispondere alla posizione corrente. Diverso è anche il trattamento della cattura
i buffer, a differenza dei pattern ricorsivi "(??{ code })" hanno accesso alla corrispondenza dei chiamanti
state, quindi è possibile utilizzare i backreference in modo sicuro.

PARNO è una sequenza di cifre (non inizia con 0) il cui valore riflette la parentesi
numero del gruppo di acquisizione a cui ricorrere. "(?R)" ricorre all'inizio del
intero modello. "(?0)" è una sintassi alternativa per "(?R)". Se PARNO è preceduto da a
segno più o meno, si presume che sia relativo, con numeri negativi che indicano
gruppi di cattura precedenti e quelli positivi successivi. Quindi "(?-1)" si riferisce al più
gruppo dichiarato di recente e "(?+1)" indica il prossimo gruppo da dichiarare. Nota
che il conteggio per la ricorsione relativa differisce da quello dei riferimenti a ritroso relativi,
in quello con ricorsione a gruppi non chiusi sono inclusa.

Il modello seguente corrisponde a una funzione pippo() che può contenere parentesi bilanciate
come argomento.

$re = qr{ ( # gruppo parentesi 1 (funzione completa)
foo
( # gruppo di parentesi 2 (parentesi)
\(
( # gruppo di parentesi 3 (contenuto delle parentesi)
(?:
(?> [^()]+ ) # Non-parentesi senza backtracking
|
(?2) # Ricorre all'inizio del gruppo di parentesi 2
)*
)
\)
)
)
}X;

Se il modello è stato utilizzato come segue

'foo(bar(baz)+baz(bop))'=~/$re/
e stampa "\$1 = $1\n",
"\$2 = $2\n",
"\$3 = $3\n";

l'output prodotto dovrebbe essere il seguente:

$ 1 = foo(bar(baz)+baz(bop))
$2 = (bar(baz)+baz(bop))
$ 3 = bar(baz)+baz(bop)

Se non è definito alcun gruppo di acquisizione corrispondente, si tratta di un errore irreversibile.
Anche la ripetizione più profonda di 50 volte senza consumare alcuna stringa di input risulterà in
un errore fatale. La profondità massima è compilata in perl, quindi cambiarla richiede a
costruzione personalizzata.

Quanto segue mostra come l'utilizzo dell'indicizzazione negativa può rendere più semplice l'incorporamento ricorsivo
pattern all'interno di un costrutto "qr//" per un uso successivo:

i miei $parenti = qr/(\((?:[^()]++|(?-1))*+\))/;
if (/pippo $parentesi \s+ \+ \s+ bar $parentesi/x) {
# fai qualcosa qui...
}

Note: che questo modello non si comporta allo stesso modo dell'equivalente PCRE o Python
costrutto della stessa forma. In Perl puoi tornare indietro in un gruppo ricorsivo, in PCRE
e Python il ricorso al gruppo viene trattato come atomico. Inoltre, i modificatori sono stati risolti
in fase di compilazione, quindi costrutti come (?i:(?1)) o (?:(?i)(?1)) non influiscono sul modo in cui
il sottomodello verrà elaborato.

"(?&NOME)"
Ricorrere a un sottomodello denominato. Uguale a "(?PARNO)" tranne che la parentesi per
il ricorso a è determinato dal nome. Se più parentesi hanno lo stesso nome, allora
ricorre all'estrema sinistra.

È un errore fare riferimento a un nome che non è dichiarato da qualche parte nel modello.

NOTA: Per rendere le cose più facili ai programmatori con esperienza con Python
o motori regex PCRE il pattern "(?P>NAME)" può essere utilizzato al posto di "(?&NAME)".

"(?(condizione)sì-schema|no-schema)"
"(?(condizione)sì-modello)"
Espressione condizionale. Corrisponde a "yes-pattern" se "condition" restituisce un valore vero,
corrisponde a "no-pattern" altrimenti. Un modello mancante corrisponde sempre.

"(condizione)" dovrebbe essere uno tra: 1) un numero intero tra parentesi (che è valido se il
corrispondente coppia di parentesi abbinate); 2) guardare avanti/guardare indietro/valutare zero-
affermazione della larghezza; 3) un nome tra parentesi angolari o virgolette singole (che è valido se a
gruppo con il nome dato abbinato); o 4) il simbolo speciale (R) (vero quando valutato
all'interno di ricorsione o eval). Inoltre la R può essere seguita da un numero, (che
sarà vero quando valutato quando ricorrendo all'interno del gruppo appropriato), o da
&NAME, nel qual caso sarà vero solo se valutato durante la ricorsione nel named
gruppo.

Ecco un riepilogo dei possibili predicati:

(1) (2) ...
Controlla se il gruppo di acquisizione numerato corrisponde a qualcosa.

( ) ('NOME')
Controlla se un gruppo con il nome dato ha trovato una corrispondenza.

(?=...) (?!...) (?<=...) (?
Controlla se il modello corrisponde (o non corrisponde, per le varianti '!').

(?{ CODICE })
Tratta il valore restituito del blocco di codice come condizione.

(R) Controlla se l'espressione è stata valutata all'interno della ricorsione.

(R1) (R2)...
Controlla se l'espressione è stata valutata durante l'esecuzione direttamente all'interno del
n-esimo gruppo di cattura. Questo controllo è l'equivalente regex di

Se ((visitatore(0))[3] eq 'sottonome') { ... }

In altre parole, non controlla l'intero stack di ricorsione.

(R&NOME)
Simile a "(R1)", questo predicato verifica se stiamo eseguendo direttamente all'interno
del gruppo più a sinistra con un dato nome (questa è la stessa logica usata da "(?&NAME)"
disambiguare). Non controlla l'intero stack, ma solo il nome del
ricorsione attiva più interna.

(DEFINIRE)
In questo caso, il modello sì non viene mai eseguito direttamente e il modello no lo è
consentito. Simile nello spirito a "(?{0})" ma più efficiente. Vedi sotto per i dettagli.

Per esempio:

M{ ( \( )?
[^()]+
(?(1) \) )
}x

corrisponde a un blocco di non parentesi, possibilmente incluso nelle parentesi stesse.

Una forma speciale è il predicato "(DEFINE)", che non esegue mai il suo modello sì
direttamente e non consente un no-pattern. Questo permette di definire sottoschemi che
verrà eseguito solo dal meccanismo di ricorsione. In questo modo, puoi definire un insieme di
regole per le espressioni regolari che possono essere raggruppate in qualsiasi modello scelto.

Si consiglia per questo utilizzo di inserire il blocco DEFINE alla fine del
pattern e di nominare eventuali subpattern definiti al suo interno.

Inoltre, vale la pena notare che i modelli definiti in questo modo probabilmente non saranno così
efficiente, poiché l'ottimizzatore non è molto intelligente nel gestirli.

Un esempio di come questo potrebbe essere utilizzato è il seguente:

/(? (?&NAME_PAT))(? (?&INDIRIZZO_PAT))
(?(DEFINIRE)
(? ....)
(? ....)
)/X

Nota che i gruppi di acquisizione abbinati all'interno della ricorsione non sono accessibili dopo il
la ricorsione ritorna, quindi è necessario il livello aggiuntivo di catturare i gruppi. così
$+{NAME_PAT} non verrebbe definito anche se lo sarebbe $+{NAME}.

Infine, tieni presente che i sottomodelli creati all'interno di un blocco DEFINE contano ai fini del
numero assoluto e relativo di acquisizioni, quindi questo:

my @captures = "a" =~ /(.) # Prima cattura
(?(DEFINIRE)
(? 1 ) # Seconda cattura
)/X;
dì scalare @captures;

Verrà generato 2, non 1. Ciò è particolarmente importante se intendi compilare il file
definizioni con l'operatore "qr//" e successivamente interpolarle in un altro modello.

"(?>modello)"
Una sottoespressione "indipendente", che corrisponde alla sottostringa che a standalone
"modello" corrisponderebbe se ancorato alla posizione data e corrisponde Niente Altro
di questo sottostringa. Questo costrutto è utile per l'ottimizzazione di ciò che sarebbe
altrimenti saranno corrispondenze "eterne", perché non tornerà indietro (vedi "Backtracking").
Può anche essere utile in luoghi in cui "prendi tutto ciò che puoi e non dare nulla
back" semantica è desiderabile.

Ad esempio: "^(?>a*)ab" non corrisponderà mai, poiché "(?>a*)" (ancorato all'inizio
di stringa, come sopra) corrisponderà contro tutti i caratteri "a" all'inizio della stringa, uscendo
nessuna "a" per "ab" da abbinare. Al contrario, "a*ab" corrisponderà allo stesso modo di "a+b", poiché il
corrispondenza del sottogruppo "a*" è influenzata dal seguente gruppo "ab" (vedi
"Tornare indietro"). In particolare, "a*" all'interno di "a*ab" corrisponderà a meno caratteri di a
standalone "a*", poiché questo fa corrispondere la coda.

"(?>modello)" non disabilita del tutto il backtracking una volta che è stato abbinato. è
è ancora possibile tornare indietro oltre il costrutto, ma non all'interno. Così
"((?>a*)|(?>b*))ar" corrisponderà ancora a "bar".

Un effetto simile a "(?>modello)" può essere ottenuto scrivendo "(?=(modello))\g{-1}".
Questo corrisponde alla stessa sottostringa di una "a+" standalone e la seguente "\g{-1}" mangia
la stringa abbinata; quindi trasforma un'asserzione di lunghezza zero in un analogo di
"(?>...)". (La differenza tra questi due costrutti è che il secondo usa a
gruppo di acquisizione, spostando così gli ordinali dei backreference nel resto di un normale
espressione.)

Considera questo schema:

M{ \(
(
[^()]+ #x+
|
\( [^()]* \)
)+
\)
}x

Ciò abbinerà in modo efficiente un gruppo non vuoto con parentesi corrispondenti a due livelli di profondità
o meno. Tuttavia, se non esiste un gruppo del genere, ci vorrà praticamente un'eternità
corda. Questo perché ci sono tanti modi diversi per dividere una lunga stringa
diverse sottostringhe. Questo è ciò che sta facendo "(.+)+" e "(.+)+" è simile a a
sottomodello del modello sopra. Considera come il modello sopra rileva la mancata corrispondenza
"((()aaaaaaaaaaaaaaaaaa" in alcuni secondi, ma ogni lettera in più raddoppia questo
volta. Questa performance esponenziale farà sembrare che il tuo programma si sia bloccato.
Tuttavia, una piccola modifica a questo modello

M{ \(
(
(?> [^()]+ ) # cambia x+ sopra a (?> x+ )
|
\( [^()]* \)
)+
\)
}x

che usa "(?>...)" corrisponde esattamente a quello sopra (verificandolo tu stesso
sarebbe un esercizio produttivo), ma termina in un quarto il tempo in cui si usa su a
stringa simile con 1000000 "a". Tieni presente, tuttavia, che, quando questo costrutto è
seguito da un quantificatore, attiva attualmente un messaggio di avviso sotto "use
avvertenze" pragma o -w switch dicendo che "corrisponde alla stringa nulla molte volte in regex".

Su gruppi semplici, come il pattern "(?> [^()]+ )", potrebbe esserci un effetto comparabile
ottenuto da una previsione negativa, come in "[^()]+ (?! [^()] )". Questo è stato solo 4 volte
più lento su una stringa con 1000000 "a".

La semantica "prendi tutto ciò che puoi e non restituire nulla" è desiderabile in molti
situazioni in cui a prima vista un semplice "()*" sembra la soluzione corretta.
Supponiamo di analizzare il testo con i commenti delimitati da "#" seguito da alcuni facoltativi
spazio bianco (orizzontale). Contrariamente al suo aspetto, "#[ \t]*" is non è un la corretta
sottoespressione in modo che corrisponda al delimitatore di commento, perché potrebbe "rinunciare" ad alcuni spazi bianchi
se il resto del motivo può essere fatto in modo che corrisponda in questo modo. La risposta corretta è
uno di questi:

(?>#[ \t]*)
#[ \t]*(?![ \t])

Ad esempio, per raccogliere commenti non vuoti in $ 1, è necessario utilizzare uno di questi:

/ (?> \# [ \t]* ) ( .+ ) /x;
/ \# [ \t]* ( [^ \t] .* ) /x;

Quale scegli dipende da quale di queste espressioni riflette meglio quanto sopra
specificazione dei commenti.

In alcune pubblicazioni questo costrutto è chiamato "corrispondenza atomica" o "possessivo".
corrispondenza".

I quantificatori possessivi equivalgono a mettere all'interno l'oggetto a cui sono applicati
di uno di questi costrutti. Si applicano le seguenti equivalenze:

Modulo di bracketing del modulo quantificatore
--------------- ----------------
PAT*+ (?>PAT*)
PAT++ (?>PAT+)
PAT?+ (?>PAT?)
PAT{min,max}+ (?>PAT{min,max})

"(?[ ])"
Vedere "Classi di caratteri tra parentesi estese" in perlrecharclass.

Special backtracking Controllo Verbi
Questi modelli speciali sono generalmente della forma "(*VERB:ARG)". Salvo diversa indicazione
l'argomento ARG è facoltativo; in alcuni casi è vietato.

Qualsiasi modello contenente un verbo di backtracking speciale che consente un argomento ha lo speciale
comportamento che una volta eseguito imposta $REGERROR e $REGMARK del pacchetto corrente
variabili. In tal caso si applicano le seguenti regole:

In caso di errore, la variabile $REGERROR verrà impostata sul valore ARG del modello di verbo, se
il verbo è stato coinvolto nel fallimento della partita. Se la parte ARG del pattern fosse
omesso, $REGERROR verrà impostato sul nome dell'ultimo modello "(*MARK:NAME)".
eseguito, o su TRUE se non ce n'era. Inoltre, la variabile $REGMARK verrà impostata su FALSE.

In caso di corrispondenza riuscita, la variabile $REGERROR verrà impostata su FALSE e $REGMARK
la variabile verrà impostata sul nome dell'ultimo modello "(*MARK:NAME)" eseguito. Vedi il
spiegazione del verbo "(*MARK:NAME)" di seguito per maggiori dettagli.

NOTA: $REGERROR e $REGMARK non sono variabili magiche come $1 e la maggior parte delle altre espressioni regolari
variabili. Non sono locali per un ambito, né di sola lettura, ma sono invece pacchetti volatili
variabili simili a $AUTOLOAD. Usa "local" per localizzare le modifiche apportate a uno specifico
ambito se necessario.

Se un modello non contiene uno speciale verbo di backtracking che consente un argomento, allora
$REGERROR e $REGMARK non vengono toccati affatto.

Verbi che accettano un argomento
"(*PRUNE)" "(*PRUNE:NOME)"
Questo modello a larghezza zero elimina l'albero di backtracking nel punto corrente quando
tornare indietro in caso di fallimento. Considera il modello "A (*PRUNE) B", dove sono A e B
schemi complessi. Finché non viene raggiunto il verbo "(*PRUNE)", A può tornare indietro come
necessario per abbinare. Una volta raggiunto, l'abbinamento continua in B, che può anche
tornare indietro se necessario; tuttavia, se B non dovesse corrispondere, non si torna più indietro
avverrà e il pattern fallirà completamente all'inizio corrente
posizione.

L'esempio seguente conta tutte le possibili stringhe corrispondenti in un modello
(senza corrispondere effettivamente a nessuno di essi).

'aaab' =~ /a+b?(?{print "$&\n"; $count++})(*FAIL)/;
print "Conteggio=$conteggio\n";

che produce:

AAAB
aaa
aa
a
Saab
aa
a
ab
a
Conteggio = 9

Se aggiungiamo un "(*PRUNE)" prima del conteggio come il seguente

'aaab' =~ /a+b?(*PRUNE)(?{print "$&\n"; $count++})(*FAIL)/;
print "Conteggio=$conteggio\n";

impediamo il backtracking e troviamo il conteggio della stringa corrispondente più lunga in ciascuna
punto di partenza corrispondente in questo modo:

AAAB
Saab
ab
Conteggio = 3

Qualsiasi numero di asserzioni "(*PRUNE)" può essere utilizzato in un pattern.

Vedi anche "(?>modello)" e quantificatori possessivi per altri modi di controllare
tornare indietro. In alcuni casi, l'uso di "(*PRUNE)" può essere sostituito con a
"(?>modello)" senza differenze funzionali; tuttavia, è possibile utilizzare "(*PRUNE)".
gestire i casi che non possono essere espressi utilizzando solo un "(?> pattern)".

"(*SALTA)" "(*SALTA:NOME)"
Questo modello a larghezza zero è simile a "(*PRUNE)", tranne per il fatto che anche in caso di errore
significa che qualsiasi testo che è stato abbinato conduce al modello "(*SKIP)".
l'esecuzione non può farne parte in qualsiasi corrispondenza di questo modello. Questo significa effettivamente
che il motore regex "salta" in questa posizione in caso di errore e tenta di farlo
abbinare di nuovo, (supponendo che ci sia spazio sufficiente per abbinare).

Il nome del modello "(*SKIP:NAME)" ha un significato speciale. Se una
"(*MARK:NAME)" è stato rilevato durante la corrispondenza, quindi è quella posizione che è
usato come "punto di salto". Se non è stato rilevato alcun "(*MARK)" con quel nome, allora il file
L'operatore "(*SKIP)" non ha effetto. Se utilizzato senza un nome, il "punto di salto" è
dove si trovava il punto di corrispondenza durante l'esecuzione del modello (*SKIP).

Confronta quanto segue con gli esempi in "(*PRUNE)"; nota che la stringa è il doppio di
lungo:

'aaabaaab' =~ /a+b?(*SKIP)(?{print "$&\n"; $count++})(*FAIL)/;
print "Conteggio=$conteggio\n";

uscite

AAAB
AAAB
Conteggio = 2

Una volta che 'aaab' all'inizio della stringa è stato abbinato e "(*SKIP)" eseguito,
il prossimo punto di partenza sarà il punto in cui si trovava il cursore quando si trovava "(*SKIP)".
eseguito.

"(*MARK:NAME)" "(*:NAME)"
Questo modello di larghezza zero può essere utilizzato per contrassegnare il punto raggiunto in una stringa quando a
certa parte del modello è stata abbinata con successo. Questo marchio può essere assegnato a
nome. Un successivo modello "(*SKIP)" salterà quindi avanti a quel punto se si torna indietro
in caso di fallimento. È consentito un numero qualsiasi di modelli "(*MARK)" e la parte NAME
possono essere duplicati.

Oltre a interagire con il modello "(*SKIP)", è possibile utilizzare "(*MARK:NAME)".
per "etichettare" un ramo di pattern, in modo che dopo la corrispondenza, il programma possa determinare
quali rami del pattern sono stati coinvolti nella partita.

Quando una corrispondenza ha esito positivo, la variabile $REGMARK verrà impostata sul nome del
eseguito più di recente "(*MARK:NAME)" coinvolto nella partita.

Questo può essere utilizzato per determinare quale ramo di un modello è stato abbinato senza utilizzare a
gruppo di acquisizione separato per ogni ramo, che a sua volta può comportare una performance
miglioramento, poiché perl non può ottimizzare "/(?:(x)|(y)|(z))/" in modo efficiente come
qualcosa come "/(?:x(*MARK:x)|y(*MARK:y)|z(*MARK:z))/".

Quando una corrispondenza è fallita, ea meno che un altro verbo non sia stato coinvolto nel fallire
match e ha fornito il proprio nome da utilizzare, la variabile $REGERROR verrà impostata su
il nome dell'ultimo "(*MARK:NAME)".

Vedere "(*SKIP)" per maggiori dettagli.

Come scorciatoia "(*MARK:NAME)" può essere scritto "(*:NAME)".

"(*THEN)" "(*THEN:NAME)"
Questo è simile all'operatore "cut group" "::" di Perl 6. Come "(*PRUNE)",
questo verbo corrisponde sempre e, quando si torna indietro in caso di errore, provoca l'espressione regolare
motore per provare l'alternanza successiva nel gruppo di chiusura più interno (cattura o
altrimenti) che ha delle alternanze. I due rami di a
"(?(condizione)yes-pattern|no-pattern)" non conta come un'alternanza, per quanto
"(*THEN)" è interessato.

Il suo nome deriva dall'osservazione che questa operazione unita al
l'operatore di alternanza ("|") può essere utilizzato per creare ciò che è essenzialmente un pattern-
basato se/allora/else blocco:

( COND (*THEN) FOO | COND2 (*THEN) BAR | COND3 (*THEN) BAZ )

Si noti che se questo operatore viene utilizzato e NON all'interno di un'alternanza, allora agisce
esattamente come l'operatore "(*PRUNE)".

/ A (*PRUGNA) B /

equivale a

/ A (*POI) B /

ma

/ ( A (*POI) B | C ) /

non è lo stesso di

/ ( LA (*PRUNE) B | C ) /

come dopo aver abbinato la A ma fallendo sulla B, il verbo "(*THEN)" tornerà indietro e
prova C; ma il verbo "(*PRUNE)" fallirà semplicemente.

Verbi senza argomento
"(*COMMETTERE)"
Questo è il "modello di commit" di Perl 6 " " o ":::". È un modello a larghezza zero
simile a "(*SKIP)", tranne per il fatto che quando si torna indietro in caso di errore provoca il
match per fallire definitivamente. Nessun ulteriore tentativo di trovare una corrispondenza valida facendo avanzare il
il puntatore di inizio si ripresenterà. Per esempio,

'aaabaaab' =~ /a+b?(*COMMIT)(?{print "$&\n"; $count++})(*FAIL)/;
print "Conteggio=$conteggio\n";

uscite

AAAB
Conteggio = 1

In altre parole, una volta che è stato inserito "(*COMMIT)" e se il pattern non lo fa
match, il motore regex non proverà ulteriori corrispondenze sul resto del file
stringa.

"(*FAIL)" "(*F)"
Questo modello non corrisponde a nulla e fallisce sempre. Può essere utilizzato per forzare il motore
tornare indietro. È equivalente a "(?!)", ma più facile da leggere. In effetti, "(?!)" ottiene
ottimizzato internamente in "(*FAIL)".

Probabilmente è utile solo se combinato con "(?{})" o "(??{})".

"(*ACCETTARE)"
Questo modello non corrisponde a nulla e provoca la fine dell'abbinamento riuscito in quel momento
in cui è stato rilevato il modello "(*ACCEPT)", indipendentemente dal fatto che sia presente
in realtà più da abbinare nella stringa. Quando si trova all'interno di un motivo nidificato, ad esempio
ricorsione, o in un sottopattern generato dinamicamente tramite "(??{})", solo il
il modello più interno viene terminato immediatamente.

Se "(*ACCEPT)" è all'interno dei gruppi di acquisizione, i gruppi vengono contrassegnati come
terminato nel punto in cui è stato rilevato "(*ACCEPT)". Per esempio:

'AB' =~ /(A (A|B(*ACCETTO)|C) D)(E)/x;

corrisponderà e $1 sarà "AB" e $2 sarà "B", $3 non verrà impostato. Se un altro
il ramo tra parentesi interne è stato abbinato, ad esempio nella stringa 'ACDE', quindi il
Anche "D" ed "E" dovrebbero essere abbinati.

backtracking
NOTA: questa sezione presenta un'approssimazione astratta del comportamento delle espressioni regolari. Per
una visione più rigorosa (e complicata) delle regole coinvolte nella selezione di una corrispondenza tra
possibili alternative, vedere "Combinazione di pezzi RE".

Una caratteristica fondamentale della corrispondenza delle espressioni regolari riguarda la nozione chiamata
backtracking, che è attualmente utilizzato (quando necessario) da tutti i normali non possessivi
quantificatori di espressioni, ovvero "*", "*?", "+", "+?", "{n,m}" e "{n,m}?". Tornare indietro
è spesso ottimizzato internamente, ma vale il principio generale qui delineato.

Affinché un'espressione regolare corrisponda, il intero l'espressione regolare deve corrispondere, non solo una parte
di esso. Quindi, se l'inizio di un pattern contenente un quantificatore riesce in un certo modo
fa sì che le parti successive nel modello non funzionino, il motore di corrispondenza esegue il backup e ricalcola
la parte iniziale: ecco perché si chiama backtracking.

Ecco un esempio di backtracking: supponiamo che tu voglia trovare la parola dopo "foo"
nella stringa "Il cibo è a tavola.":

$_ = "Il cibo è sul tavolo.";
se ( /\b(pippo)\s+(\w+)/i ) {
print "$2 segue $1.\n";
}

Quando la corrispondenza viene eseguita, la prima parte dell'espressione regolare ("\b(foo)") trova un possibile
corrisponde all'inizio della stringa e carica $ 1 con "Foo". Tuttavia, non appena
poiché il motore di corrispondenza vede che non ci sono spazi bianchi dopo il "Foo" che aveva
risparmiato in $ 1, si rende conto del suo errore e ricomincia da capo un carattere dopo dove era
ha avuto la partita provvisoria. Questa volta va fino in fondo fino alla prossima occorrenza di
"pippo". L'espressione regolare completa corrisponde questa volta e ottieni l'output previsto
di "tabella segue pippo."

A volte una corrispondenza minima può aiutare molto. Immagina di voler abbinare tutto tra
"pippo" e "bar". Inizialmente, scrivi qualcosa del genere:

$_ = "Il cibo è sotto il bancone della stalla.";
se ( /pippo(.*)bar/ ) {
print "ho <$1>\n";
}

Che forse inaspettatamente produce:

avuto

Questo perché ".*" era avido, quindi ottieni tutto tra il prima di tutto "pippo" e il ultimo
"sbarra". Qui è più efficace utilizzare una corrispondenza minima per assicurarsi di ottenere il testo
tra un "foo" e la prima "barra" successiva.

if ( /foo(.*?)bar/ ) { print "got <$1>\n" }
avuto

Ecco un altro esempio. Diciamo che desideri abbinare un numero alla fine di una stringa, e
vuoi anche mantenere la parte precedente della partita. Quindi scrivi questo:

$_ = "Ho 2 numeri: 53147";
if ( /(.*)(\d*)/ ) { # Sbagliato!
print "L'inizio è <$1>, il numero è <$2>.\n";
}

Non funzionerà affatto, perché ".*" era avido e ha divorato l'intera stringa. Come "\d*"
può trovare una corrispondenza su una stringa vuota con l'espressione regolare completa che corrisponde correttamente.

L'inizio è , il numero è <>.

Ecco alcune varianti, la maggior parte delle quali non funziona:

$_ = "Ho 2 numeri: 53147";
@pats = qw{
(.*)(\D*)
(.*)(\d+)
(.*?)(\D*)
(.*?)(\d+)
(.*)(\d+)$
(.*?)(\d+)$
(.*)\b(\d+)$
(.*\D)(\d+)$
};

per $patto (@pattino) {
printf "%-12s", $pat;
se ( /$patto/ ) {
stampa "<$1> <$2>\n";
} Else {
stampa "FALLITO\n";
}
}

Verrà stampato:

(.*)(\d*) <>
(.*)(\d+) <2>
(.*?)(\d*) <> <>
(.*?)(\d+) <2>
(.*)(\d+)$ <2>
(.*?)(\d+)$ <2>
(.*)\b(\d+)$ <2>
(.*\D)(\d+)$ <2>

Come vedi, questo può essere un po' complicato. È importante rendersi conto che un'espressione regolare
è semplicemente un insieme di affermazioni che danno una definizione di successo. Potrebbero esserci 0, 1 o
diversi modi in cui la definizione potrebbe avere successo su una determinata stringa. e
se ci sono più modi in cui potrebbe avere successo, devi capire il backtracking per sapere
quale varietà di successo otterrai.

Quando si usano asserzioni e negazioni previsionali, tutto questo può diventare ancora più complicato. Immaginare
vorresti trovare una sequenza di non cifre non seguita da "123". Potresti provare a scrivere
che come

$_ = "ABC123";
if ( /^\D*(?!123)/ ) { # Sbagliato!
print "Sì, no 123 in $_\n";
}

Ma questo non corrisponderà; almeno, non nel modo in cui speri. Afferma che c'è
non c'è 123 nella stringa. Ecco un quadro più chiaro del motivo per cui quel modello corrisponde, al contrario
alle aspettative popolari:

$x = 'ABC123';
$y = 'ABC445';

print "1: ho ricevuto $1\n" if $x =~ /^(ABC)(?!123)/;
print "2: ho $1\n" if $y =~ /^(ABC)(?!123)/;

print "3: ho $1\n" if $x =~ /^(\D*)(?!123)/;
print "4: ho $1\n" if $y =~ /^(\D*)(?!123)/;

Questo stampa

2: ho l'ABC
3: ottenuto AB
4: ho l'ABC

Potresti aspettarti che il test 3 fallisca perché sembra una versione più generica
del test 1. La differenza importante tra loro è che il test 3 contiene un quantificatore
("\D*") e così possono usare il backtracking, mentre il test 1 no. Quello che sta succedendo è quello
hai chiesto "È vero che all'inizio di $x, dopo 0 o più non cifre, hai
qualcosa che non è 123?" Se il pattern matcher avesse lasciato che "\D*" si espandesse in "ABC", questo
avrebbe causato il fallimento dell'intero schema.

Il motore di ricerca corrisponderà inizialmente a "\D*" con "ABC". Quindi proverà a corrispondere
"(?!123)" con "123", che non riesce. Ma poiché un quantificatore ("\D*") è stato utilizzato in
espressione regolare, il motore di ricerca può tornare indietro e riprovare la corrispondenza in modo diverso nel file
speranza di corrispondere all'espressione regolare completa.

Il modello davvero, veramente vuole avere successo, quindi usa il modello standard back-off-and-
riprova e lascia che "\D*" si espanda solo a "AB" questa volta. Ora c'è davvero qualcosa
dopo "AB" che non è "123". È "C123", che è sufficiente.

Possiamo affrontarlo usando sia un'asserzione che una negazione. Diciamo che il primo
parte in $1 deve essere seguita sia da una cifra che da qualcosa che non sia "123". Ricordare
che i look-aheads sono espressioni a larghezza zero: guardano solo, ma non consumano nessuno dei
la stringa nella loro corrispondenza. Quindi riscrivere in questo modo produce ciò che ti aspetteresti; questo è,
il caso 5 avrà esito negativo, ma il caso 6 avrà esito positivo:

print "5: ho $1\n" if $x =~ /^(\D*)(?=\d)(?!123)/;
print "6: ho $1\n" if $y =~ /^(\D*)(?=\d)(?!123)/;

6: ho l'ABC

In altre parole, le due asserzioni di larghezza zero una accanto all'altra funzionano come se lo fossero
ANDed insieme, proprio come useresti qualsiasi asserzione incorporata: "/^$/" corrisponde solo se sei
all'inizio della riga E alla fine della riga contemporaneamente. Il più profondo
la verità di fondo è che la giustapposizione nelle espressioni regolari significa sempre AND, tranne
quando scrivi un OR esplicito usando la barra verticale. "/ab/" significa corrispondenza "a" AND (quindi)
corrispondenza "b", sebbene i tentativi di corrispondenza siano effettuati in posizioni diverse perché "a" lo è
non un'affermazione di larghezza zero, ma un'affermazione di una larghezza.

AVVERTIMENTO: le espressioni regolari particolarmente complicate possono richiedere un tempo esponenziale per essere risolte
a causa dell'immenso numero di modi possibili in cui possono utilizzare il backtracking per provare a
incontro. Ad esempio, senza le ottimizzazioni interne eseguite dal motore delle espressioni regolari,
questo richiederà un tempo dolorosamente lungo per l'esecuzione:

'aaaaaaaaaaaa' =~ /((a{0,5}){0,5})*[c]/

E se hai usato "*" nei gruppi interni invece di limitarli da 0 a 5
partite, ci vorrebbe un'eternità o fino a quando non esaurisci lo spazio nello stack. Inoltre, questi
le ottimizzazioni interne non sono sempre applicabili. Ad esempio, se metti invece "{0,5}".
di "*" sul gruppo esterno, non è applicabile alcuna ottimizzazione corrente e la corrispondenza richiede a
molto tempo per finire.

Un potente strumento per ottimizzare tali bestie è il cosiddetto "gruppo indipendente",
che non torna indietro (vedi ""(?>modello)""). Nota anche che lunghezza zero
le asserzioni look-ahead/look-behind non torneranno indietro per far corrispondere la coda, poiché loro
sono in un contesto "logico": solo se corrispondono è considerato rilevante. Per un esempio
dove gli effetti collaterali del look-ahead forza hanno influenzato la seguente partita, cfr
""(?>modello)"".

Versione 8 Regular Espressioni
Nel caso in cui non hai familiarità con le routine regex "normali" della versione 8, ecco le
regole di corrispondenza dei modelli non descritte sopra.

Ogni singolo carattere corrisponde a se stesso, a meno che non sia a metacarattere con un significato speciale
descritto qui o sopra. Puoi causare caratteri che normalmente funzionano come
metacaratteri da interpretare letteralmente anteponendo loro un "\" (ad esempio, "\."
corrisponde a ".", non a qualsiasi carattere; "\\" corrisponde a "\"). Questo meccanismo di fuga è anche
richiesto per il carattere utilizzato come delimitatore di pattern.

Una serie di caratteri corrisponde a quella serie di caratteri nella stringa di destinazione, quindi il
il pattern "blurfl" corrisponderebbe a "blurfl" nella stringa di destinazione.

Puoi specificare una classe di caratteri, racchiudendo un elenco di caratteri in "[]", che lo farà
corrisponde a qualsiasi carattere dell'elenco. Se il primo carattere dopo "[" è "^", la classe
corrisponde a qualsiasi carattere non presente nell'elenco. All'interno di un elenco, il carattere "-" specifica a
intervallo, in modo che "az" rappresenti tutti i caratteri compresi tra "a" e "z", inclusi. Se tu
vuoi che "-" o "]" stesso sia un membro di una classe, mettilo all'inizio dell'elenco
(possibilmente dopo un "^"), o evitalo con una barra rovesciata. "-" è anche preso alla lettera quando
è alla fine dell'elenco, appena prima della chiusura "]". (Di seguito tutti specificano il
stessa classe di tre caratteri: "[-az]", "[az-]" e "[a\-z]". Tutti sono diversi da
"[az]", che specifica una classe contenente ventisei caratteri, anche su EBCDIC
set di caratteri.) Inoltre, se si tenta di utilizzare le classi di caratteri "\w", "\W", "\s", "\S",
"\d" o "\D" come punti finali di un intervallo, il "-" è inteso letteralmente.

Nota anche che l'idea dell'intero intervallo è piuttosto inportabile tra i set di caratteri, tranne
per quattro situazioni che Perl gestisce in modo speciale. Qualsiasi sottoinsieme degli intervalli "[AZ]",
"[az]" e "[0-9]" sono garantiti per corrispondere al sottoinsieme previsto di caratteri ASCII, no
importa quale set di caratteri è in esecuzione sulla piattaforma. Il quarto modo portatile per specificare
ranges consiste nell'utilizzare la sintassi "\N{...}" per specificare uno dei punti finali dell'intervallo. Per
esempio, "[\N{U+04}-\N{U+07}]" significa che corrisponde ai punti di codice Unicode "\N{U+04}",
"\N{U+05}", "\N{U+06}" e "\N{U+07}", qualunque siano i loro valori nativi sul
piattaforma. In use re 'strict' o all'interno di un ""(?[ ])"", viene generato un avviso, se abilitato,
e l'altro punto finale di un intervallo che ha un endpoint "\N{...}" non è portabile
specificato. Per esempio,

[\N{U+00}-\x06] # Avvertimento sotto "usa re 'rigoroso'".

È difficile capire senza scavare ciò che corrisponde esattamente agli intervalli diversi dai sottoinsiemi di
"[AZ]", "[az]" e "[0-9]". Un buon principio è usare solo intervalli che iniziano da
e termina con lettere alfabetiche uguali ([ae], [AE]) o cifre ([0-9]). Nulla
altrimenti non è sicuro o non è chiaro. In caso di dubbio, precisare l'intervallo per intero.

I caratteri possono essere specificati usando una sintassi dei metacaratteri molto simile a quella usata in C: "\n"
corrisponde a una nuova riga, "\t" una scheda, "\r" un ritorno a capo, "\f" un feed modulo e così via. Altro
generalmente, \nnn, Dove nnn è una stringa di tre cifre ottali, corrisponde al carattere di cui
il valore del set di caratteri codificati è nnn. Allo stesso modo, \xnn, Dove nn sono cifre esadecimali,
corrisponde al carattere il cui ordinale è nn. L'espressione \cx corrisponde al personaggio
controllo-x. Infine, il "." il metacarattere corrisponde a qualsiasi carattere tranne "\n" (a meno che tu
utilizzare "/s").

Puoi specificare una serie di alternative per un pattern usando "|" per separarli, in modo che
"fee|fie|foe" corrisponderà a qualsiasi di "fee", "fie" o "foe" nella stringa di destinazione (come farebbe
"f(e|i|o)e"). La prima alternativa include tutto dall'ultimo delimitatore di pattern
("(", "(?:", ecc. o l'inizio del pattern) fino al primo "|" e all'ultimo
alternativa contiene tutto dall'ultimo "|" al successivo delimitatore di pattern di chiusura.
Ecco perché è prassi comune includere le alternative tra parentesi: minimizzare
confusione su dove iniziano e dove finiscono.

Le alternative vengono provate da sinistra a destra, quindi la prima alternativa trovata per la quale il
l'intera espressione corrisponde, è quella scelta. Ciò significa che le alternative non lo sono
necessariamente avido. Ad esempio: quando si abbina "foo|foot" a "barefoot", solo il
La parte "pippo" corrisponderà, poiché questa è la prima alternativa provata e corrisponderà correttamente
la stringa di destinazione. (Questo potrebbe non sembrare importante, ma è importante quando lo sei
catturare il testo corrispondente usando le parentesi.)

Ricorda anche che "|" viene interpretato come un letterale tra parentesi quadre, quindi se scrivi
"[fee|fie|foe]" in realtà stai solo abbinando "[feio|]".

All'interno di un modello, è possibile designare sottomodelli per un riferimento successivo racchiudendoli
parentesi, e si può fare riferimento a nesimo sottomodello più avanti nel modello usando il
metacarattere \n o \gn. I sottomodelli sono numerati in base all'ordine da sinistra a destra di
la loro parentesi di apertura. Un backreference corrisponde a qualunque cosa effettivamente corrispondesse a
subpattern nella stringa in esame, non le regole per quel subpattern. Perciò,
"(0|0x)\d*\s\g1\d*" corrisponderà a "0x1234 0x4321", ma non a "0x1234 01234", perché il modello secondario
1 corrispondeva a "0x", anche se la regola "0|0x" potrebbe potenzialmente corrispondere allo 0 iniziale in
secondo numero.

Avvertenza on \1 Invece of $1
Alcune persone si abituano troppo a scrivere cose come:

$modello =~ s/(\W)/\\\1/g;

Questo è nonno (da \1 a \9) per l'RHS di un sostituto per evitare di scioccare il sete
tossicodipendenti, ma è una sporca abitudine da prendere. Questo perché in PerlThink, la mano destra
il lato di una "s///" è una stringa tra virgolette. "\1" nella solita stringa tra virgolette significa
un controllo-A. Il consueto significato Unix di "\1" è sostituito da "s///". Tuttavia, se
prendi l'abitudine di farlo, ti metti nei guai se poi aggiungi un
modificatore "/e".

s/(\d+)/ \1 + 1 /eg; # provoca un avviso sotto -w

O se provi a farlo

s/(\d+)/\1000/;

Non puoi disambiguarlo dicendo "\{1}000", mentre puoi risolverlo con "${1}000".
L'operazione di interpolazione non va confusa con l'operazione di matching a
riferimento. Certamente significano due cose diverse sul a sinistra lato della "s///".

Ripetuta Modelli Abbinare a Lunghezza zero Sottostringa
AVVERTIMENTO: Materiale difficile (e prosa) avanti. Questa sezione necessita di una riscrittura.

Le espressioni regolari forniscono un linguaggio di programmazione conciso e potente. Come con la maggior parte degli altri
utensili elettrici, la potenza si unisce alla capacità di devastare.

Un comune abuso di questo potere deriva dalla capacità di fare loop infiniti usando regolari
espressioni, con qualcosa di innocuo come:

'pippo' =~ m{ ( o? )* }x;

Il "o?" corrisponde all'inizio di 'foo' e poiché la posizione nella stringa non lo è
commosso dalla partita, "o?" corrisponderebbe ancora e ancora a causa del quantificatore "*".
Un altro modo comune per creare un ciclo simile è con il modificatore di loop "//g":

@matches = ( 'pippo' =~ m{ o? }xg );

or

print "match: <$&>\n" while 'foo' =~ m{ o? }xg;

o il ciclo implicito da Diviso().

Tuttavia, una lunga esperienza ha dimostrato che molte attività di programmazione possono essere significative
semplificato utilizzando sottoespressioni ripetute che possono corrispondere a sottostringhe di lunghezza zero. Ecco
un semplice esempio è:

@chars = diviso //, $stringa; # // non è magico in split
($imbiancato = $stringa) =~ s/()/ /g; # i genitori evitano la magia s// /

Quindi Perl consente tali costrutti, da con forza rottura , il infinito loop. Le regole per
questo è diverso per i loop di livello inferiore dati dai quantificatori avidi "*+{}" e per
quelli di livello superiore come il modificatore "/g" o Diviso() operatore.

I loop di livello inferiore sono sospeso (cioè, il ciclo è interrotto) quando Perl lo rileva
un'espressione ripetuta corrispondeva a una sottostringa di lunghezza zero. così

m{ (?: NON_ZERO_LENGTH | ZERO_LENGTH )* }x;

è reso equivalente a

m{ (?: NON_ZERO_LENGTH )* (?: ZERO_LENGTH )? }X;

Ad esempio, questo programma

#!perl -l
"aaaaab" =~ /
(?:
un # diverso da zero
| # o
(?{print "ciao"}) # stampa ciao ogni volta che questo
# ramo è stato provato
(?=(b)) # asserzione di larghezza zero
)* # un numero qualsiasi di volte
/X;
stampa $&;
stampa $1;

stampe

Ciao
AAAAA
b

Si noti che "ciao" viene stampato solo una volta, come quando Perl vede che la sesta iterazione di
il "(?:)*" più esterno corrisponde a una stringa di lunghezza zero, interrompe il "*".

I loop di livello superiore conservano uno stato aggiuntivo tra le iterazioni: se l'ultimo
la partita era di lunghezza zero. Per interrompere il ciclo, la corrispondenza seguente dopo una corrispondenza di lunghezza zero
è vietato avere una lunghezza pari a zero. Questo divieto interagisce con il backtracking (vedi
"Backtracking"), e così il secondo migliore la corrispondenza viene scelta se il migliore corrispondenza è zero
lunghezza.

Per esempio:

$_ = 'barra';
s/\w??/<$&>/g;

risulta in "<> <> <> <>". Ad ogni posizione della stringa la migliore corrispondenza data da
non avido "?? è la corrispondenza di lunghezza zero e il secondo migliore match è ciò a cui è abbinato
"\w". Pertanto, le corrispondenze di lunghezza zero si alternano a quelle di un carattere.

Allo stesso modo, per "m/()/g" ripetuti, la seconda migliore corrispondenza è la corrispondenza nella posizione uno
tacca ulteriormente nella stringa.

Lo stato addizionale dell'essere abbinato con lunghezza zero è associato alla corrispondenza
stringa e viene reimpostato da ogni assegnazione a pos (). Partite a lunghezza zero alla fine del
la corrispondenza precedente viene ignorata durante lo "split".

La combinazione di RE pezzi
Ciascuno dei pezzi elementari di espressioni regolari che sono stati descritti in precedenza (come
"ab" o "\Z") ​​potrebbero corrispondere al massimo a una sottostringa nella posizione data della stringa di input.
Tuttavia, in una tipica espressione regolare questi pezzi elementari sono combinati in più
schemi complicati che utilizzano gli operatori di combinazione "ST", "S|T", "S*" ecc. (in questi esempi
"S" e "T" sono sottoespressioni regolari).

Tali combinazioni possono includere alternative, portando a un problema di scelta: se abbiniamo a
espressione regolare "a|ab" contro "abc", corrisponderà alla sottostringa "a" o "ab"? Un modo per
descrivere quale sottostringa è effettivamente abbinata è il concetto di backtracking (vedi
"Tornare indietro"). Tuttavia, questa descrizione è di livello troppo basso e ti fa pensare in termini
di una particolare attuazione.

Un'altra descrizione inizia con le nozioni di "migliore"/"peggiore". Tutte le sottostringhe che possono
essere abbinato all'espressione regolare data può essere ordinato dalla corrispondenza "migliore" alla
corrispondenza "peggiore", ed è la corrispondenza "migliore" che viene scelta. Questo sostituisce la domanda
di "cosa viene scelto?" dalla domanda "quali partite sono migliori e quali peggiori?".

Anche in questo caso, per i pezzi elementari non esiste una domanda del genere, poiché al massimo una corrispondenza alla volta
posizione è possibile. Questa sezione descrive la nozione di migliore/peggio per la combinazione
operatori. Nella descrizione seguente "S" e "T" sono sottoespressioni regolari.

"ST"
Considera due possibili corrispondenze, "AB" e "A'B'", "A" e "A'" sono sottostringhe che possono
essere abbinato da "S", "B" e "B'" sono sottostringhe che possono essere abbinate da "T".

Se "A" è una corrispondenza migliore per "S" rispetto ad "A'", "AB" è una corrispondenza migliore di "A'B'".

Se "A" e "A'" coincidono: "AB" è una corrispondenza migliore di "AB'" se "B" è una corrispondenza migliore
per "T" rispetto a "B'".

"S|T"
Quando "S" può corrispondere, è una corrispondenza migliore rispetto a quando può corrispondere solo "T".

Ordinare due fiammiferi per "S" è lo stesso che per "S". Simile per due partite per
"T".

"S{REPEAT_COUNT}"
Corrisponde come "SSS...S" (ripetuto tutte le volte che è necessario).

"S{min,max}"
Corrisponde a "S{max}|S{max-1}|...|S{min+1}|S{min}".

"S{min,max}?"
Corrisponde a "S{min}|S{min+1}|...|S{max-1}|S{max}".

"S?", "S*", "S+"
Come rispettivamente "S{0,1}", "S{0,BIG_NUMBER}", "S{1,BIG_NUMBER}".

"S???", "S*?", "S+?"
Come "S{0,1}?", "S{0,BIG_NUMBER}?", "S{1,BIG_NUMBER}?" rispettivamente.

"(?>S)"
Corrisponde alla migliore corrispondenza per "S" e solo quella.

"(?=S)", "(?<=S)"
Viene considerata solo la migliore corrispondenza per "S". (Questo è importante solo se "S" ha
l'acquisizione di parentesi e backreference vengono utilizzati da qualche altra parte nell'intero regular
espressione.)

"(?!S)", "(?
Per questo operatore di raggruppamento non è necessario descrivere l'ordinamento, poiché only
se "S" può corrispondere o meno è importante.

"(??{ ESPR })", "(?PARNO)"
L'ordine è lo stesso dell'espressione regolare che è il risultato di EXPR, o
il modello contenuto dal gruppo di acquisizione PARNO.

"(?(condizione)sì-schema|no-schema)"
Ricorda ciò che di "yes-pattern" o "no-pattern" corrisponde effettivamente già
determinato. L'ordine delle corrispondenze è lo stesso della sottoespressione scelta.

Le ricette di cui sopra descrivono l'ordine dei fiammiferi at a dato posizione. Un'altra regola è
necessario per capire come viene determinata una corrispondenza per l'intera espressione regolare: una corrispondenza
in una posizione precedente è sempre meglio di una partita in una posizione successiva.

Creazione Custom RE Motori
A partire da Perl 5.10.0, è possibile creare motori di espressioni regolari personalizzati. Questo non è per il
deboli di cuore, poiché devono collegarsi al livello C. Vedi perlreapi per maggiori dettagli.

In alternativa, le costanti sovraccaricate (vedi sovraccarico) forniscono un modo semplice per estendere il
funzionalità del motore RE, sostituendo un pattern con un altro.

Supponiamo di voler abilitare una nuova sequenza di escape RE "\Y|" che corrisponde a un confine
tra caratteri di spazio vuoto e caratteri non di spazio vuoto. Notare che
"(?=\S)(?
"\Y|" al posto della versione più complicata. Possiamo creare un modulo "customre" a
Fai questo:

pacchetto personalizzato;
utilizzare il sovraccarico;

importazione secondaria {
cambio;
die "Nessun argomento per customre::import consentito" if @_;
sovraccarico::costante 'qr' => \&convert;
}

sub invalid { die "/$_[0]/: escape non valido '\\$_[1]'"}

# Dobbiamo anche fare attenzione a non sfuggire al legittimo \\Y|
# sequenza, da qui la presenza di '\\' nelle regole di conversione.
le mie %regole = ( '\\' => '\\\\',
'Y|' => qr/(?=\S)(?
subconvert {
il mio $re = turno;
$ri =~ s{
\\ ( \\ | Y . )
}
{$regole{$1} o non valide($re,$1) }sgex;
ritorno $re;
}

Ora "use customre" abilita il nuovo escape nelle espressioni regolari costanti, cioè quelle
senza alcuna interpolazione di variabili di runtime. Come documentato in sovraccarico, questa conversione
funzionerà solo su parti letterali di espressioni regolari. Per "\Y|$ri\Y|" la variabile
parte di questa espressione regolare deve essere convertita in modo esplicito (ma solo se special
significato di "\Y|" dovrebbe essere abilitato all'interno di $re):

utilizzare il cliente;
$ri = <>;
mastica $re;
$re = cliente::convert $re;
/\Y|$ri\Y|/;

Embedded Code Frequenza
Le regole esatte per quanto spesso (??{}) e (?{}) vengono eseguite in un pattern non sono specificate.
Nel caso di una partita riuscita, puoi presumere che DWIM e verranno eseguiti
da sinistra a destra ordina il numero di volte appropriato nel percorso di accettazione del pattern
come farebbe qualsiasi altro meta-modello. In che modo i percorsi di non accettazione e gli errori di corrispondenza influiscono sul
il numero di volte in cui viene eseguito un pattern è specificatamente non specificato e può variare a seconda
su quali ottimizzazioni possono essere applicate al pattern ed è probabile che cambi dalla versione
alla versione.

Per esempio in

"aaabcdeeeee"=~/a(?{stampa "a"})b(?{stampa "b"})cde/;

il numero esatto di volte in cui "a" o "b" vengono stampati non è specificato per il fallimento, ma tu
potrebbe presumere che verranno stampati almeno una volta durante una partita di successo, in aggiunta a te
può presumere che se viene stampata "b", sarà preceduta da almeno una "a".

Nel caso di costrutti ramificati come i seguenti:

/a(b|(?{ print "a" }))c(?{ print "c" })/;

puoi presumere che l'input "ac" produca "ac" e che "abc" produca solo "c".

Quando il codice incorporato viene quantificato, le corrispondenze riuscite chiameranno il codice una volta per ciascuna
iterazione abbinata del quantificatore. Per esempio:

"buono" =~ /g(?:o(?{print "o")))*d/;

emetterà "o" due volte.

PCRE/Pitone Assistenza
A partire da Perl 5.10.0, Perl supporta diverse estensioni specifiche per Python/PCRE alla regex
sintassi. Mentre i programmatori Perl sono incoraggiati a usare la sintassi specifica per Perl, il
sono inoltre accettati:

"(?P modello)"
Definire un gruppo di acquisizione denominato. Equivalente a "(? modello)".

"(?P=NOME)"
Backreference a un gruppo di acquisizione denominato. Equivalente a "\g{NAME}".

"(?P>NOME)"
Chiamata di subroutine a un gruppo di acquisizione denominato. Equivalente a "(?&NAME)".

Usa perlre online usando i servizi onworks.net