Perl/Espressioni regolari (oltre)

Wikibooks, manuali e libri di testo liberi.
Jump to navigation Jump to search

Le espressioni regolari hanno un livello di astrazione in più consentendo di concentrarsi su contenuti "generici" e non solo su quelli noti a priori.

Prima , Match , Dopo[modifica]

Quando chiediamo di fare un'operazione di match, il Perl mette a disposizione tre variabili che consentono di capire meglio "cosa" si è catturato: $` contiene quello che c'è prima $& contiene il match $' contiene quello che c'è dopo

riprendendo l'esempio relativo alla parola "vita" vediamo cosa succede in questo caso:


foreach $stringa (   "che vita... stare in pace con il mondo" 
                   , "mi sembra che sia vitale respirare" 
                   , "sono contento della mia vita!" 
                   , "ma ti sembra vita??"
                   , "non so se la mia vita mi piace molto" ) 
{                                                                               
    if ( $stringa =~ m/\s+vita[\s.?!]+/ )                                          
    {                                                                           
        print "$stringa fa match!\n";                                           
        print "prima :$`\n";                                           
        print "match :$&\n";                                           
        print "dopo  :$'\n";                                           
        print "---\n";                                           
    }                                                                           
}                                                                               

che produce:

che vita... stare in pace con il mondo fa match! 
prima :che:                                     
match : vita... :                                 
dopo  :stare in pace con il mondo:               
---
sono contento della mia vita! fa match!          
prima :sono contento della mia :                 
match : vita!:                                    
dopo  ::                                         
---
ma ti sembra vita?? fa match!                    
prima :ma ti sembra :                            
match : vita??:                                   
dopo  ::                                         
---
non so se la mia vita mi piace molto fa match!   
prima :non so se la mia:                        
match : vita :                                    
dopo  :mi piace molto:                           
---

Raggruppare[modifica]

Oltre alle variabili precedenti le espressioni regolari consentono di fare dei raggruppamenti: considerare un certo "gruppo di sintassi" come un unico elemento. La sintassi per specificare questa possibilità è mettere la sintassi fra '(' e ')'. Vediamo allora come migliorare l'esempio precedente aggiungendo il caso di estrarre anche " vitavita " , " vitavita!! " e " vitavita? ". L'espressione regolare in questo caso diventa : "\s+(vita)+[\s.!?]+" ciò che si trova fra parentesi viene trattato dal moltiplicatore come se fosse un'unica entità.

foreach $stringa (   "che vita... stare in pace con il mondo"     
                   , "mi sembra che sia vitale respirare"         
                   , "sono contento della mia vita!"              
                   , "ma ti sembra vita??"                        
                   , "non so se la mia vita mi piace molto"      
                   , "non so se la mia vitavita mi piace molto"  
                   , "non so se vitavitavita sia corretta" )      
{                                                                 
    if ( $stringa =~ m/\s+(vita)+[\s.!?]+/ )                      
    {                                                             
        print "$stringa fa match!\n";                             
        print "prima :$`:\n";                                     
        print "match :$&:\n";                                     
        print "dopo  :$':\n";                                     
    }                                                             
}                                                                 

che produce:

che vita... stare in pace con il mondo fa match!   
prima :che:                                        
match : vita... :                                  
dopo  :stare in pace con il mondo:                 
sono contento della mia vita! fa match!            
prima :sono contento della mia:                    
match : vita!:                                     
dopo  ::                                           
ma ti sembra vita?? fa match!                      
prima :ma ti sembra:                               
match : vita??:                                    
dopo  ::                                           
non so se la mia vita mi piace molto fa match!     
prima :non so se la mia:                           
match : vita :                                     
dopo  :mi piace molto:                             
non so se la mia vitavita mi piace molto fa match! 
prima :non so se la mia:                           
match : vitavita :                                 
dopo  :mi piace molto:                             
non so se vitavitavita sia corretta fa match!      
prima :non so se:                                  
match : vitavitavita :                             
dopo  :sia corretta:                               

Raggruppare ed usare ciò che si è raggruppato[modifica]

Se non indicato esplicitamente il Perl mette da qualche parte in memoria i vari raggruppamenti. Questi possono essere usati nella stessa espressione regolare oppure "subito" dopo l'azione di match. Ogni elemento raggruppato viene numerato a partire da 1. Se si usano nell'espressione regolare occorre indicarli come \X dove X è una cifra. Se si usano fuori dall'espressione regolare allora vengono memorizzati in $X dove X è una cifra. Vediamo un esempio: voglio sapere se la parola "stringa" è presente due volte all'interno della frase. L'espressione regolare potrebbe essere la seguente: "(stringa).*\1"

$stringa = "questa è la stringa di test e rimane una stringa !";
if ( $stringa =~ /(stringa).*\1/ )
{
     print " mi interessa $1 \n";
}

che produce:

 mi interessa stringa

Vediamo ora un caso più complesso : voglio sapere se una parola di almeno 5 caratteri è ripetuta in una frase e quale è (per ora ci si ferma alla prima che si incontra). L'espressione regolare potrebbe essere la seguente:"(\w{5,}).*\1"

# commentate una stringa e provate !
$stringa = "questa è la stringa di test e rimane una stringa !";
$stringa = "questa \350 la stringa di test e rimane una stringa questa !";
                                                                          
if ( $stringa =~ /(\w{5,}).*\1/ )                                         
{                                                                         
     print "ho trovato:$1: \n";                                         
}                                                                         

che produce:

ho trovato:questa:

Raggruppare ma NON usare ciò che si è raggruppato[modifica]

Per non usare il raggruppamento (libera memoria e semplifica la ricerca) è sufficiente usare la sintassi : "(?:" e ")". Cioè basta aggiungere subito dopo la parentesi "(" un "?:".

$stringa = "io contengo una parola di soli quattro caratteri";
if ( $stringa =~ m/\s(?:\w{4,4})\s/ )
{
    print "la stringa -$stringa- contiene una parola di 4 caratteri!\n";
    print "parola è $&\n";
}

L'uso del raggruppamento senza memorizzare non modifica le altre caratteristiche del raggruppamento. Per esempio voglio parole di 4 o 8 o 12 ... etc


$stringa = "io contengo una parola di soli quattro caratteri";
if ( $stringa =~ m/\s(?:\w{4,4})+\s/ )
{
    print "la stringa -$stringa- contiene una parola multipla di 4 caratteri!\n";
    print "parola è $&\n";
}

che produce:

la stringa -io contengo una parola di soli quattro caratteri- contiene una parola multipla di 4 caratteri!                                                                                           
parola è  contengo                                                                                  

Posizionamento della ricerca[modifica]

Se si vuole cercare qualcosa che si trova all'inizio della stringa occorre mettere come primo carattere il carattere ^. Se si vuole cercare qualcosa che si trova alla fine della stringa occorre mettere come ultimo carattere il carattere $. Se volessi cercare la parola vita all'inizio della stringa (ma non in mezzo!) l'espressione regolare potrebbe essere: "^vita" Vediamo un esempio:

foreach $stringa (   "che vita... stare in pace con il mondo"     
                   , "mi sembra che sia vitale respirare"         
                   , "sono contento della mia vita!"              
                   , "vita : ma ti sembra vita??"                        
                   , "non so se la mia vita mi piace molto"      
                   , "non so se la mia vitavita mi piace molto"  
                   , "non so se vitavitavita sia corretta" )      
{                                                                 
    if ( $stringa =~ m/^vita/ )                      
    {                                                             
        print "$stringa fa match!\n";                             
        print "prima :$`:\n";                                     
        print "match :$&:\n";                                     
        print "dopo  :$':\n";                                     
    }                                                             
}                                                                 

che produce:

vita : ma ti sembra vita?? fa match!
prima ::                            
match :vita:                        
dopo  : : ma ti sembra vita??:      

Se volessi cercare la parola vita alla fine della stringa (ma non in mezzo!) l'espressione regolare potrebbe essere : "vita[?!.]*$" NOTA:si è messa la punteggiatura finale che può non esserci, esserci , ed essere ripetuta !

foreach $stringa (   "che vita... stare in pace con il mondo"     
                   , "mi sembra che sia vitale respirare"         
                   , "sono contento della mia vita!"              
                   , "vita : ma ti sembra vita??"                        
                   , "non so se la mia vita mi piace molto"      
                   , "non so se la mia vitavita mi piace molto"  
                   , "non so se vitavitavita sia corretta" )      
{                                                                 
    if ( $stringa =~ m/vita[?!.]*$/ )                      
    {
        print "---\n";                                                             
        print "$stringa fa match!\n";                             
        print "prima :$`:\n";                                     
        print "match :$&:\n";                                     
        print "dopo  :$':\n";                                     
    }                                                             
}                                                                 

che produce:

---
sono contento della mia vita! fa match!
prima :sono contento della mia :       
match :vita!:                          
dopo  ::                               
---
vita : ma ti sembra vita?? fa match!   
prima :vita : ma ti sembra :           
match :vita??:                         
dopo  ::                               

Separatore di parola[modifica]

In questa sezione si parla del separatore di parola. Con questo termine si indica il punto di inizio/fine di una parola. Negli esempi precedenti si è utilizzato lo spazio come elemento che separa una parola dalla successiva. Esiste un marcatore "più" preciso : \b indica la sequenza \W\w o \w\W e si posiziona "nel mezzo". \B è tutto quello che non è il \b

Occorre però capirne bene la sua utilità. Con il separatore la parola viene già considerata e separata ( caso di /b ) o considerata e non separata ( caso /B ) dal resto delle parole. Infatti prendendo il punto in cui si verifica \w\W o \W\w la si è già considerata come estranea ed appartenente ad una certa sequenza. Vediamo se con un esempio si chiarisce questo: applichiamolo alla ricerca della parola "vita" nell'esempio precedente:

foreach $stringa (   "che vita... stare in pace con il mondo"   
                   , "mi sembra che sia vitale respirare"       
                   , "sono contento della mia vita!"            
                   , "ma ti sembra vita??"                      
                   , "non so se la mia vita mi piace molto"     
                   , "non so se la mia vitavita mi piace molto" 
                   , "non so se vitavitavita sia corretta" )    
{                                                               
    if ( $stringa =~ m/\b(vita)+\b/ )                           
    {                                                           
        print "---\n";                                          
        print "$stringa fa match!\n";                           
        print "prima :$`:\n";                                   
        print "match :$&:\n";                                   
        print "dopo  :$':\n";                                   
    }                                                           
}                                                               
        

che produce:

---                                               
che vita... stare in pace con il mondo fa match!  
prima :che :                                      
match :vita:                                      
dopo  :... stare in pace con il mondo:            
---                                               
sono contento della mia vita! fa match!           
prima :sono contento della mia :                  
match :vita:                                      
dopo  :!:                                         
---                                               
ma ti sembra vita?? fa match!                     
prima :ma ti sembra :                             
match :vita:                                      
dopo  :??:                                        
---                                               
non so se la mia vita mi piace molto fa match!    
prima :non so se la mia :                         
match :vita:                                      
dopo  : mi piace molto:                           
---                                               
non so se la mia vitavita mi piace molto fa match!
prima :non so se la mia :                         
match :vitavita:                                  
dopo  : mi piace molto:                           
---                                                
non so se vitavitavita sia corretta fa match!      
prima :non so se :                                 
match :vitavitavita:                               
dopo  : sia corretta:                                                           

NOTA: Avete notato che ora "vita" viene identificata senza spazi? (confrontate l'inizio e la fine del carattere ":" in prima , match , dopo )

Guardare avanti[modifica]

In inglese "lookahead" significa che durante la verifica dell'espressione regolare ne viene verificata la contemporaneità di un'altra (positivo) oppure la non contemporaneità di un'altra (negativo). La sintassi è la seguente : (?= ) per la positiva; (?! ) per la negativa. Come per (?: ) non viene memorizzata in uno spazio in memoria, ma fa parte del match. Vediamo questo esempio :

foreach $stringa (   "che vita... stare in pace con il mondo"   
                   , "mi sembra che sia vitale respirare"       
                   , "sono contento della mia vita!"            
                   , "ma ti sembra vita??"                      
                   , "non so se la mia vita mi piace molto"     
                   , "non so se la mia vitavita mi piace molto" 
                   , "non so se vitavitavita sia corretta" )    
{                                                               
    if ( $stringa =~ m/(vita)+(?=[!?.])/ )                           
    {                                                           
        print "---\n";                                          
        print "$stringa fa match!\n";                           
        print "prima :$`:\n";                                   
        print "match :$&:\n";                                   
        print "dopo  :$':\n";                                   
    }                                                           
}                                                               

che produce :

---                                             
che vita... stare in pace con il mondo fa match!
prima :che :                                    
match :vita:                                    
dopo  :... stare in pace con il mondo:          
---                                             
sono contento della mia vita! fa match!         
prima :sono contento della mia :                
match :vita:                                    
dopo  :!:                                       
---                                             
ma ti sembra vita?? fa match!                   
prima :ma ti sembra :                           
match :vita:                                    
dopo  :??:

Cioè solo tutte quelle righe che che hanno un carattere .,!,? dopo la sequenza v-i-t-a.

Alternativa[modifica]

Si è visto nel caso dei caratteri che era possibile specificare dei caratteri diversi mettendoli fra []. Nel caso di espressioni complesse invece viene incontro il simbolo |. Attenzione che questo NON si riferisce al singolo carattere ma al raggruppamento nel quale è usato. Se per esempio voglio tutte le frasi con la parola vita o morte posso usare la seguente espressione regolare: "vita|morte"

foreach $stringa (   "che vita... stare in pace con il mondo"   
                   , "purché non sia un portatore di morte"
                   , "mi sembra che sia vitale respirare" )    
{                                                               
    if ( $stringa =~ m/\bvita\b|\bmorte\b/ )                           
    {                                                           
        print "---\n";                                          
        print "$stringa fa match!\n";                           
        print "prima :$`:\n";                                   
        print "match :$&:\n";                                   
        print "dopo  :$':\n";                                   
    }                                                           
}                                                               

che produce :

---                                             
che vita... stare in pace con il mondo fa match!
prima :che :                                    
match :vita:                                    
dopo  :... stare in pace con il mondo:          
---                                             
purché non sia un portatore di morte fa match!  
prima :purché non sia un portatore di :         
match :morte:                                   
dopo  ::                                        

vediamo un altro esempio : occorre che la parola vita sia all'inizio e la parola morte sia in fondo e viceversa

foreach $stringa (   "vita precede la morte"   
                   , "morte segue la vita"
                   , "morte non segue ne precede morte"     
                   , "vita genera vita" )    
{                                                               
    if ( $stringa =~ m/^vita.*morte$|^morte.*vita$/ )                           
    {                                                           
        print "---\n";                                          
        print "$stringa fa match!\n";                           
        print "prima :$`:\n";                                   
        print "match :$&:\n";                                   
        print "dopo  :$':\n";                                   
    }                                                           
}                                                               

che produce :

---                            
vita precede la morte fa match!
prima ::                       
match :vita precede la morte:  
dopo  ::                       
---                            
morte segue la vita fa match!  
prima ::                       
match :morte segue la vita:    
dopo  ::                        

Sii minimale[modifica]

Quando si usano i moltiplicatori di caratteri, il Perl cerca la stringa che maggiormente di adatta alla sequenza cercata. A volte questo comportamento non è esattamente quello desiderato. Per dare istruzioni di come cercare si usa la sintassi "?" posta dopo il ripetitore. Vediamone la sintassi: {min,max}? inizia dal numero minimo e poi incrementa fino al massimo {min,}? inizia dal numero minimo e poi incrementa {max}? prova max (non cambia!)

  • ? inizia da 0 e poi incrementa

+? inizia da 1 e poi incrementa ?? inizia da 0 e poi incrementa

Vediamo un esempio : data una stringa contenente 'elemento="xxxx"', ripetuto più volte , estrarre i valori fra " e ". Di primo impulso verrebbe l'espressione regolare : "elemento=["].*["]" tuttavia dato che .* inizia dalla maggior numero e poi decrementa , mangia anche i caratteri che seguono, che diventano inutili. Allora si utilizza il modo minimale che consente di dare visibilità anche ai caratteri che seguono. Quindi si potrebbe utilizzare l'espressione regolare : "elemento=["].*?["]"

$stringa = 'elemento="questo è il primo elemento",elemento="questo è il secondo elemento"';
if ( $stringa =~ m/elemento=["].*?["]/ )                                                         
{                                                                                                
    print "---\n";                                                                               
    print "fa match!\n";                                                                         
    print ":$&:\n";                                                                              
}                                                                                                

che produce :

--- fa match!

elemento="questo è il primo elemento":

Al lettore che non gli è chiaro : provi a togliere il ? e a capire cosa accade !

gli scalari come espressioni regolari[modifica]

È possibile scrivere una espressione regolare in una variabile e poi sostituirla nel match oppure mettere una variabile nell'espressione regolare. Vediamo come modificare l'esempio precedente che cerca la stessa parola nella stringa:

$stringa = "questa è la stringa di test e rimane una stringa questa !";

foreach $prova ( '\w{5,}' , 'stringa' , 'questa' )
{ 
    if ( $stringa =~ /($prova).*\1/ )
    {
         print "parola doppia: $1 \n";
    }
    else
    {
         print "non trovata $prova ! \n";
    }
}

che produce :

parola doppia :questa 
parola doppia :stringa
parola doppia :questa 


se si ha l'intenzione di sostituire per intero l'espressione regolare dato che in assegnamento di variabile i caratteri speciali vengono interpretati occorre scriverli con l'apice singolo o con il "marcatore" qr che è quello dedicato. Vediamo l'esempio precedente:

$stringa = "questa \350 la stringa di test e rimane una stringa questa !"; 
                                                                           
$p1 = "stringa";                                                           
                                                                           
foreach $prova ( qr(\w{5,}) , qr($p1) , qr(questa) )                       
{                                                                          
    if ( $stringa =~ /($prova).*\1/ )                                      
    {                                                                      
         print "parola doppia: $1 \n";                                     
    }                                                                      
    else                                                                   
    {                                                                      
         print "non trovata $prova ! \n";                                  
    }                                                                      
}                                                                          

commenti (in linea)[modifica]

Dato che le espressioni regolari possono essere molto complicate, segnarsi degli appunti, per quando eventualmente dovranno essere modificate, potrebbe tornare utile. Per poter far questo basta usare la sintassi (?# ... ). Per esempio : (?# ATTENZIONE: questo è un commento per i posteri !)


Scorciatoie (lettera in fondo)[modifica]

Spesso complicati concetti possono esprimersi con una lettera in una posizione particolare. Vediamo aggiungendo una (o più) lettera in fondo alla sintassi /<espressione regolare>/ che possibilità offrono in più le espressioni regolari.

Sia minuscolo , sia maiuscolo[modifica]

Con la lettera "i" si intendono per tutta l'espressione regolare sia lettere maiuscole che minuscole. Per esempio : voglio sapere se hai digitato "si" maiuscolo o minuscolo. L'espressione regolare potrebbe essere : /si/i

foreach $s ( "Si" , "SI" , "sI" , "si" , "No" )
{
    if ( $s =~ m/si/i )
    {
        print "$s fa match con /si/i\n";
    }
    else
    {
        print "$s NON fa match con /si/i\n";
    }
} 

che produce:

Si fa match con /si/i    
SI fa match con /si/i    
sI fa match con /si/i    
si fa match con /si/i    
No NON fa match con /si/i

Commenti (su più linee)[modifica]

Con la lettera "x" si possono mettere le espressioni regolari su più linee mettendo il commento "perl" in modo tradizionale con il simbolo # . Vediamo questo esempio:

foreach $s ( "Si" , "SI" , "sI" , "si" , "No" , "ni" )
{                                                     
    if ( $s =~ m/                                     
                  si    |#accetta Si                  
                  ni    #accetta Ni                   
                /ix )                                 
    {                                                 
        print "$s fa match \n";              
    }                                                 
    else                                              
    {                                                 
        print "$s NON fa match \n";          
    }                                                 
}                                                     

NOTA: Gli spazi sono IGNORATI pertanto occorrerà renderli esplici usando \s o [ ].

che produce :

Si fa match     
SI fa match     
sI fa match     
si fa match     
No NON fa match 
ni fa match