perlreref - Guida di riferimento rapida alle Espressioni regolari in Perl
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 è una guida di riferimento rapida alle espressioni regolari (regex) in Perl. Per maggiori informazioni vedete perlre e perlop, e la sezione "VEDI ANCHE"
=~ determina la variabile su cui si applica la regex In sua assenza, viene usato $_. $var =~ /foo/; !~ determina la variabile su cui si applica la regex e inverte il risultato dell'operazione. Restituisce false se c'è una corrispondenza, vero se non la si trova. $var !~ /foo/; m/pattern/igmsoxc cerca un pattern in una stringa. applicando le opzioni date. i case-Insensitive g Globale - tutte le occorrenze m Modo multi-riga - ^ and $ trovano inizio e fine righeinterne s Cerca in una riga sinola. - . trova \n o compila l'espressione solo una volta x leggibilità estesa. Spazi e commenti ammessi c non azzera pos dopo una mancata corrispondenza quando si usa /g Se 'pattern' è una stringa vuota, viene usata l'ultima regex I<che ha trovato corrispondenza>. Per questo operatore e i successivi si possono usare delimitatori diversi da '/'. qr/pattern/imsox registra una regex in una variabile. Modificatori come per m// sono registrati insieme alla regex. s/pattern/testo sostituito/igmsoxe sostituisce corrispondenze di 'pattern' con 'testo sostituito'. Modificatori come per m// con un'aggiunta: e valuta "testo sostituito" come un'espressione Perl 'e' può essere specificata più volte. "testo sostituito" viene interpretato come una stringa tra virgolette doppie a meno che vengano usate virgolette semplici (') come delimitatore. ?pattern? è come m/pattern/ ma trova la corrispondenza una sola volta. Non si possono usare delimitatori alternativi. Deve essere azzerata con la funzione L<reset|perlfunc/reset>.
\ Tratta come normale (escaped) il carattere seguente . Indica in un singolo carattere tranne newline (se non viene usato /s) ^ Indica l'inizio della stringa (o della riga, se viene usato /m) $ Indica la fine della stringa (o riga, se viene usato /m) * 0 o più occorrenze dell'elemento che precede + 1 o più occorrenze dell'elemento che precede ? rende opzionale l'elemento che precede (0 o una occorrenza) {...} Specifica una gamma di occorrenze dell'elemento che precede [...] Trova corrispondenza in uno dei caratteri fra parentesi quadre (...) Raggruppa espressioni per catturare in $1, $2 ... (?:...) Raggruppa espressioni senza catturare (cluster) | Trova l'espressione che precede o quella che segue (alternanza) \1, \2 ... Il testo dell'ennesimo gruppo catturato
Queste sequenze funzionano anche in stringhe normali.
\a Beep \e Escape \f Formfeed \n Newline \r Carriage return \t Tab \037 Valore ASCII ottale \x7f Valore ASCII esadecimale \x{263a} valore esadecimale (oltre 1 byte) \cx Control-x \N{name} Un carattere con nome \l Trasforma in minuscolo il carattere seguente \u Trasforma in maiuscolo (Titlecase) il carattere seguente \L Trasforma in minuscolo fino a \E \U Trasforma in maiuscolo fino a \E \Q Disabilita i caratteri speciali (metacaratteri) fino a \E \E Fine della modifica apportata da \L, \U, \Q.
Per Titlecase, si veda la sezione Titlecase
Questa sequenza è diversa dalle stringhe normali:
\b Un delimitatore di parola, non un backspace, tranne quando è dentro una classe di caratteri.
[amy] Trova 'a', 'm' o 'y' [f-j] Il trattino identifica una sequenza (da 'f' a 'j') [f-j-] Il trattino con escape o messo all'inizio o alla fine identifica se stesso. [^f-j] Il segno di omissione (^) indica "trova qualsiasi carattere ECCETTO questi"
Le sequenze che seguono funzionano sia dentro che fuori da una classe di caratteri. Le prime sei si uniformano alle impostazioni locali. Tutte le sequenze supportano Unicode. Sono indicate le classi di caratteri di default. vedete perllocale e perlunicode per maggiori dettagli.
\d Un numero [0-9] \D Un non-numero (inverso di \d) [^0-9] \w Un carattere di una parola [a-zA-Z0-9_] \W L'inverso di \w [^a-zA-Z0-9_] \s Un carattere spazio [ \t\n\r\f] \S L'inverso di \s [^ \t\n\r\f] \C Trova un byte (conUnicode, '.' trova un carattere) \pP Trova una proprietà Unicode con nome \p{...} Trova una proprietà Unicode con nome lungo \PP Trova una non-proprietà Unicode \P{...} Trova un'entità senza nome lungo Unicode \X Trova una sequenza estesa di Unicode
Classi di caratteri POSIX e i loro equivalenti Unicode e Perl:
alnum IsAlnum Alfa-numerico alpha IsAlpha Alfabetico ascii IsASCII Un carattere ASCII blank IsSpace [ \t] Uno spazio orizzontale (estensione GNU) cntrl IsCntrl Un carattere di controllo digit IsDigit \d Numero graph IsGraph Alfa-numerico e punteggiatura lower IsLower carattere minuscolo (anche secondo impostazioni locali e unicode) print IsPrint Alfa-numerico, punteggiatura e spazi punct IsPunct Punteggiatura space IsSpace [\s\ck] Spazio IsSpacePerl \s Definizione di spazio di Perl upper IsUpper carattere minuscolo (anche secondo impostazioni locali e unicode) word IsWord \w Alfa-numerico più _ (estensione Perl) xdigit IsXDigit [0-9A-Fa-f] Numero esadecimale
All'interno di una classe di caratteri:
POSIX tradizionale Unicode [:digit:] \d \p{IsDigit} [:^digit:] \D \P{IsDigit}
Sono tutte asserzioni di lunghezza zero.
^ Trova corrispondenza all'inizio della stringa (o riga, se viene usato /m) $ Trova corrispondenza alla fine della stringa (o riga, se viene usato /m) o prima di un newline \b Trova corrispondenza al confine di una parola (fra \w e \W) \B Trova corrispondenza dove non c'è un \b (fra \w e \w o fra \W e \W) \A Trova corrispondenza all'inizio della stringa (senza considerare /m) \Z Trova corrispondenza alla fine della stringa (o prima di un newline) \z Trova corrispondenza alla fine della stringa (in maniera assoluta) \G Troca corrispondenza dove il precedente m//g ha finito
I quantificatori sono avidi (greedy) per dafult -- trovano il testo più lungo e più a sinistra.
Massimo Minimo Gamma di applicazione ------- ------- --------------------- {n,m} {n,m}? Almeno n volte e non più di m volte {n,} {n,}? Almeno n volte {n} {n}? Esattamente n volte * *? 0 o più volte (come {0,}) + +? 1 o più volte (come {1,}) ? ?? 0 o 1 volte (come {0,1})
Non esiste un quantificatore {,n} -- viene interpretato come una stringa letterale
(?#text) Un commento (?imxs-imsx:...) Abilita/disabilita opzioni (come i modificatori dopo m//) (?=...) Asserzione positiva in avanti di lunghezza zero (?!...) Asserzione negativa in avanti di lunghezza zero (?<=...) Asserzione negativa indietro di lunghezza zero (?<!...) Asserzione negativa indietro di lunghezza zero (?>...) Trova corrispondenza in tutto quello che può proibendo il backtracking (?{ code }) Codice Perl incluso. Il valore restituito diventa $^R (??{ code }) Regex dinamica. Il valore restituito viene usato come regex (?(cond)sì|no) in cui "cond" è un intero corrispondente a una parentesi che ha catturato (?(cond)yes) o a un'asserzione di lunghezza zero (avanti o indietro)
$_ Varibile di default su cui agiscono gli operatori $* Abilita ricerche su righe multiple (deprecato: not sarà più supportato a partire dalla 5.9.0) $& L'intero testo trovato $` Tutto quel che precede il testo trovato $' Tutto quel che segue il testo trovato
L'uso di queste ultime tre variabili rallenta tutte le regex usate nel vostro programma. Consultate perlvar, cercando @LAST_MATCH_START per vedere un'espressione equivalente che non rallenta l'esecuzione. Vedete anche Devel::SawAmpersand.
@LAST_MATCH_START
$1, $2 ... contiene il primo, secondo, ennesimo testo catturato $+ L'ultimo testo catturato $^N Contiene il testo del testo catturato più di recente $^R Contiene il risultato dell'ultima espressione (?{...}) @- posizione dell'inizio dei gruppi catturati $-[0] contiene la posizione iniziale dell'intera espressione trovata. @+ posizione della fine dei gruppi catturati. $+[0] contiene la posizione finale dell'intera espressione trovata.
I gruppi catturati sono numerati secondo la loro rispettiva parentesi aperta.
lc trasforma una stringa in minuscolo lcfirst trasforma in minuscolo il primo carattere di una stringa uc trasforma una stringa in maiuscolo ucfirst trasforma in maiuscolo (Titlecase) il primo carattere della stringa pos restituisce o imposta la posizione della corrispondenza attuale. quotemeta mette un escape ai caratteri speciali (metacaratteri) reset azzera lo stato di ?pattern? study analizza una stringa per ottimizzare la ricerca. split Usa una regex per scomporre una stringa in più parti.
Le prime quattro funzioni equivalgono alle sequenze di escape \L, \l, \U, e \u. Per Titlecase, vedete "Titlecase".
\L
\l
\U
\u
Si tratta di un concetto di Unicode che è quasi sempre uguale a un carattere maiuscolo, ma per certi caratteri come "scharfes s" (ß) in tedesco c'è una differenza.
Iain Truskett.
Questo documento può essere distribuito secondo gli stessi termini del Perl. Questo documento è a cura del progetto pod2it ( http://pod2it.sourceforge.net ). Traduzione di Giuseppe Maxia
perlretut Un tutorial sulle espressioni regolari
perlrequick Un tutorial molto rapido.
perlre Tutti i dettagli.
perlvar Dettagli sulle variabili
perlop Dettagli sugli operatori.
perlfunc Dettagli sulle funzioni.
perlfaq6 FAQ sulle espressioni regolari.
il modulo re per alterare il comportamento delle regex e facilitare il debugging.
"Debugging regular expressions" in perldebug
perluniintro, perlunicode, charnames e locale Dettagli sulle regex, impostazioni locali e internazionalizzazione.
Mastering Regular Expressions (2nd edition) di Jeffrey Friedl (http://regex.info/) Riferimenti completi e dettagliati sull'argomento.
David P.C. Wollmann, Richard Soderberg, Sean M. Burke, Tom Christiansen, Jim Cromie, e Jeffrey Goff per preziosi consigli.
1 POD Error
The following errors were encountered while parsing the POD:
Non-ASCII character seen before =encoding in 'perché'. Assuming UTF-8
To install POD2::IT, copy and paste the appropriate command in to your terminal.
cpanm
cpanm POD2::IT
CPAN shell
perl -MCPAN -e shell install POD2::IT
For more information on module installation, please visit the detailed CPAN module installation guide.