|
| index | project | pods | responsabili |
NOMEperlreref - Guida di riferimento rapida alle Espressioni regolari in Perl
Note del traduttoreLe 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 verbo ``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.
DESCRIZIONEQuesta è una guida di riferimento rapida alle espressioni regolari (regex) in Perl. Per maggiori informazioni vedete perlre e perlop, e la sezione SI VEDA ANCHE
OPERATORI
=~ 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
falso se c'e` 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 righe interne
s Cerca in una riga sinola. - . trova \n
o compila l'espressione solo una volta
x leggibilita` estesa. Spazi e commenti ammessi
c non azzera pos dopo una mancata corrispondenza quando si usa /g
Se 'pattern' e` 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' puo` essere specificata piu` volte. "testo sostituito"
viene interpretato come una stringa tra virgolette doppie
a meno che vengano usate virgolette semplici (') come
delimitatore.
?pattern? e` 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>.
SYNTASSI
\ Tratta come normale (escaped) il carattere seguente
. Indica 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 piu` occorrenze dell'elemento che precede
+ 1 o piu` 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
SEQUENZE DI ESCAPEQueste 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 E<egrave> diversa dalle stringhe normali: \b Un delimitatore di parola, non un backspace, tranne quando e` dentro una classe di caratteri.
CLASSI 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 proprieta` Unicode con nome
\p{...} Trova una proprieta` Unicode con nome lungo
\PP Trova una non-proprieta` Unicode
\P{...} Trova un'entita` 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 piu` _ (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}
ANCORESono 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'e` 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
QUANTIFICATORII 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 piu` di m volte
{n,} {n,}? Almeno n volte
{n} {n}? Esattamente n volte
* *? 0 o piu` volte (come {0,})
+ +? 1 o piu` volte (come {1,})
? ?? 0 o 1 volte (come {0,1})
Non esiste un quantificatore {,n} -- viene interpretato come una stringa letterale
COSTRUTTI ESTESI
(?#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 puo` proibendo il backtracking
(?{ code }) Codice Perl incluso. Il valore restituito diventa $^R
(??{ code }) Regex dinamica. Il valore restituito viene usato come regex
(?(cond)si`|no) in cui "cond" e` un intero corrispondente a una parentesi che ha catturato
(?(cond)si`) o a un'asserzione di lunghezza zero (avanti o indietro)
VARIABILI$_ Varibile di default su cui agiscono gli operatori $* Abilita ricerche su righe multiple (deprecato: not sara` piu` 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
$1, $2 ... contiene il primo, secondo, ennesimo testo catturato
$+ L'ultimo testo catturato
$^N Contiene il testo del testo catturato piu` 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.
FUNZIONIlc 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 piu` parti. Le prime quattro funzioni equivalgono alle sequenze di escape
TERMINOLOGIA
TitlecaseSi 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.
AUTOREIain Truskett. Questo documento può essere distribuito secondo gli stessi termini del Perl.
SI VEDA ANCHE
RINGRAZIAMENTIDavid P.C. Wollmann, Richard Soderberg, Sean M. Burke, Tom Christiansen, Jim Cromie, e Jeffrey Goff per preziosi consigli.
TRADUZIONE
VersioneLa versione su cui si basa questa traduzione è ottenibile con: perl -MPOD2::IT -e print_pod perlreref Per maggiori informazioni sul progetto di traduzione in italiano si veda http://pod2it.sourceforge.net/ .
TraduttoreTraduzione a cura di Giuseppe Maxia.
RevisoreRevisione a cura di dree. Mon Jun 11 22:02:18 2012 |