/ 
POD2-IT-0.08
River stage zero No dependents
/ IT::perlreref

NOME

perlreref - Guida di riferimento rapida alle Espressioni regolari in Perl

Note del traduttore

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.

DESCRIZIONE

Questa è una guida di riferimento rapida alle espressioni regolari (regex) in Perl. Per maggiori informazioni vedete perlre e perlop, e la sezione "VEDI 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
   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>.

SYNTASSI

\       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

SEQUENZE DI ESCAPE

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.

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 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}

ANCORE

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

QUANTIFICATORI

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

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 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)

VARIABILI

$_    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.

$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.

FUNZIONI

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".

TERMINOLOGIA

Titlecase

Si tratta di un concetto di Unicode che è quasi sempre uguale a un carattere maiuscolo, ma per certi caratteri come "scharfes s" (&szlig;) in tedesco c'è una differenza.

AUTORE

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

VEDI ANCHE

RINGRAZIAMENTI

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:

Around line 7:

Non-ASCII character seen before =encoding in 'perché'. Assuming UTF-8