From cdc16411ad7545c58045f15e701930157b049a24 Mon Sep 17 00:00:00 2001
From: dakkar <dakkar@luxion>
Date: Fri, 8 Aug 2008 12:05:55 +0000
Subject: array, manca il contesto

git-svn-id: svn://luxion/repos/intro-perl@351 fcb26f47-9200-0410-b104-b98ab5b095f3
---
 corso.content.tex | 301 +++++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 299 insertions(+), 2 deletions(-)

diff --git a/corso.content.tex b/corso.content.tex
index e42f822..0a71925 100644
--- a/corso.content.tex
+++ b/corso.content.tex
@@ -6,7 +6,7 @@
 \usepackage{listings}
 \usepackage{tikz}
 
-\lstset{numbers=left,numberstyle=\tiny ,numbersep=5pt,language=Perl,printpod=true,showspaces=false,frame=single,framerule=0pt,backgroundcolor=\color{black!20},basicstyle=\small\ttfamily}
+\lstset{extendedchars,numbers=left,numberstyle=\tiny ,numbersep=5pt,language=Perl,printpod=true,showspaces=false,frame=single,framerule=0pt,backgroundcolor=\color{black!20},basicstyle=\small\ttfamily}
 
 \mode<presentation>
 {
@@ -370,6 +370,8 @@ Stringhe tra virgolette doppie {\em interpolano} le variabili:
 \item \lstinline!$msg="Totale: \$quanti pezzi"! \visible<2->{$\rightarrow$ \lstinline!Totale: $quanti pezzi!}
 \item \lstinline!$misura=7.5;$etichetta="${misura}cm"! \visible<2->{$\rightarrow$ \lstinline!7.5cm!}
 \end{itemize}
+
+Usate le graffe intorno al nome per evitare che i caratteri che seguono vengano interpretati come parte del nome.
 \end{frame}
 
 \subsection{Input/Output} % print, <>, chomp
@@ -406,18 +408,311 @@ Adesso \lstinline!$riga! non contiene pi
 
 \subsection{\texttt{if} e \texttt{while}} % else, elsif
 
+\begin{frame}[fragile]\frametitle{Esecuzione condizionale}
+\begin{overprint}
+\onslide<1|handout:0>
+\begin{lstlisting}
+if ($totale > $SOGLIA_SPEDIZIONE_GRATIS) {
+   print "Spedizione: gratis\n"
+}
+\end{lstlisting}
+\onslide<2|handout:0>
+\begin{lstlisting}
+if ($totale > $SOGLIA_SPEDIZIONE_GRATIS) {
+   print "Spedizione: gratis\n"
+}
+else {
+   print "Spedizione: costa\n";
+}
+\end{lstlisting}
+\onslide<3|handout:1>
+\begin{lstlisting}
+if ($totale > $SOGLIA_SPEDIZIONE_GRATIS) {
+   print "Spedizione: gratis\n"
+}
+elsif ($totale < $SOGLIA_MINIMA_ORDINE) {
+   print "Compra di più!";
+}
+else {
+   print "Spedizione: costa\n";
+}
+\end{lstlisting}
+\end{overprint}
+\end{frame}
+
+\begin{frame}[fragile]\frametitle{Cicli condizionali}
+\begin{lstlisting}
+my $quanti=0;
+while ($quanti < 10) {
+  $quanti++;
+  print "Siamo a $quanti\n";
+}
+\end{lstlisting}
+\end{frame}
+
 \subsection{Valori particolari} % undef, true/false, defined
 
+\begin{frame}[fragile]\frametitle{\texttt{undef}}
+\begin{itemize}
+\item una variabile cui non è mai stato assegnato nulla ha valore \lstinline!undef!
+\item \lstinline!undef! ha valore numerico \lstinline!0! e valore stringa \lstinline!''! (stringa vuota)
+\item usare \lstinline!undef! in un'espressione genera un warning
+\end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]\frametitle{\texttt{defined}}
+\begin{lstlisting}
+my $a;
+# fai qualcosa...
+
+if (defined $a) { print "\$a non è definita\n" }
+else { print "\$a ha valore «$a»\n" }
+\end{lstlisting}
+\end{frame}
+%$
+
+\begin{frame}[fragile]\frametitle{Vero e falso}
+\begin{itemize}
+\item i seguenti valori sono considerati {\em falsi}:
+ \begin{itemize}
+ \item \lstinline!0! (il numero zero)
+ \item \lstinline!''! (la stringa vuota)
+ \item \lstinline!'0'! (la stringa che contiene il singlo carattere ``cifra zero'')
+ \item \lstinline!undef!
+ \end{itemize}
+\item tutti gli altri valori sono {\em veri}
+\end{itemize}
+\end{frame}
+
 \section{Liste e Array}
 
+\begin{frame}\frametitle{Cos'è un array?}
+\begin{itemize}
+\item una sequenza di valori {\em scalari}, indicati per posizione
+\item \Perl\ distingue tra {\em singolare} e {\em plurale}
+\item liste e array sono i plurali
+\end{itemize}
+\end{frame}
+
 \subsection{Indici}
 
+\begin{frame}[fragile]\frametitle{Indici normali}
+Gli indici in un array cominciano da 0:
+
+\begin{lstlisting}
+$persone[0]="Cino";
+$persone[1]="Dino";
+$persone[2]="Gino";
+$persone[3]="Lino";
+\end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]\frametitle{Uso}
+Potete usare un ``accesso ad elemento di array'' ovunque usereste uno scalare.
+
+\begin{lstlisting}
+print $persone[0],"\n";
+$totali[3]*=1.2;
+\end{lstlisting}
+
+Se usate un indice cui non avete mai assegnato nulla, il suo valore è \lstinline!undef!
+
+\visible<2->{\textbf{Nota:} gli array si ``allungano'' implicitamente}
+\end{frame}
+
+\begin{frame}[fragile]\frametitle{Espressioni come indici}
+L'indice può essere una qualsiasi espressione (purché abbia un valore
+numerico).
+
+\begin{lstlisting}
+print $persone[$indice];
+$totali[$numero_ordine 
+        + $mese * $ordini_mese]
+  = $totale_ordine;
+\end{lstlisting}
+\end{frame}
+%$
+
+\begin{frame}[fragile]\frametitle{Indici negativi}
+Se usate un numero negativo come indice, accedete ``dal fondo'':
+
+\begin{lstlisting}
+$persone[0]="Cino";$persone[1]="Dino";
+$persone[2]="Gino";$persone[3]="Lino";
+
+print $persone[-1]; # stampa Lino
+\end{lstlisting}
+
+Gli array non si allungano ``all'indietro'': \lstinline!$persone[-10]!
+genera un errore (ammesso che non ci siano 10 elementi)
+\end{frame}
+
+\begin{frame}[fragile]\frametitle{Ultimo indice}
+\lstinline!$#persone! è l'ultimo indice valido per le \texttt{persone}:
+
+\begin{lstlisting}
+$persone[0]="Cino";$persone[1]="Dino";
+$persone[2]="Gino";$persone[3]="Lino";
+
+print $persone[-1]; # stampa Lino
+print $persone[$#persone]; # stampa Lino
+\end{lstlisting}
+\end{frame}
+
 \subsection{Valori}
 
+\begin{frame}[fragile]\frametitle{Liste}
+\begin{itemize}
+\item \lstinline!(1, 2, 3)!
+\item \lstinline!(1, 2, 3, )!
+\item \lstinline!('a', 'b', 'c')!
+\item \lstinline!(1, 'a')!
+\item \lstinline!()!
+\item \lstinline!(1..100)!
+\end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]\frametitle{\texttt{qw}}
+\lstinline!qw! crea liste, da stringhe:
+\ \\
+
+\begin{overprint}
+\onslide<1|handout:0>
+\lstinline!qw(1 2 3)!\\
+\lstinline!qw(a b c)!
+\onslide<2|handout:0>
+\lstinline!qw{1 2 3}!\\
+\lstinline!qw{a b c}!
+\onslide<3|handout:0>
+\lstinline!qw/1 2 3/!\\
+\lstinline!qw"a b c"!
+\onslide<4|handout:1>
+\lstinline!qw(1 2 3)!\\
+\lstinline!qw{a b c}!\\
+\lstinline!qw/1 2 3/!\\
+\lstinline!qw"a b c"!
+
+\end{overprint}
+\ \\
+
+\visible<4->{Potete usare i delimitatori che volete. \lstinline!qw! {\em non interpola}, nemmeno se usate le virgolette doppie come delimitatore.}
+\end{frame}
+
+\subsection{Assegnamento}
+
+\begin{frame}[fragile]\frametitle{Assegnamento tra liste}
+\begin{itemize}
+\item \lstinline!my ($nome,$cognome) =!
+\lstinline!    ('Gianni','Ceccarelli');!
+\item \lstinline!($uno,$due)=($due,$uno)!
+\item \lstinline!($p[0],$p[1])=qw(a b)!
+\item \lstinline!my ($a,$b,$c)=(1,2)! \visible<2->{nota: \lstinline!$c! vale \lstinline!undef!}
+\item \lstinline!my ($a,$b)=(1..10)! \visible<2->{8 valori ignorati}
+\end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]\frametitle{Variabili array}
+\begin{lstlisting}
+my @a=(1..10);
+print $a[3],"\n";
+\end{lstlisting}
+
+\visible<2->{
+\lstinline!4!
+}
+
+\visible<3->{Sì, \lstinline!@a! è il nome dell'intero array, ma l'accesso a elemento comincia con \lstinline!$!. Potete usare una variable array in ogni posto dove usereste una lista.}
+
+\visible<4->{Una variabile array cui non è mai stato assegnato nulla ha valore \lstinline!()! (lista vuota).}
+\end{frame}
+
+\begin{frame}[fragile]\frametitle{Assegnamento, di nuovo}
+\begin{lstlisting}
+my @a=(1..10);
+my @b=(20..29);
+my @c=(100,99,@a,50,@b);
+\end{lstlisting}
+
+\visible<2->{È equivalente a \lstinline!@c=(100,99,1..10,50,20..29)!: gli array vengono appiattiti.}
+\end{frame}
+
+\subsection{Funzioni}
+
+\begin{frame}[fragile]\frametitle{\texttt{pop} e \texttt{push}}
+\begin{lstlisting}
+my @a=1..5;    # 1 2 3 4 5
+my $ultimo
+  = pop @a;    # 1 2 3 4
+push @a,11;    # 1 2 3 4 11
+pop @a;        # 1 2 3 4
+push @a,
+  12,13,14;    # 1 2 3 4 12 13 14
+\end{lstlisting}
+
+\lstinline!pop! e \lstinline!push! agiscono sulla {\em coda} dell'array.
+\end{frame}
+%$
+
+\begin{frame}[fragile]\frametitle{\texttt{shift} e \texttt{unshift}}
+\begin{lstlisting}
+my @a=1..5;    # 1 2 3 4 5
+my $primo
+  = shift @a;  # 2 3 4 5
+unshift @a,11; # 11 2 3 4 5
+shift @a;      # 2 3 4 5
+unshift @a,
+  12,13,14;    # 12 13 14 2 3 4 5
+\end{lstlisting}
+
+\lstinline!shift! e \lstinline!unshift! agiscono sulla {\em testa} dell'array.
+\end{frame}
+%$
+
 \subsection{Interpolazione}
 
+\begin{frame}[fragile]\frametitle{Interpolazione}
+Stringhe tra virgolette doppie {\em interpolano} le variabili, anche array:
+
+\begin{itemize}
+\item \lstinline!my @a=(1..3);$msg="Numeri: @a"! \visible<2->{$\rightarrow$ \lstinline!Numeri: 1 2 3!}
+\item \lstinline!$email="dakkar@thenautilus.net"! \visible<2->{errore!}
+\item \lstinline!$email="dakkar\@thenautilus.net"! \visible<2->{ok}
+\item \lstinline!$email='dakkar@thenautilus.net'! \visible<2->{ok}
+\end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]\frametitle{Interpolazione di espressioni}
+Si possono interpolare anche gli accessi ad elemento:
+
+\begin{itemize}
+\item \lstinline!my @a=(1..3);$msg="Numero: $a[1]"! \visible<2->{$\rightarrow$ \lstinline!Numero: 2!}
+\item \lstinline!my $a=5;$msg="[boh]$a[1]"! \visible<2->{errore!}
+\item \lstinline!my $a=5;$msg="[boh]${a}[1]"! \visible<2->{ok}
+\end{itemize}
+\end{frame}
+
 \subsection{\texttt{foreach}}
 
+\begin{frame}[fragile]\frametitle{Cicli su liste}
+\begin{lstlisting}
+foreach my $fratello (qw(Cino Dino Gino Lino)) {
+  print "Un fratello si chiama $fratello\n";
+}
+\end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]\frametitle{Assegnamenti nel ciclo}
+\begin{lstlisting}
+my @fratelli=qw(Cino Dino Gino Lino);
+foreach my $fratello (@fratelli) {
+  $fratello="<$fratello>";
+}
+\end{lstlisting}
+
+Questo {\em cambia il valore} degli elementi dell'array \lstinline!@fratelli!.
+\end{frame}
+%$
+
 \subsection{Il contesto}
 
 \section{Subroutine}
@@ -498,9 +793,11 @@ Adesso \lstinline!$riga! non contiene pi
 
 \section{Argomenti avanzati}
 
+\subsection{Variabile implicita} % $_
+
 \subsection{Manipolazione di stringhe} % substr, sprintf
 
-\subsection{Manipolazione di liste} % sort, grep, map
+\subsection{Manipolazione di liste} % reverse, sort, grep, map
 
 \subsection{Indici multipli} % array & hash slices
 
-- 
cgit v1.2.3