fatte le regex

git-svn-id: svn://luxion/repos/intro-perl@356 fcb26f47-9200-0410-b104-b98ab5b095f3

1 files changed, 212 insertions, 3 deletions

diff --git a/corso.content.tex b/corso.content.tex
index eda1412..1ea0e3b 100644
--- a/corso.content.tex
+++ b/corso.content.tex
@@ -1230,14 +1230,223 @@ scrivere \lstinline!<STDIN>!
 
 \section{Espressioni regolari}
 
-\subsection{Cosa sono}
+\begin{frame}\frametitle{Cos'è un'espressione regolare?}
+\begin{itemize}
+\item evitiamo i tecnicismi
+\item un'espressione regolare ({\em regex}) è un modo per descrivere
+una famiglia di stringhe
+\item si usano per verificare che una stringa appartenga a una certa
+famiglia
+\item ma anche per manipolare le stringhe
+\end{itemize}
+\end{frame}
 
 \subsection{Casi semplici} % literal, simple charclass, repetition
 
-\subsection{Operatori più complessi} % anchors, parens, complex charclass (\p)
+\begin{frame}[fragile]\frametitle{Caso base}
+\lstinline!gino! indica la famiglia di stringhe che contengono quei
+quattro caratteri, consecutivi, in quell'ordine, in qualche punto
+\end{frame}
+
+\begin{frame}[fragile]\frametitle{Classi di caratteri}
+\begin{itemize}
+\item \lstinline![cdgl]ino! indica la famiglia di stringhe che contengono 
+un carattere
+tra \lstinline!c!, \lstinline!d!, \lstinline!g!, \lstinline!l!,
+seguito da \lstinline!ino!
+\item \lstinline!numero: [0-9]! indica la famiglia di stringhe che contengono 
+\lstinline!numero: ! seguito da una cifra.
+\item \lstinline![^cdgl]ino! indica la famiglia di stringhe che
+contengono \lstinline!ino! preceduto da un carattere {\em non} tra
+quelli
+\end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]\frametitle{Carattere qualsiasi}
+\lstinline!a.b! indica la famiglia di stringhe che contengono 
+\lstinline!a!, seguito da un carattere qualsiasi, seguito da \lstinline!b!.
+\end{frame}
+
+\begin{frame}[fragile]\frametitle{Ripetizione}
+\begin{itemize}
+\item \lstinline!a+! indica la famiglia di stringhe che contengono 
+una sequenza di \lstinline!a!, lunga almeno 1 carattere.
+\item \lstinline!ab*c! indica la famiglia di stringhe che contengono 
+\lstinline!a!, seguito da una sequenza di \lstinline!b!, lunga anche
+0, seguita da \lstinline!c!.
+\item \lstinline!ab?c! indica la famiglia di stringhe che contengono 
+\lstinline!a!, opzionamlente seguito da \lstinline!b!, seguito da \lstinline!c!.
+\item Notare che \lstinline!a*! indica tutte le stringhe possibili (come
+anche \lstinline!a?!, o la regex vuota)
+\end{itemize}
+\end{frame}
+
+\subsection{Operatori più complessi} % anchors, parens
+
+\begin{frame}[fragile]\frametitle{Alternanze}
+\begin{itemize}
+\item \lstinline!a|b|c! indica la famiglia di stringhe che
+contengono \lstinline!a!, oppure \lstinline!b!, oppure \lstinline!c!
+\item \lstinline!cane|gatto|topo! indica la famiglia di stringhe che
+contengono \lstinline!cane!, oppure \lstinline!gatto!, oppure \lstinline!topo!
+\end{itemize}
+\end{frame}
+%$
+
+\begin{frame}[fragile]\frametitle{Ancoraggi}
+\begin{itemize}
+\item \lstinline!^a! indica la famiglia di stringhe che cominciano per \lstinline!a!
+\item \lstinline!a$! indica la famiglia di stringhe che terminano per
+\lstinline!a!
+\end{itemize}
+\end{frame}
+%$
+
+\begin{frame}[fragile]\frametitle{Parentesi}
+\begin{itemize}
+\item \lstinline!ab|c|de! indica la famiglia di stringhe che
+contengono \lstinline!ab!, oppure \lstinline!c!, oppure \lstinline!de!
+\item \lstinline!a(b|c|d)e! indica la famiglia di stringhe che
+contengono \lstinline!abe!, oppure \lstinline!ace!,
+oppure \lstinline!ade!
+\item oltre a cambiare la precendenza, le parentesi indicano anche di
+``segnarsi cosa è successo''
+\end{itemize}
+\end{frame}
 
 \subsection{Uso generale} % m, s, split, =~, options, tr
 
+\begin{frame}[fragile]{Esempio: contare le pecore}
+\begin{lstlisting}
+use strict; use warnings;
+my $pecore=0;
+while (my $linea=<>) {
+  if ($linea =~ m{pecora}) {
+    ++$pecore;
+  }
+}
+print "Ho visto $pecore pecore\n";
+\end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]{L'operatore \texttt{m//}}
+\lstinline!$linea =~ m{pecora}!
+
+\begin{itemize}
+\item \lstinline!=~! indica di applicare l'operatore a destra sulla
+stringa a sinistra
+\item \lstinline!m{}! sta per {\em match}: restituisce vero se e solo
+se la stringa appartiene alla famiglia descritta dalla regex
+\item come \lstinline!qw!, anche \lstinline!m! può usare i
+delimitatori che volete
+\item si può scrivere anche \lstinline!//!, usando le barre e senza la 'm'
+\end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]{Esempio: sommare i numeri}
+\begin{lstlisting}
+use strict; use warnings;
+my $totale=0;my $testo='';
+while (my $linea=<>) {
+  my ($prima,$numero,$dopo) =
+    $linea =~ m{^([^0-9]*)([0-9]+)(.*)$};
+  $totale += $numero;$testo.=$prima.$dopo;
+}
+print "Totale: $totale\n";
+print "Testo: $testo\n";
+\end{lstlisting}
+\end{frame}
+%$
+
+\begin{frame}[fragile]{L'operatore \texttt{m//} in contesto lista}
+\lstinline!my ($prima,$numero,$dopo) =!
+\lstinline!    $linea =~ m{^([^0-9]*)([0-9]+)(.*)$};!
+%$
+
+\begin{itemize}
+\item \lstinline!m//! in contesto lista restituisce le parti della
+stringa che corrispondono ai pezzi tra parentesi
+\item se la stringa non corrisponde, restituisce la lista vuota
+\item i pezzi sono anche disponibili nelle variabili speciali \lstinline!$1!,
+\lstinline!$2!, ecc.
+\end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]{Esempio: censurare gli indirizzi}
+\begin{lstlisting}
+use strict; use warnings;
+while (my $linea=<>) {
+  $linea =~ s{[a-z0-9.-]+\@[a-z0-9.-]+}
+             {***\@***};
+  print $linea;
+}
+\end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]{L'operatore \texttt{m//}}
+\begin{lstlisting}[escapeinside=«»,backgroundcolor=,numbers=none]
+$linea =~ s{[a-z0-9.-]+\@[a-z0-9.-]+}{***\@***};
+
+s/«{\em \sffamily regex}»/«{\em \sffamily stringa}»/
+\end{lstlisting}
+
+\begin{itemize}
+\item l'operatore \lstinline!s///! prende il primo pezzo della stringa che
+corrisponde alla regex, e lo sostituisce con la stringa suo parametro
+\item notare i delimitatori, e il fatto che sia la regex sia la
+stringa di sostituzione sono trattate come se avessero le virgolette doppie
+\end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]{Esempio: leggere un CSV}
+\begin{lstlisting}
+use strict; use warnings;
+while (my $linea=<>) {
+  chomp($linea);
+  my @campi = split /,/,$linea;
+  for my $campo (@campi) {
+    print "Campo: $campo\n"
+  }
+  print "-- fine record\n";
+}
+\end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]{L'operatore \texttt{m//}}
+\begin{lstlisting}[escapeinside=«»,backgroundcolor=,numbers=none]
+my @campi = split /,/,$linea;
+
+split /«{\em \sffamily regex}»/, «{\em \sffamily stringa}»
+\end{lstlisting}
+
+\begin{itemize}
+\item l'operatore \lstinline!split! spezza la stringa nei punti
+corrispondenti alla regex
+\item \lstinline!join !{\em \sffamily stringa}\lstinline!, !{\em \sffamily lista} fa l'operazione ``inversa'' (ma con i separatori tutti uguali)
+\end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]\frametitle{Opzioni per le regex}
+\begin{lstlisting}[escapeinside=«»,backgroundcolor=,numbers=none]
+m/«{\em \sffamily regex}»/smxi
+s/«{\em \sffamily regex}»/«{\em \sffamily stringa}»/smxig
+\end{lstlisting}
+
+\begin{itemize}
+\item \lstinline!/s! fa in modo che \lstinline!.! corrisponda anche al
+carattere di ``a capo''
+\item \lstinline!/m! fa in modo che \lstinline!^! e \lstinline!$!
+corrispondano all'inizo e alla fine di ciascuna riga (\lstinline!\A!
+e \lstinline!\z! corrispondono sempre a inizio e fine {\em
+stringa}) %$
+\item \lstinline!/x! ignora gli spazi nella regex, per aumentare la
+leggibilità (mettete una \lstinline!\! davanti agli spazi che devono
+esserci)
+\item \lstinline!/g! fa in modo che la sostituzione avvenga in tutti i
+punti che corrispondono alla regex, non solo il primo
+\end{itemize}
+\end{frame}
+
 \section{Controllo del flusso}
 
 \subsection{Controlli negati} % unless, until
@@ -1280,7 +1489,7 @@ scrivere \lstinline!<STDIN>!
 
 \section{Argomenti avanzati}
 
-\subsection{Variabile implicita} % $_
+\subsection{Variabile implicita} % $_, @_ e @ARGV
 
 \subsection{Manipolazione di stringhe} % substr, sprintf