Enrico Sorcinelli > POD2-IT > IT/perlreref.pod

Download:
POD2-IT-0.13.tar.gz

Annotate this POD

CPAN RT

New  1
Open  0
View/Report Bugs
Source  

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

DESCRIZIONE ^

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

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

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

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 \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" (ß) in tedesco c'è una differenza.

AUTORE ^

Iain Truskett.

Questo documento può essere distribuito secondo gli stessi termini del Perl.

SI VEDA ANCHE ^

RINGRAZIAMENTI ^

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

TRADUZIONE ^

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

Traduttore

Traduzione a cura di Giuseppe Maxia.

Revisore

Revisione a cura di dree.

syntax highlighting: