=head1 NOME

perlreref - Guida di riferimento rapida alle Espressioni regolari in Perl

=head1 Note del traduttore

Le espressioni regolari sono difficili per un italiano sia perchE<eacute> 
trattano una materia poco nota alla maggiornanza dei programmatori,
sia perchE<eacute> introducono termini che non hanno corrispondente esatto 
in italiano.

Una menzione particolare merita il verbo "to match", che significa
"trovare una corrispondenza". E<Egrave> diverso dal semplice "trovare un testo",
e questo E<egrave> parte del mistero che circonda le espressioni regolari,
perchE<eacute> non (sempre) viene trovato un testo definito in mezzo a un testo
piE<ugrave> 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" E<egrave> uno schema composto da caratteri e/o simboli che ne
indicano la composizione. Per esempio: "casa" E<egrave> un pattern semplice
composto da 4 caratteri; "[Cc]asa" E<egrave> un pattern piE<ugrave> complesso che indica
un carattere a scelta fra 'c' e 'C', seguito da tre caratteri. "\b\w{4}\b"
E<egrave> 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
E<egrave> piE<ugrave> oscuro che lasciare l'originale, ed E<egrave> appunto quello che abbiamo
deciso di fare.

Un carattere di "escape" E<egrave> 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" E<egrave> 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.

=head1 DESCRIZIONE

Questa E<egrave> una guida di riferimento rapida alle espressioni 
regolari (regex) in Perl. Per maggiori informazioni vedete  
L<perlre> e L<perlop>, e la sezione L</"SI VEDA ANCHE">

=head2 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>.

=head2 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

=head2 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 L<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.

=head2 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 L<perllocale> e L<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}

=head2 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'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

=head2 QUANTIFICATORI

I quantificatori sono avidi (greedy) per dafult -- trovano il testo B<piE<ugrave> lungo> e piE<ugrave> 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

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

=head2 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 B<tutte> le
regex usate nel vostro programma. Consultate B<perlvar>, cercando 
C<@LAST_MATCH_START> per vedere un'espressione equivalente che
non rallenta l'esecuzione. Vedete anche L<Devel::SawAmpersand>.

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

=head2 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 piu` parti.

Le prime quattro funzioni equivalgono alle sequenze di escape C<\L>, C<\l>,
C<\U>, e C<\u>. Per Titlecase, vedete L</Titlecase>.

=head2 TERMINOLOGIA

=head3 Titlecase

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

=head1 AUTORE

Iain Truskett.

Questo documento puE<ograve> essere distribuito secondo gli stessi termini del Perl.

=head1 SI VEDA ANCHE

=over 4

=item *

L<perlretut> Un tutorial sulle espressioni regolari.

=item *

L<perlrequick> Un tutorial molto rapido.

=item *

L<perlre> Tutti i dettagli.

=item *

L<perlvar> Dettagli sulle variabili.

=item *

L<perlop> Dettagli sugli operatori.

=item *

L<perlfunc> Dettagli sulle funzioni.

=item *

L<perlfaq6> FAQ sulle espressioni regolari.

=item *

il modulo L<re> per alterare il comportamento delle regex e 
facilitare il debugging.

=item *

L<perldebug/"Debugging regular expressions"> ["Fare il debug di espressioni regolari", NdR]

=item *

L<perluniintro>, L<perlunicode>, L<charnames> e L<locale>
Dettagli sulle regex, impostazioni locali e internazionalizzazione.

=item *

I<Mastering Regular Expressions> (2nd edition) di Jeffrey Friedl
(F<http://regex.info/>) Riferimenti completi e dettagliati sull'argomento.

=back

=head1 RINGRAZIAMENTI

David P.C. Wollmann,
Richard Soderberg,
Sean M. Burke,
Tom Christiansen,
Jim Cromie,
e
Jeffrey Goff
per preziosi consigli.

=head1 TRADUZIONE

=head2 Versione

La 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
L<http://pod2it.sourceforge.net/> .

=head2 Traduttore

Traduzione a cura di Giuseppe Maxia.

=head2 Revisore

Revisione a cura di dree.

=cut
