fatti gli hash

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

1 files changed, 177 insertions, 1 deletions

diff --git a/corso.content.tex b/corso.content.tex
index 623b4c2..297cf47 100644
--- a/corso.content.tex
+++ b/corso.content.tex
@@ -668,6 +668,16 @@ unshift @a,
 \end{frame}
 %$
 
+\begin{frame}[fragile]\frametitle{\texttt{reverse}}
+\begin{lstlisting}
+my @a=(1..10);
+my @b=reverse @a;
+print @b;
+\end{lstlisting}
+
+\visible<2->{\lstinline!10987654321!}
+\end{frame}
+
 \subsection{Interpolazione}
 
 \begin{frame}[fragile]\frametitle{Interpolazione}
@@ -794,12 +804,178 @@ chomp(@linee); # toglie tutti gli "a capo"
 
 \section{Hash}
 
-\subsection{Indici}
+\begin{frame}\frametitle{Cos'è un hash?}
+\begin{itemize}
+\item una mappa tra {\em stringhe} e valori {\em scalari}
+\item un po' come gli array, ma i singoli elementi sono indicati con una stringa (``chiave'') invece che con la loro posizione
+\item gli hash non sono ordinati
+\end{itemize}
+\end{frame}
+
+\subsection{Chiavi}
+
+\begin{frame}[fragile]\frametitle{Accesso ad elemento}
+\begin{itemize}
+\item \lstinline!$altezza{'dakkar'}=1.72!
+\item \lstinline!$altezza{$persona}=$altezza!
+\end{itemize}
+
+Il valore corrispondente a una chiave cui non è mai stato assegnato
+nulla è \lstinline!undef!.
+\end{frame}
+
+\begin{frame}[fragile]\frametitle{Sintassi abbreviata per le chiavi}
+\begin{itemize}
+\item \lstinline!$altezza{'dakkar'}! e \lstinline!$altezza{dakkar}! indicano lo stesso elemento
+\item se le cose tra \lstinline!{}! non sembrano essere un'espressione, sono trattate come una stringa
+\item usate le virgolette in caso di dubbio
+\end{itemize}
+\end{frame}
 
 \subsection{Valori}
 
+\begin{frame}[fragile]\frametitle{Variabili hash}
+\begin{itemize}
+\item \lstinline!%altezza! indica l'intero hash
+\item notare che \lstinline!$nome!, \lstinline!@nome! e \lstinline!%nome! sono variabili diverse %$
+\end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]\frametitle{Assegnamento a hash}
+\begin{lstlisting}
+my %traccia_in=('X','corso','Y','avanzati');
+
+print "$traccia_in{X}\n";
+\end{lstlisting}
+
+\visible<2->{\lstinline!corso!
+
+A un hash si assegna una lista chiave-valore. Notare che l'accesso a elemento di hash è interpolabile.}
+\end{frame}
+%$
+
+\begin{frame}[fragile]\frametitle{Assegnamento a hash (2)}
+\begin{lstlisting}
+my %traccia_in=('X','corso',
+                'Y','avanzati','Y','GUI');
+
+print "$traccia_in{Y}\n";
+\end{lstlisting}
+
+\visible<2->{\lstinline!GUI!
+
+Se una chiave appare più volte nella lista assegnata al hash, vale l'ultima.}
+\end{frame}
+%$
+
+\begin{frame}[fragile]\frametitle{Hash come lista}
+\begin{lstlisting}
+my %traccia_in=('X','corso','Y','avanzati');
+my @tracce=%traccia_in;
+
+print "@tracce\n";
+\end{lstlisting}
+
+\visible<2->{\lstinline!Y avanzati X corso!
+
+Notare che l'ordine è arbitrario: gli hash non sono ordinati.}
+\end{frame}
+
+\begin{frame}[fragile]\frametitle{Trasporre un hash}
+\begin{lstlisting}
+my %traccia_in=('X','corso','Y','avanzati');
+my %stanza_per=reverse %traccia_in;
+
+print "$stanza_per{avanzati}\n";
+\end{lstlisting}
+
+\visible<2->{\lstinline!Y!
+
+Con \lstinline!reverse! trasformiamo la lista chiave-valore in una lista valore-chiave, per cui trasponiamo l'hash.
+
+Se i valori in \lstinline!\%traccia_in! non fossero univoci, il valore di \lstinline!\%stanza_per! sarebbe mal definito.
+}
+\end{frame}
+%$
+
+
+\begin{frame}[fragile]\frametitle{Sintassi alternativa}
+\begin{lstlisting}
+my %traccia_in=( X => 'corso',
+                 Y => 'avanzati');
+\end{lstlisting}
+
+\begin{itemize}
+\item stesso valore di prima
+\item \lstinline!=>! è come una virgola
+\item ma quel che viene prima viene trattato come una stringa (a meno che non sembri un'espressione)
+\end{itemize}
+\end{frame}
+
 \subsection{Funzioni}
 
+\begin{frame}[fragile]\frametitle{\texttt{keys} e \texttt{values}}
+\begin{itemize}
+\item \lstinline!keys %a! restituisce la lista delle chiavi in \lstinline!%a!, {\em in un qualche ordine arbitrario}
+\item \lstinline!values %a! restituisce la lista dei valori in \lstinline!%a!, {\em nello stesso ordine di \lstinline!keys!}
+\item in contesto scalare, restituiscono il numero di chiavi (o valori, è lo stesso)
+\item per sapere se un hash è vuoto o meno, invece di controllare \lstinline!keys %a!, basta controllare \lstinline!%a!: un hash è vero se e solo se è non-vuoto
+\end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]\frametitle{\texttt{each}}
+\begin{lstlisting}
+my %hash=( a => 1, b => 2, c => 3 );
+while (my ($chiave,$valore) = each %hash) {
+  print "Alla chiave $chiave",
+        " corrisponde $valore\n";
+}
+\end{lstlisting}
+
+\lstinline!each! visita l'hash in ordine arbitrario, restituendo ad ogni invocazione una nuova coppia chiave-valore; restituisce lista vuota (quindi un valore falso) alla fine.
+\end{frame}
+
+\begin{frame}[fragile]\frametitle{\texttt{exists} e \texttt{defined}}
+\begin{itemize}
+\item \lstinline!exists $hash{chiave}! restituisce vero se l'hash
+contiene quella chiave (qualunque ne sia il valore)
+\item \lstinline!defined $hash{chiave}! restituisce vero se il valore
+corrispondente a quella chiave è definito (questo è il funzionamento
+normale di \lstinline!defined!)
+\end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]\frametitle{Nota su esistenza etc.}
+Notare la differenza:
+
+\begin{lstlisting}
+my %a=( vero => 1,
+        falso => 0,
+        non_definito => undef);
+\end{lstlisting}
+
+\begin{itemize}
+\item \lstinline!$a{vero}! è vero
+\item \lstinline!$a{falso}! è falso
+\item \lstinline!$a{non_definito}! è falso
+\item \lstinline!exists $a{non_definito}! è vero
+\item \lstinline!defined $a{falso}! è vero
+\item \lstinline!exists $a{non_ce}! è falso
+\end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]\frametitle{\texttt{delete}}
+\begin{lstlisting}
+my %hash=( a => 1, b => 2, c => 3 );
+delete $hash{a};
+if (!exists $hash{a}) {
+  print "ok\n";
+}
+\end{lstlisting}
+
+\lstinline!delete! elimina un elemento da un hash.
+\end{frame}
+
 \section{Subroutine}
 
 \subsection{Definizione}