perlre - Espressioni regolari in Perl
14-5-2005
ricevuto modulo da Marco Saba. Analisi del testo attuale
Le espressioni regolari sono difficili per un italiano sia perché
trattano una materia poco nota alla maggiornanza dei programmatori,
sia perché introducono termini che non hanno corrispondente esatto
in italiano.
Una menzione particolare merita il vetbo ``to match'', che significa
``trovare una corrispondenza''. È diverso dal semplice ``trovare un testo'',
e questo è parte del mistero che circonda le espressioni regolari,
perché non (sempre) viene trovato un testo definito in mezzo a un testo
più grande, ma spesso si tratta di verificare la corrispondenza di un
testo a uno dato schema (pattern).
Pertanto, quando il testo inglese usa ``match'', usiamo ``corrispondere'' o ``trovare''
per definire l'azione, e ``corrispondenza'' quando si intende un risultato.
Un ``pattern'' è uno schema composto da caratteri e/o simboli che ne
indicano la composizione. Per esempio:, ``casa'' è un pattern semplice
composto da 4 caratteri; ``[Cc]asa'' è un pattern più complesso che indica
un carattere a scelta fra 'c' e 'C', seguito da tre caratteri. ``\b\w{4}\b''
è un pattern che cerca quattro caratteri alfanumerici che compongono una parola.
``case-sensitive'' e ``case-insensitive'' non hanno corrispondente in italiano.
Bisognerebbe dire ``considerando (o ignorando) maiuscole e minuscole'', ma
è più oscuro che lasciare l'originale, ed è appunto quello che abbiamo
deciso di fare.
Un carattere di ``escape'' è un carattere che cambia il significato del
carattere che lo segue. Il verbo ``to escape'' indica l'applicazione di un
tale carattere di escape.
Il ``backtracking'' è un'operazione compiuta da una regex quando, nella
ricerca di condizioni composte, dopo aver soddisfatto una delle condizioni,
torna indietro per cercare di soddisfare la seguente.
Questa pagina descrive la sintassi delle espressioni regolari (regex) in Perl.
Se non abbiamo mai utilizzato prima le regex, possiamo trovare una
veloce introduzione in perlrequick, e un tutorial più lungo
è reperibile in perlretut.
Per una guida su come le regex vengono utilizzate nelle operazioni
di match, oltre a vari esempi sullee stesse, si vedano le analisi
m//, s///, qr// e ?? in perlop/``Regexp Quote-Like Operators''.
Le operazioni di match possono avere vari modificatori. I modificatori
utilizzati nell'interpretazione interna delle regex sono elencate
di seguito. I modificatori che alterano il modo in cui una regex
è utilizzaata dal Perl sono descritti in perlop/``Regexp Quote-Like Operators'' e
perlop/``Gory details of parsing quoted constructs''.
- i
-
Opera un pattern matching case-insensitive.
Se si utilizza use locale , §§the case map§§ è utilizzata dal
locale corrente. Si veda perllocale.
- m
-
Tratta la stringa su righe multiple. In pratica, porta ``^'' e ``$'' dal matchare
l'inizio o la fine della stringa al matchare l'inizio o la fine di una qualunque
riga, dovunque all'interno della stringa.
- s
-
Tratta la stringa come una singola riga. In pratica, porta ``.'' a matchare un carattere
qualsiasi, anche un newline, che normalmente non dovrebbe matchare.
I modificatori /s e /m insisme sovrascrivono l'impostazione $*.
In pratica, non importa cosa contenga $*, /s senza /m forzerà
``^'' a matchare solo l'inizio della stringa e ``$'' a matchare
solo la fine (o appena prima di un newline alla fine) della stringa.
Insieme, cioè /ms, lasciano che il ``.'' matchi un carattere
qualsiasi, mentre permettono ancora che ``^'' e ``$'' matchino,
rispettivamente, appena dopo e appena prima i newline
all'interno della stringa.
- x
-
Estende la leggibilità del pattern permettendo spazi e commenti.
Questi sono di solito scritti come ``il modificatore /x'', anche se il delimitatore
in oggetto potrebbe non essere uno slash. Ognuno di questi
modificatori può anche essere inserito all'interno di una regex stessa utilizzando
il costrutto (?...). Si veda dopo.
Il modificatore stesso /x richiede un'ulteriore spiegazione. Dice
al parser della regex di ignorare spazi che non sono preceduti da
backslash o che non sono all'interno di una classe di caratteri. Si può usare questo
per spezzare la regex in più parti leggibili (leggermente). Il carattere #
è inoltre trattato come un metacarattere che introduce un commento,
come nel codice Perl normale. Questo ancora significa che se desideriamo uno
spazio reale o un carattere # nel pattern (fuori da una classe di caratteri,
dove non risentono di /x), bisognerà utilizzare l'escape
per entrambi o §§encode them§§ utilizzando escape ottali o esadecimali. Utilizzate insieme,
queste caratteristiche rendono le regex in Perl molto più leggibili.
Si noti che bisogna avere cura di non includere il delimitatore di pattern
nel commento, dato che il Perl non ha modo di sapere che non si intendeva
chiudere prima il pattern. Si veda il §§C-comment deletion code§§
in perlop.
I pattern utilizzati nel §§pattern mathcing del Perl§§ derivano da quelle fornite
nella Versione 8 delle §§routines§§ regex. (Le routines derivano
(lontanamente) dalla reimplementazione delle routines V8 di Henry Spencer,
liberamente ridistribuibile.) Si veda Version 8 Regular Expressions per i
dettagli.
In particolare, i seguenti metacaratteri hanno i loro significati standard
§§egrep-ish§§:
\ Quota il metacarattere successivo
^ Matcha l'inizio di una riga
. Matcha qualunque carattere (tranne il newline)
$ Matcha la fine della riga (o prima del newline alla fine)
| Alternanza
() §§Grouping§§
[] Classi di carattere
Di default, il carattere ``^'' garantisce di matchare solo
l'inizio della stringa, il carattere ``$'' slo la fine (o prima del
newline alla fine), e il Perl compie alcune ottimizzazioni assumendo
che la stringa contenga una sola riga. I newline interni
non saranno matchati da ``^'' o da ``$''. Si potrebbe comunque voler trattare
una stringa come un buffer multi-riga, cosicchè il ``^'' matcherà dopo ogni
newline all'interno della stringa, e ``$'' matcherà prima di ogni newline. Pagando
un ulteriore overhead, possiamo fare ciò utilizzando il modificatore /m
nel operatore di pattern match. (I vecchi programmi fanno ciò settando $*,
ma questa pratica è ormai deprecata.)
Per semplificare le sostituzioni multi-riga, il carattere ``.'' non matcha mai
un newline a meno che non usiamo il modificatore /s, che in realtà dice al Perl di fingere
che la stringa sia una singola riga, anche se non lo è. Il modificatore /s
sovrascrive anche l'impostazione di $*, nel caso in cui abbiamo qualche vecchio
codice che lo setta in un altro modulo (non consigliato).
I seguenti quantificatori standard sono riconosciuti:
* Matcha 0 o più volte
+ Matcha 1 o più volte
? Matcha 1 o 0 volte
{n} Matcha esattamente n volte
{n,} Matcha minimo n volte
{n,m} Matcha minimo n ma non più di m volte
(Se un parentesi grafa appare in qualunque altro contesto, è trattata
come un carattere regolare. In particolare, il limite più basso
non è opzionale.) Il modificatore ``*'' è equivalente a {0,}, il modificatore ``+''
a {1,}, e il modificatore ``?'' a {0,1}. n e m sono limitati
a valori interi a meno di un §§preset limit§§ definito quando Perl è §§built§§.
Questo numero è di solito 32766 sulle piattaforme più comuni. Il limite attuale può
essere visto nel messaggio di errore generato da un codice come il seguente:
$_ **= $_ , / {$_} / for 2 .. 42;
Di default, un §§subpattern§§ quantificato è §§``greedy''§§, cioè matcherà
il maggior numero di volte possibile (dato un particolare punto di partenza) mentre
permette ancora al resto del pattern di matchare. Se vogliamo matchare
il minimo numero di volte possibile, facciamo seguire al quantificatore un ``?''. Notiamo
che i significati non cambiano, solamente la §§``greediness''§§:
*? Matcha 0 o più volte
+? Matcha 1 o più volte
?? Matcha 1 o 0 volte
{n}? Matcha esattamente n volte
{n,}? Matcha minimo n volte
{n,m}? Matcha minimo n ma non più di m volte
Poichè i pattern sono processati come stringhe doppiamente quotate, funzionano
anche i seguenti:
\t tab (HT, TAB)
\n newline (LF, NL)
\r return (CR)
\f form feed (FF)
\a alarm (bell) (BEL)
\e escape (think troff) (ESC)
\033 octal char (think of a PDP-11)
\x1B hex char
\x{263a} wide hex char (Unicode SMILEY)
\c[ control char
\N{name} named char
\l prossimo carattere minuscolo (think vi)
\u prossimo carattere maiuscolo (think vi)
\L minuscole fino a \E (think vi)
\U maiuscole fino a \E (think vi)
\E end case modification (think vi)
\Q quota (disabilita) §§pattern metacharacters§§ till \E
Se è in uso use locale, §§the case map§§ utilizzato da \l, \L, \u
e \U è preso dal corrente §§locale§§. Si veda perllocale. Per la
documentazione di \N{name}, si veda charnames.
Non possiamo includere un letterale $ o @ all'interno di una sequenza \Q.
Un $ o un @ senza escape va ad interpolare la variabile corrispondente,
mentre l'escape porterà il \$ ad essere matchato.
Dovremo scrivere qualcosa del tipo: m/\Quser\E\@\Qhost/.
In aggiunta, Perl definisce i seguenti:
\w Matcha un carattere "parola" (alfanumerici oltre a "_")
\W Matcha un carattere non-"parola"
\s Matcha un carattere spazio
\S Match un carattere non-spazio
\d Matcha un carattere numerico
\D Matcha un carattere non-numerico
\pP Matcha P, named property. Utilizzare \p{Prop} per nomi più lunghi.
\PP Matcha non-P
\X Matcha eXtended Unicode "combining character sequence",
equivalente a (?:\PM\pM*)
\C Matcha un singolo carattere C (ottetto) anche sotto Unicode.
NOTA: spezza i caratteri in UTF-8 bytes,
so you may end up with malformed pieces of UTF-8.
Unsupported in lookbehind.
Un \w matcha un singolo carattere alfanumerico (un carattere
alfabetico, o un numero decimale) o _, ma non una parola intera. Utilizziamo \w+
per matchare una stringa di caratteri §§Perl-identifier§§ (che non è lo stesso
che matchare una parola inglese). Se use locale è in uso, la lista
dei caratteri alfabetici generata da \w è presa dal §§current locale.§§
Si veda perllocale. Possiamo utilizzare \w, \W, \s, \S,
\d, e \D all'interno delle classi di caratteri, ma se vogliamo provare ad usarli
come punti terminali di un range, §§that's not a range§§, il ``-'' è considerato
letteralmente. Se Unicode è in uso, \s matcha anche ``\x{85}'',
``\x{2028}, e ''\x{2029}``, si veda perlunicode per maggiori dettagli riguardo
\pP, \PP, e \X, e perluniintro riguardo l'Unicode in generale.
Possiamo definire nostre proprietà di \p e \P, si veda perlunicode.
Possiamo utilizzare anche la sintassi delle classi di carattere POSIX
[:class:]
Le classi a disposizione e i loro equivalenti con backslash
(se disponibili) sono i seguenti:
alpha
alnum
ascii
blank [1]
cntrl
digit \d
graph
lower
print
punct
space \s [2]
upper
word \w [3]
xdigit
- [1]
-
Un estesnione GNU equivalente a
[ \t], `tutti gli spazi orizzontali'.
- [2]
-
Non esattamente equivalente a
\s dato che [[:space:]] include
anche il (decisamente raro) §§`vertical tabulator'§§, ``\ck'', chr(11).
- [3]
-
Un'estensione Perl, si veda oltre.
Per esempio si può utilizzare [:upper:] per matchare tutti i caratteri maiuscoli.
Si noti che le [] sono parte del costrutto [::], non parte dell'intera
classe di caratteri. Per esempio:
[01[:alpha:]%]
matcha zero, uno, qualsiasi carattere alfabetico, e il segno di percentulale.
Le seguenti equivalenze ai costrutti Unicode \p{} ed equivalenti
classi di carattere con backslash (se disponibili), §§will hold§§:
[:...:] \p{...} backslash
alpha IsAlpha
alnum IsAlnum
ascii IsASCII
blank IsSpace
cntrl IsCntrl
digit IsDigit \d
graph IsGraph
lower IsLower
print IsPrint
punct IsPunct
space IsSpace
IsSpacePerl \s
upper IsUpper
word IsWord
xdigit IsXDigit
Per esempio [:lower:] e \p{IsLower} sono equivalenti.
Se il utf8 §§pragma§§ non è usato ma lo è il locale §§pragma§§, le classi
sono in correlazione con l'usuale interfaccia isalpha(3) (eccetto per
`word' e `blank').
Le classi nominate e sicuramente non scontate sono:
- cntrl
-
Qualunque carattere di controllo. Di solito sono caratteri che non producono output
come tali ma invece controllano in qualche modo il terminale: per esempio il newline e
il backspace sono caratteri di controllo. Tutti i caratteri con
ord() minore di
32 sono spesso classificati come caratteri di controllo (assumendo ASCII,
il set di caratteri ISO Latin, e Unicode), come ad esempio è il carattere con
il valore ord() 127 (DEL).
- graph
-
Qualunque carattere alfanumerico o di punteggiatura (speciale).
- print
-
Qualunque carattere alfanumerico o di punteggiatura (speciale) o il carattere spazio.
- punct
-
Qualunque carattere di punteggiatura (speciale).
- xdigit
-
Qualunque cifra esadecimale. Anche se questo può sembrare stupido ([0-9A-Fa-f] potrebbe
fare altrettanto) è incluso per completezza.
Possiamo negare la classe di caratteri [::] ponendo prima del nome della classe
il prefisso '^'. Qeusta è un'estensione Perl. Per esempio:
POSIX traditional Unicode
[:^digit:] \D \P{IsDigit}
[:^space:] \S \P{IsSpace}
[:^word:] \W \P{IsWord}
Perl rispetta lo standard POSIX in quanto le classi di carattere POSIX sono
supportate solamente all'interno di una classe di caratteri. Le classi di carattere POSIX
[.cc.] e [=cc=] sono riconosciute ma not supportate e provare ad usarle
causerà un errore.
Perl definisce le seguenti §§zero-width assertions§§:
\b Matcha un limite di parola
\B Matcha un non-(limite di parola)
\A Matcha sono all'inizio della stringa
\Z Matcha solo alla fine della stringa, o prima del newline alla fine
\z Matcha solo alla fine della stringa
\G Matcha solo a pos() (cioè alla §§end-of-match position
of prior m//g§§)
Un limite di parola (\b) è un punto tra due caratteri
che ha da una parte un \w e dall'altra un \W
(in entrambi gli ordini), contando che i caratteri immaginari
all'inizio e alla fine della stringa matchano con \W. (All'interno
delle classi di carattere \b rappresenta un backspace piuttosto che
un limite di parola, come normalmente fa in qualunque stringa doppiamente quotata.)
Il \A e \Z sono semplicemente come ``^'' e ``$'', tranne che
non matcheranno più volte quando viene utilizzato il modificatore /m,
mentre ``^'' e ``$'' matcheranno ogni limite di stringa interno. Per matchare
la fine attuale della stringa e non ignorare un §§optional trailing§§
newline, utilizziamo \z.
L'asserzione \G può essere usata per legare dei match globali
(utilizzando m//g), come descritto in perlop/``Regexp Quote-Like Operators''.
È anche utile quando §§when writing lex-like scanners§§, quando abbiamo
diversi pattern che vogliamo matchare in sottostringhe consecutive
della nostra stringa; si veda il riferimento precedente. L'attuale posizione
in cui \G matcherà può anche essere influenzata utilizzando pos()
come un lvalue: si veda perlfunc/pos. Ora \G è completamente
supportato solo quando è ancorato all'inizio del pattern; anche se
è permesso utilizzarlo dovunque, come in /(?<=\G..)./g, altri
utilizzi (/.\G/g, per esempio) causano problemi, ed è
raccomandato evitare per ora tali utilizzi.
Il costrutto con parentesi ( ... ) crea dei buffers di cattura. Per
riferirsi all' n-esimo buffer utilizziamo \n all'interno del
match. Al di furoi del match utilizziamo ``$'' al posto di ``\''. (La
notazione \n funziona in alcune circostanze anche al di fuori del
match. Per i dettagli, si veda oltre il chiarimento riguardo a \1 e $1.)
Il riferimento all'indietro ad un'altra porzione di match
è chiamata §§backreference§§.
Non c'è limite al numero di sottostringhe catturate che possiamo
utilizzare. Comunque Perl utilizza anche \10, \11, etc. come alias per \010,
\011, etc. (Ricordiamoci che 0 significa ottale, cioè \011 è il carattere
in posizione 9 nel nostro set di caratteri, che dovrebbe il decimo carattere,
un tab orizzontale in ASCII.) perl risolve questa ambiguità
interpretando \10 come un §§backreference§§ solo se sono state aperte
almeno 10 parentesi prima di questo. Allo stesso modo \11 è un
§§backreference§§ solo se sono state aperte come minimo 11 parentesi
prima. E così via. Da \1 a \9 sono sempre interpretate come
dei §§backreferences§§.
Esempi:
s/^([^ ]*) *([^ ]*)/$2 $1/; # inverte di posizione le prime due parole
if (/(.)\1/) { # trova i primi caratteri doppi
print "'$1' è il primo carattere doppio\n";
}
if (/Ora: (..):(..):(..)/) { # trova i valori
$ore = $1;
$minuti = $2;
$secondi = $3;
}
Esistono ancora diverse variabili speciali che si riferiscono
a porzioni del precedente match. $+ restituisce qualsiasi cosa
abbia trovato l'ultimo match con parentesi.
$& restituisce l'intera stringa matchata. (Un tempo $0 faceva
lo stesso, ma ora restituisce il nome del programma.) $` restituisce
qualsiasi cosa prima della stringa matchata. $' restituisce
tutto ciò che si trova dopo la stringa matchata. E $^N contiene
tutto ciò che è stato matchato dal più recente §§closed group§§
(submatch). $^N può essere utilizzato in pattern estesi
(si veda oltre), per esempio per assegnare un submatch ad una
variabile.
Le variabili numeriche ($1, $2, $3, etc.) e il relativo set di
variabili §§``punteggiatura''§§
($+, $&, $`, $', e $^N) sono tutte dinamicamente §§scoped§§
sino alla fine del blocco di chiusura o sino al successivo
match che ha successo, qualunque cosa venga prima. (Si veda perlsyn/``Compound Statements''.)
NOTA: i match falliti in Perl non resettano le variabili di match,
il che rende più facile scrivere codice per provare una serie di più
casi specifici e ricordare il match migliore.
ATTENZIONE: Una volta che Perl vede che abbiamo bisogno di uno tra $&, $`, o
$' dovunque nel programma, li rende disponibili per ogni match su
pattern. Questo potrebbe notevolmente rallenatere il nostro programma. Perl
utilizza lo stesso meccanismo per fornire $1, $2, etc, cosicchè
perdiamo qualcosa per ogni pattern che contiene parentesi di cattura. (Per
evitare questa perdita utilizzando comunque il grouping, utilizziamo invece
l'espressione regolare estesa (?: ... ).) Ma se non utilizziamo mai
$&, $` o $', allora i pattern senza parentesi di cattura
non saranno penalizzati. In pratica è meglio evitare $&, $', e $`
se possiamo, ma se non possiamo (e alcuni algoritmi li apprezzeranno),
una volta che li abbiamo utilizzati, sfruttiamoli a piacere, poichè
avremo già perso qualcosa. Dalla versione 5.005, $& non è così §§``costoso''§§
come i due restanti.
I metacaratteri preceduti da backslash in Perl sono alfanumerici, come \b,
\w, \n. Diversamente da altri linguaggi che utilizzano espressioni regolari,
non vi sono simboli preceduti da backslash che non siano alfanumerici. Così
qualunque cosa che assomigli a \\, \(, \), \<, \>, \{, o \} è sempre
interpretato come un carattere letterale, non come un metacarattere. Questo era
utilizzato nel linguaggio comune per disabilitare o quotare il significato speciale
dei metacaratteri di un'espresssione regolare in una stringa che volevamo utilizzare
come pattern. Semplicemente quotiamo tutti i caratteri non-``parola'':
$pattern =~ s/(\W)/\\$1/g;
(Se è settato use locale, allora questo dipende dal §§locale§§ corrente.)
Oggi è più comune utilizzare la funzione quotemeta() o la sequenza di escape \Q
per disabilitare il significato speciale dei metacartteri,
come il seguente:
/$nonquotato\Q$quotato\E$nonquotato/
Facciamo attenzione che se mettiamo backslash letterali (quelli che non si trovano
all'interno di variabili interpolate) tra \Q e \E, l'interpolazione
con doppio backslash può condurre a risultati fuorvianti. Se
abbiamo bisogno di usare i backslah letterali all'interno \Q...\E,
possiamo consultare perlop/``Gory details of parsing quoted constructs''.
Perl definisce inoltre una consistente sintassi di estensione per
caratteristiche che non si trovano in tools standard come awk e lex.
La sintassi si compone di un paio di parentesi con un punto interrogativo come
primo carattere cosa all'interno delle parentesi.
Il carattere dopo il punto di domanda indica l'estensione.
La stabilità di queste estensioni varia largamente. Qualcuna ha fatto
parte del nucleo del linguaggio per motli anni. Altre sono sperimentali
e potrebbero cambiare senza nessun avviso o essere completamente rimosse.
Si controlli la documentazione su ogni singola feature per verificare
il suo stato corrente.
Un punto interrogativo era stato scelto per questo e per il costrutto
di match minimo perchè 1) i punti interrogativi sono rari nelle più vecchie
espressioni regolari, e 2) quando ne vediamo una, dovremmo fermarci e
``interrogarci'' su cosa esattamente stia succedendo. Questa è psicologia...
(?#text)
-
Un commento. Il testo è ignorato. Se il modificatore
/x abilita
la formattazione degli spazi, un semplice # basterà. Si noti che Perl
termina il commento appena vede una ), quindi non c'è modo
di mettere un ) letterale nel commento.
(?imsx-imsx)
-
Uno o più modificatori interni del match su pattern, che possono essere attivati
(o disattivati, se preceduti da
-) per il resto del pattern o
per il resto del pattern group racchiuso (se esiste). Questo è
particolarmente utile per i pattern dinamici, come alcuni che vengono presi da
un file di configurazione, letti come un argomento, sono specificati in una tabella
da qualche parte, etc. Dobbiamo considerare il fattto che alcuni di questi
sono case-sensitive ed altri invece no. Quelli che sono case insensitive devono
semplicemente contenere (?i) all'inizio del pattern. Per esempio:
$pattern = "foobar";
if ( /$pattern/i ) { }
# più flessibile:
$pattern = "(?i)foobar";
if ( /$pattern/ ) { }
These modifiers are restored at the end of the enclosing group. For example,
( (?i) blah ) \s+ \1
will match a repeated (including the case!) word blah in any
case, assuming x modifier, and no i modifier outside this
group.
(?:pattern)
-
(?imsx-imsx:pattern)
-
This is for clustering, not capturing; it groups subexpressions like
``()'', but doesn't make backreferences as ``()'' does. So
@fields = split(/\b(?:a|b|c)\b/)
is like
@fields = split(/\b(a|b|c)\b/)
but doesn't spit out extra fields. It's also cheaper not to capture
characters if you don't need to.
Any letters between ? and : act as flags modifiers as with
(?imsx-imsx). For example,
/(?s-i:more.*than).*million/i
is equivalent to the more verbose
/(?:(?s-i)more.*than).*million/i
(?=pattern)
-
A zero-width positive look-ahead assertion. For example,
/\w+(?=\t)/
matches a word followed by a tab, without including the tab in $&.
(?!pattern)
-
A zero-width negative look-ahead assertion. For example
/foo(?!bar)/
matches any occurrence of ``foo'' that isn't followed by ``bar''. Note
however that look-ahead and look-behind are NOT the same thing. You cannot
use this for look-behind.
If you are looking for a ``bar'' that isn't preceded by a ``foo'', /(?!foo)bar/
will not do what you want. That's because the (?!foo) is just saying that
the next thing cannot be ``foo''--and it's not, it's a ``bar'', so ``foobar'' will
match. You would have to do something like /(?!foo)...bar/ for that. We
say ``like'' because there's the case of your ``bar'' not having three characters
before it. You could cover that this way: /(?:(?!foo)...|^.{0,2})bar/.
Sometimes it's still easier just to say:
if (/bar/ && $` !~ /foo$/)
For look-behind see below.
(?<=pattern)
-
A zero-width positive look-behind assertion. For example,
/(?<=\t)\w+/
matches a word that follows a tab, without including the tab in $&.
Works only for fixed-width look-behind.
(?<!pattern)
-
A zero-width negative look-behind assertion. For example
/(?<!bar)foo/
matches any occurrence of ``foo'' that does not follow ``bar''. Works
only for fixed-width look-behind.
(?{ code })
-
WARNING: This extended regular expression feature is considered
highly experimental, and may be changed or deleted without notice.
This zero-width assertion evaluates any embedded Perl code. It
always succeeds, and its code is not interpolated. Currently,
the rules to determine where the code ends are somewhat convoluted.
This feature can be used together with the special variable $^N to
capture the results of submatches in variables without having to keep
track of the number of nested parentheses. For example:
$_ = "The brown fox jumps over the lazy dog";
/the (\S+)(?{ $color = $^N }) (\S+)(?{ $animal = $^N })/i;
print "color = $color, animal = $animal\n";
Inside the (?{...}) block, $_ refers to the string the regular
expression is matching against. You can also use pos() to know what is
the current position of matching withing this string.
The code is properly scoped in the following sense: If the assertion
is backtracked (compare Backtracking), all changes introduced after
localization are undone, so that
$_ = 'a' x 8;
m<
(?{ $cnt = 0 }) # Initialize $cnt.
(
a
(?{
local $cnt = $cnt + 1; # Update $cnt, backtracking-safe.
})
)*
aaaa
(?{ $res = $cnt }) # On success copy to non-localized
# location.
>x;
will set $res = 4. Note that after the match, $cnt returns to the globally
introduced value, because the scopes that restrict local operators
are unwound.
This assertion may be used as a (?(condition)yes-pattern|no-pattern)
switch. If not used in this way, the result of evaluation of
code is put into the special variable $^R. This happens
immediately, so $^R can be used from other (?{ code }) assertions
inside the same regular expression.
The assignment to $^R above is properly localized, so the old
value of $^R is restored if the assertion is backtracked; compare
Backtracking.
For reasons of security, this construct is forbidden if the regular
expression involves run-time interpolation of variables, unless the
perilous use re 'eval' pragma has been used (see re), or the
variables contain results of qr// operator (see
perlop/``qr/STRING/imosx'').
This restriction is because of the wide-spread and remarkably convenient
custom of using run-time determined strings as patterns. For example:
$re = <>;
chomp $re;
$string =~ /$re/;
Before Perl knew how to execute interpolated code within a pattern,
this operation was completely safe from a security point of view,
although it could raise an exception from an illegal pattern. If
you turn on the use re 'eval', though, it is no longer secure,
so you should only do so if you are also using taint checking.
Better yet, use the carefully constrained evaluation within a Safe
compartment. See perlsec for details about both these mechanisms.
(??{ code })
-
WARNING: This extended regular expression feature is considered
highly experimental, and may be changed or deleted without notice.
A simplified version of the syntax may be introduced for commonly
used idioms.
This is a ``postponed'' regular subexpression. The code is evaluated
at run time, at the moment this subexpression may match. The result
of evaluation is considered as a regular expression and matched as
if it were inserted instead of this construct.
The code is not interpolated. As before, the rules to determine
where the code ends are currently somewhat convoluted.
The following pattern matches a parenthesized group:
$re = qr{
\(
(?:
(?> [^()]+ ) # Non-parens without backtracking
|
(??{ $re }) # Group with matching parens
)*
\)
}x;
(?>pattern)
-
WARNING: This extended regular expression feature is considered
highly experimental, and may be changed or deleted without notice.
An ``independent'' subexpression, one which matches the substring
that a standalone pattern would match if anchored at the given
position, and it matches nothing other than this substring. This
construct is useful for optimizations of what would otherwise be
``eternal'' matches, because it will not backtrack (see Backtracking).
It may also be useful in places where the ``grab all you can, and do not
give anything back'' semantic is desirable.
For example: ^(?>a*)ab will never match, since (?>a*)
(anchored at the beginning of string, as above) will match all
characters a at the beginning of string, leaving no a for
ab to match. In contrast, a*ab will match the same as a+b,
since the match of the subgroup a* is influenced by the following
group ab (see Backtracking). In particular, a* inside
a*ab will match fewer characters than a standalone a*, since
this makes the tail match.
An effect similar to (?>pattern) may be achieved by writing
(?=(pattern))\1. This matches the same substring as a standalone
a+, and the following \1 eats the matched string; it therefore
makes a zero-length assertion into an analogue of (?>...).
(The difference between these two constructs is that the second one
uses a capturing group, thus shifting ordinals of backreferences
in the rest of a regular expression.)
Consider this pattern:
m{ \(
(
[^()]+ # x+
|
\( [^()]* \)
)+
\)
}x
That will efficiently match a nonempty group with matching parentheses
two levels deep or less. However, if there is no such group, it
will take virtually forever on a long string. That's because there
are so many different ways to split a long string into several
substrings. This is what (.+)+ is doing, and (.+)+ is similar
to a subpattern of the above pattern. Consider how the pattern
above detects no-match on ((()aaaaaaaaaaaaaaaaaa in several
seconds, but that each extra letter doubles this time. This
exponential performance will make it appear that your program has
hung. However, a tiny change to this pattern
m{ \(
(
(?> [^()]+ ) # change x+ above to (?> x+ )
|
\( [^()]* \)
)+
\)
}x
which uses (?>...) matches exactly when the one above does (verifying
this yourself would be a productive exercise), but finishes in a fourth
the time when used on a similar string with 1000000 as. Be aware,
however, that this pattern currently triggers a warning message under
the use warnings pragma or -w switch saying it
"matches null string many times in regex".
On simple groups, such as the pattern (?> [^()]+ ), a comparable
effect may be achieved by negative look-ahead, as in [^()]+ (?! [^()] ).
This was only 4 times slower on a string with 1000000 as.
The ``grab all you can, and do not give anything back'' semantic is desirable
in many situations where on the first sight a simple ()* looks like
the correct solution. Suppose we parse text with comments being delimited
by # followed by some optional (horizontal) whitespace. Contrary to
its appearance, #[ \t]* is not the correct subexpression to match
the comment delimiter, because it may ``give up'' some whitespace if
the remainder of the pattern can be made to match that way. The correct
answer is either one of these:
(?>#[ \t]*)
#[ \t]*(?![ \t])
For example, to grab non-empty comments into $1, one should use either
one of these:
/ (?> \# [ \t]* ) ( .+ ) /x;
/ \# [ \t]* ( [^ \t] .* ) /x;
Which one you pick depends on which of these expressions better reflects
the above specification of comments.
(?(condition)yes-pattern|no-pattern)
-
(?(condition)yes-pattern)
-
WARNING: This extended regular expression feature is considered
highly experimental, and may be changed or deleted without notice.
Conditional expression. (condition) should be either an integer in
parentheses (which is valid if the corresponding pair of parentheses
matched), or look-ahead/look-behind/evaluate zero-width assertion.
For example:
m{ ( \( )?
[^()]+
(?(1) \) )
}x
matches a chunk of non-parentheses, possibly included in parentheses
themselves.
NOTE: This section presents an abstract approximation of regular
expression behavior. For a more rigorous (and complicated) view of
the rules involved in selecting a match among possible alternatives,
see Combining pieces together.
A fundamental feature of regular expression matching involves the
notion called backtracking, which is currently used (when needed)
by all regular expression quantifiers, namely *, *?, +,
+?, {n,m}, and {n,m}?. Backtracking is often optimized
internally, but the general principle outlined here is valid.
For a regular expression to match, the entire regular expression must
match, not just part of it. So if the beginning of a pattern containing a
quantifier succeeds in a way that causes later parts in the pattern to
fail, the matching engine backs up and recalculates the beginning
part--that's why it's called backtracking.
Here is an example of backtracking: Let's say you want to find the
word following ``foo'' in the string ``Food is on the foo table.'':
$_ = "Food is on the foo table.";
if ( /\b(foo)\s+(\w+)/i ) {
print "$2 follows $1.\n";
}
When the match runs, the first part of the regular expression (\b(foo))
finds a possible match right at the beginning of the string, and loads up
$1 with ``Foo''. However, as soon as the matching engine sees that there's
no whitespace following the ``Foo'' that it had saved in $1, it realizes its
mistake and starts over again one character after where it had the
tentative match. This time it goes all the way until the next occurrence
of ``foo''. The complete regular expression matches this time, and you get
the expected output of ``table follows foo.''
Sometimes minimal matching can help a lot. Imagine you'd like to match
everything between ``foo'' and ``bar''. Initially, you write something
like this:
$_ = "The food is under the bar in the barn.";
if ( /foo(.*)bar/ ) {
print "got <$1>\n";
}
Which perhaps unexpectedly yields:
got <d is under the bar in the >
That's because .* was greedy, so you get everything between the
first ``foo'' and the last ``bar''. Here it's more effective
to use minimal matching to make sure you get the text between a ``foo''
and the first ``bar'' thereafter.
if ( /foo(.*?)bar/ ) { print "got <$1>\n" }
got <d is under the >
Here's another example: let's say you'd like to match a number at the end
of a string, and you also want to keep the preceding part of the match.
So you write this:
$_ = "I have 2 numbers: 53147";
if ( /(.*)(\d*)/ ) { # Wrong!
print "Beginning is <$1>, number is <$2>.\n";
}
That won't work at all, because .* was greedy and gobbled up the
whole string. As \d* can match on an empty string the complete
regular expression matched successfully.
Beginning is <I have 2 numbers: 53147>, number is <>.
Here are some variants, most of which don't work:
$_ = "I have 2 numbers: 53147";
@pats = qw{
(.*)(\d*)
(.*)(\d+)
(.*?)(\d*)
(.*?)(\d+)
(.*)(\d+)$
(.*?)(\d+)$
(.*)\b(\d+)$
(.*\D)(\d+)$
};
for $pat (@pats) {
printf "%-12s ", $pat;
if ( /$pat/ ) {
print "<$1> <$2>\n";
} else {
print "FAIL\n";
}
}
That will print out:
(.*)(\d*) <I have 2 numbers: 53147> <>
(.*)(\d+) <I have 2 numbers: 5314> <7>
(.*?)(\d*) <> <>
(.*?)(\d+) <I have > <2>
(.*)(\d+)$ <I have 2 numbers: 5314> <7>
(.*?)(\d+)$ <I have 2 numbers: > <53147>
(.*)\b(\d+)$ <I have 2 numbers: > <53147>
(.*\D)(\d+)$ <I have 2 numbers: > <53147>
As you see, this can be a bit tricky. It's important to realize that a
regular expression is merely a set of assertions that gives a definition
of success. There may be 0, 1, or several different ways that the
definition might succeed against a particular string. And if there are
multiple ways it might succeed, you need to understand backtracking to
know which variety of success you will achieve.
When using look-ahead assertions and negations, this can all get even
trickier. Imagine you'd like to find a sequence of non-digits not
followed by ``123''. You might try to write that as
$_ = "ABC123";
if ( /^\D*(?!123)/ ) { # Wrong!
print "Yup, no 123 in $_\n";
}
But that isn't going to match; at least, not the way you're hoping. It
claims that there is no 123 in the string. Here's a clearer picture of
why that pattern matches, contrary to popular expectations:
$x = 'ABC123' ;
$y = 'ABC445' ;
print "1: got $1\n" if $x =~ /^(ABC)(?!123)/ ;
print "2: got $1\n" if $y =~ /^(ABC)(?!123)/ ;
print "3: got $1\n" if $x =~ /^(\D*)(?!123)/ ;
print "4: got $1\n" if $y =~ /^(\D*)(?!123)/ ;
This prints
2: got ABC
3: got AB
4: got ABC
You might have expected test 3 to fail because it seems to a more
general purpose version of test 1. The important difference between
them is that test 3 contains a quantifier (\D*) and so can use
backtracking, whereas test 1 will not. What's happening is
that you've asked ``Is it true that at the start of $x, following 0 or more
non-digits, you have something that's not 123?'' If the pattern matcher had
let \D* expand to ``ABC'', this would have caused the whole pattern to
fail.
The search engine will initially match \D* with ``ABC''. Then it will
try to match (?!123 with ``123'', which fails. But because
a quantifier (\D*) has been used in the regular expression, the
search engine can backtrack and retry the match differently
in the hope of matching the complete regular expression.
The pattern really, really wants to succeed, so it uses the
standard pattern back-off-and-retry and lets \D* expand to just ``AB'' this
time. Now there's indeed something following ``AB'' that is not
``123''. It's ``C123'', which suffices.
We can deal with this by using both an assertion and a negation.
We'll say that the first part in $1 must be followed both by a digit
and by something that's not ``123''. Remember that the look-aheads
are zero-width expressions--they only look, but don't consume any
of the string in their match. So rewriting this way produces what
you'd expect; that is, case 5 will fail, but case 6 succeeds:
print "5: got $1\n" if $x =~ /^(\D*)(?=\d)(?!123)/ ;
print "6: got $1\n" if $y =~ /^(\D*)(?=\d)(?!123)/ ;
6: got ABC
In other words, the two zero-width assertions next to each other work as though
they're ANDed together, just as you'd use any built-in assertions: /^$/
matches only if you're at the beginning of the line AND the end of the
line simultaneously. The deeper underlying truth is that juxtaposition in
regular expressions always means AND, except when you write an explicit OR
using the vertical bar. /ab/ means match ``a'' AND (then) match ``b'',
although the attempted matches are made at different positions because ``a''
is not a zero-width assertion, but a one-width assertion.
WARNING: particularly complicated regular expressions can take
exponential time to solve because of the immense number of possible
ways they can use backtracking to try match. For example, without
internal optimizations done by the regular expression engine, this will
take a painfully long time to run:
'aaaaaaaaaaaa' =~ /((a{0,5}){0,5})*[c]/
And if you used *'s in the internal groups instead of limiting them
to 0 through 5 matches, then it would take forever--or until you ran
out of stack space. Moreover, these internal optimizations are not
always applicable. For example, if you put {0,5} instead of *
on the external group, no current optimization is applicable, and the
match takes a long time to finish.
A powerful tool for optimizing such beasts is what is known as an
``independent group'',
which does not backtrack (see < (?>pattern) >). Note also that
zero-length look-ahead/look-behind assertions will not backtrack to make
the tail match, since they are in ``logical'' context: only
whether they match is considered relevant. For an example
where side-effects of look-ahead might have influenced the
following match, see < (?>pattern) >.
In case you're not familiar with the ``regular'' Version 8 regex
routines, here are the pattern-matching rules not described above.
Any single character matches itself, unless it is a metacharacter
with a special meaning described here or above. You can cause
characters that normally function as metacharacters to be interpreted
literally by prefixing them with a ``\'' (e.g., ``\.'' matches a ``.'', not any
character; ``\\'' matches a ``\''). A series of characters matches that
series of characters in the target string, so the pattern blurfl
would match ``blurfl'' in the target string.
You can specify a character class, by enclosing a list of characters
in [], which will match any one character from the list. If the
first character after the ``['' is ``^'', the class matches any character not
in the list. Within a list, the ``-'' character specifies a
range, so that a-z represents all characters between ``a'' and ``z'',
inclusive. If you want either ``-'' or ``]'' itself to be a member of a
class, put it at the start of the list (possibly after a ``^''), or
escape it with a backslash. ``-'' is also taken literally when it is
at the end of the list, just before the closing ``]''. (The
following all specify the same class of three characters: [-az],
[az-], and [a\-z]. All are different from [a-z], which
specifies a class containing twenty-six characters, even on EBCDIC
based coded character sets.) Also, if you try to use the character
classes \w, \W, \s, \S, \d, or \D as endpoints of
a range, that's not a range, the ``-'' is understood literally.
Note also that the whole range idea is rather unportable between
character sets--and even within character sets they may cause results
you probably didn't expect. A sound principle is to use only ranges
that begin from and end at either alphabets of equal case ([a-e],
[A-E]), or digits ([0-9]). Anything else is unsafe. If in doubt,
spell out the character sets in full.
Characters may be specified using a metacharacter syntax much like that
used in C: ``\n'' matches a newline, ``\t'' a tab, ``\r'' a carriage return,
``\f'' a form feed, etc. More generally, \nnn, where nnn is a string
of octal digits, matches the character whose coded character set value
is nnn. Similarly, \xnn, where nn are hexadecimal digits,
matches the character whose numeric value is nn. The expression \cx
matches the character control-x. Finally, the ``.'' metacharacter
matches any character except ``\n'' (unless you use /s).
You can specify a series of alternatives for a pattern using ``|'' to
separate them, so that fee|fie|foe will match any of ``fee'', ``fie'',
or ``foe'' in the target string (as would f(e|i|o)e). The
first alternative includes everything from the last pattern delimiter
(``('', ``['', or the beginning of the pattern) up to the first ``|'', and
the last alternative contains everything from the last ``|'' to the next
pattern delimiter. That's why it's common practice to include
alternatives in parentheses: to minimize confusion about where they
start and end.
Alternatives are tried from left to right, so the first
alternative found for which the entire expression matches, is the one that
is chosen. This means that alternatives are not necessarily greedy. For
example: when matching foo|foot against ``barefoot'', only the ``foo''
part will match, as that is the first alternative tried, and it successfully
matches the target string. (This might not seem important, but it is
important when you are capturing matched text using parentheses.)
Also remember that ``|'' is interpreted as a literal within square brackets,
so if you write [fee|fie|foe] you're really only matching [feio|].
Within a pattern, you may designate subpatterns for later reference
by enclosing them in parentheses, and you may refer back to the
nth subpattern later in the pattern using the metacharacter
\n. Subpatterns are numbered based on the left to right order
of their opening parenthesis. A backreference matches whatever
actually matched the subpattern in the string being examined, not
the rules for that subpattern. Therefore, (0|0x)\d*\s\1\d* will
match ``0x1234 0x4321'', but not ``0x1234 01234'', because subpattern
1 matched ``0x'', even though the rule 0|0x could potentially match
the leading 0 in the second number.
Some people get too used to writing things like:
$pattern =~ s/(\W)/\\\1/g;
This is grandfathered for the RHS of a substitute to avoid shocking the
sed addicts, but it's a dirty habit to get into. That's because in
PerlThink, the righthand side of an s/// is a double-quoted string. \1 in
the usual double-quoted string means a control-A. The customary Unix
meaning of \1 is kludged in for s///. However, if you get into the habit
of doing that, you get yourself into trouble if you then add an /e
modifier.
s/(\d+)/ \1 + 1 /eg; # causes warning under -w
Or if you try to do
s/(\d+)/\1000/;
You can't disambiguate that by saying \{1}000, whereas you can fix it with
${1}000. The operation of interpolation should not be confused
with the operation of matching a backreference. Certainly they mean two
different things on the left side of the s///.
WARNING: Difficult material (and prose) ahead. This section needs a rewrite.
Regular expressions provide a terse and powerful programming language. As
with most other power tools, power comes together with the ability
to wreak havoc.
A common abuse of this power stems from the ability to make infinite
loops using regular expressions, with something as innocuous as:
'foo' =~ m{ ( o? )* }x;
The o? can match at the beginning of 'foo', and since the position
in the string is not moved by the match, o? would match again and again
because of the * modifier. Another common way to create a similar cycle
is with the looping modifier //g:
@matches = ( 'foo' =~ m{ o? }xg );
or
print "match: <$&>\n" while 'foo' =~ m{ o? }xg;
or the loop implied by split().
However, long experience has shown that many programming tasks may
be significantly simplified by using repeated subexpressions that
may match zero-length substrings. Here's a simple example being:
@chars = split //, $string; # // is not magic in split
($whitewashed = $string) =~ s/()/ /g; # parens avoid magic s// /
Thus Perl allows such constructs, by forcefully breaking
the infinite loop. The rules for this are different for lower-level
loops given by the greedy modifiers *+{}, and for higher-level
ones like the /g modifier or split() operator.
The lower-level loops are interrupted (that is, the loop is
broken) when Perl detects that a repeated expression matched a
zero-length substring. Thus
m{ (?: NON_ZERO_LENGTH | ZERO_LENGTH )* }x;
is made equivalent to
m{ (?: NON_ZERO_LENGTH )*
|
(?: ZERO_LENGTH )?
}x;
The higher level-loops preserve an additional state between iterations:
whether the last match was zero-length. To break the loop, the following
match after a zero-length match is prohibited to have a length of zero.
This prohibition interacts with backtracking (see Backtracking),
and so the second best match is chosen if the best match is of
zero length.
For example:
$_ = 'bar';
s/\w??/<$&>/g;
results in <><b><><a><><r><>. At each position of the string the best
match given by non-greedy ?? is the zero-length match, and the second
best match is what is matched by \w. Thus zero-length matches
alternate with one-character-long matches.
Similarly, for repeated m/()/g the second-best match is the match at the
position one notch further in the string.
The additional state of being matched with zero-length is associated with
the matched string, and is reset by each assignment to pos().
Zero-length matches at the end of the previous match are ignored
during split.
Each of the elementary pieces of regular expressions which were described
before (such as ab or \Z) could match at most one substring
at the given position of the input string. However, in a typical regular
expression these elementary pieces are combined into more complicated
patterns using combining operators ST, S|T, S* etc
(in these examples S and T are regular subexpressions).
Such combinations can include alternatives, leading to a problem of choice:
if we match a regular expression a|ab against "abc", will it match
substring "a" or "ab"? One way to describe which substring is
actually matched is the concept of backtracking (see Backtracking).
However, this description is too low-level and makes you think
in terms of a particular implementation.
Another description starts with notions of ``better''/``worse''. All the
substrings which may be matched by the given regular expression can be
sorted from the ``best'' match to the ``worst'' match, and it is the ``best''
match which is chosen. This substitutes the question of ``what is chosen?''
by the question of ``which matches are better, and which are worse?''.
Again, for elementary pieces there is no such question, since at most
one match at a given position is possible. This section describes the
notion of better/worse for combining operators. In the description
below S and T are regular subexpressions.
ST
-
Consider two possible matches,
AB and A'B', A and A' are
substrings which can be matched by S, B and B' are substrings
which can be matched by T.
If A is better match for S than A', AB is a better
match than A'B'.
If A and A' coincide: AB is a better match than AB' if
B is better match for T than B'.
S|T
-
When
S can match, it is a better match than when only T can match.
Ordering of two matches for S is the same as for S. Similar for
two matches for T.
S{REPEAT_COUNT}
-
Matches as
SSS...S (repeated as many times as necessary).
S{min,max}
-
Matches as
S{max}|S{max-1}|...|S{min+1}|S{min}.
S{min,max}?
-
Matches as
S{min}|S{min+1}|...|S{max-1}|S{max}.
S?, S*, S+
-
Same as
S{0,1}, S{0,BIG_NUMBER}, S{1,BIG_NUMBER} respectively.
S??, S*?, S+?
-
Same as
S{0,1}?, S{0,BIG_NUMBER}?, S{1,BIG_NUMBER}? respectively.
(?>S)
-
Matches the best match for
S and only that.
(?=S), (?<=S)
-
Only the best match for
S is considered. (This is important only if
S has capturing parentheses, and backreferences are used somewhere
else in the whole regular expression.)
(?!S), (?<!S)
-
For this grouping operator there is no need to describe the ordering, since
only whether or not
S can match is important.
(??{ EXPR })
-
The ordering is the same as for the regular expression which is
the result of EXPR.
(?(condition)yes-pattern|no-pattern)
-
Recall that which of
yes-pattern or no-pattern actually matches is
already determined. The ordering of the matches is the same as for the
chosen subexpression.
The above recipes describe the ordering of matches at a given position.
One more rule is needed to understand how a match is determined for the
whole regular expression: a match at an earlier position is always better
than a match at a later position.
Overloaded constants (see overload) provide a simple way to extend
the functionality of the RE engine.
Suppose that we want to enable a new RE escape-sequence \Y| which
matches at boundary between white-space characters and non-whitespace
characters. Note that (?=\S)(?<!\S)|(?!\S)(?<=\S) matches exactly
at these positions, so we want to have each \Y| in the place of the
more complicated version. We can create a module customre to do
this:
package customre;
use overload;
sub import {
shift;
die "No argument to customre::import allowed" if @_;
overload::constant 'qr' => \&convert;
}
sub invalid { die "/$_[0]/: invalid escape '\\$_[1]'"}
my %rules = ( '\\' => '\\',
'Y|' => qr/(?=\S)(?<!\S)|(?!\S)(?<=\S)/ );
sub convert {
my $re = shift;
$re =~ s{
\\ ( \\ | Y . )
}
{ $rules{$1} or invalid($re,$1) }sgex;
return $re;
}
Now use customre enables the new escape in constant regular
expressions, i.e., those without any runtime variable interpolations.
As documented in overload, this conversion will work only over
literal parts of regular expressions. For \Y|$re\Y| the variable
part of this regular expression needs to be converted explicitly
(but only if the special meaning of \Y| should be enabled inside $re):
use customre;
$re = <>;
chomp $re;
$re = customre::convert $re;
/\Y|$re\Y|/;
This document varies from difficult to understand to completely
and utterly opaque. The wandering prose riddled with jargon is
hard to fathom in several places.
This document needs a rewrite that separates the tutorial content
from the reference content.
perlrequick.
perlretut.
perlop/``Regexp Quote-Like Operators''.
perlop/``Gory details of parsing quoted constructs''.
perlfaq6.
perlfunc/pos.
perllocale.
perlebcdic.
Mastering Regular Expressions by Jeffrey Friedl, published
by O'Reilly and Associates.
La versione su cui si basa questa traduzione è ottenibile con:
perl -MPOD2::IT -e print_pod perlre
Per maggiori informazioni sul progetto di traduzione in italiano si veda
http://pod2it.sourceforge.net/ .
Traduzione a cura di perlinux, Giuseppe Maxia.
Revisione a cura di Giuseppe Maxia.
Mon Jun 11 22:02:20 2012
| 