\documentclass[12pt]{beamer}
% - preambolo: stili, package, comandi
% -- questo imposta lo stile della presentazione
\mode<presentation>{
% \usetheme{Frankfurt}
% \usetheme[secheader]{Boadilla}
\usetheme[hideallsubsections,right]{PaloAlto}
\usecolortheme{sidebartab}
\usecolortheme{seahorse}
\setbeamercovered{transparent}
}
% -- package
% --- questo � per la grafica
\usepackage{pgf}
% --- font, encoding, lingua
\usepackage{times}
\usepackage[T1]{fontenc}
\usepackage[italian]{babel}
% -- metadati per la pagina del titolo
\title[Perl]{Corso introduttivo a Perl}
\author{dakkar}
\subject{Perl}
% -- comandi di comodo
% --- slide con titolo implicito
\newenvironment{slide}[1][c]
{\begin{frame}[#1]
\frametitle{\insertsubsection}}
{\end{frame}}
% --- come sopra, ma per gli esempi di comandi
\newenvironment{fslide}[1][c]
{\begin{frame}[fragile,environment=fslide,#1]
\frametitle{\insertsubsection}}
{\end{frame}}
% --- lista a comparsa progressiva
\newenvironment{mylist}
{\begin{itemize}[<+->]}
{\end{itemize}}
% --- cosa far vedere all'inizio di una ``parte''
%% \AtBeginPart
%% {
%% \begin{frame}<beamer>
%% \frametitle{\insertpart}
%% \tableofcontents[hideallsubsections]
%% \end{frame}
%% }
% --- cosa far vedere all'inizio di una sezione
\AtBeginSection[]
{
\begin{frame}<beamer>[shrink]
\frametitle{\insertsection}
\tableofcontents[sectionstyle=show/hide,subsectionstyle=show/show/hide]
\end{frame}
}
%% \AtBeginSubsection[]
%% {
%% \begin{frame}<beamer>
%% \frametitle{Struttura}
%% \tableofcontents[sectionstyle=show/hide,subsectionstyle=show/shaded/hide]
%% \end{frame}
%% }
% - contenuti
\begin{document}
\begin{frame}
\titlepage
\end{frame}
\section[Obiettivi]{Obiettivi del corso}
\subsection{Cosa imparerete}
\begin{slide}
\begin{itemize}
\item come si scrive ed esegue un programma Perl
\item nomi, variabili e valori in Perl
\item strutture di controllo
\item subroutine
\item moduli
\item espressioni regolari
\end{itemize}
\end{slide}
\subsection{Cosa suppongo sappiate}
\begin{slide}
\begin{itemize}
\item usare un editor di testi
\item usare la linea di comando
\item programmare in qualche linguaggio imperativo
\end{itemize}
\end{slide}
\section{Cos'� Perl}
\subsection{Il nome}
\begin{slide}
\begin{itemize}[<+->]
\item \texttt{Perl} � il nome del linguaggio
\item \texttt{perl} � il nome del programma
\item \texttt{PERL} � un errore
\end{itemize}
\end{slide}
\begin{slide}
\begin{itemize}[<+->]
\item \emph{non} � una sigla
\item � un nome
\item se proprio volete...
\begin{itemize}[<+->]
\item Practical Extraction and Report Language
\item Pathologically Eclectic Rubbish Lister
\item Polymorphic Existential Recursive Lambdas
\end{itemize}
\end{itemize}
\end{slide}
\subsection{Interprete o compilatore?}
\begin{slide}
\addtocounter{beamerpauses}{1}
\begin{description}
\item[Interprete] legge un'istruzione alla volta e la esegue
\begin{itemize}[<+->]
\item scova gli errori solo quando ci sbatte
\item non fa ottimizzazioni serie
\end{itemize}
\item[Compilatore] trasforma il programma da un linguaggio a un altro
\begin{itemize}[<+->]
\item pu� scovare molti errori staticamente
\item pu� ottimizzare il codice
\item \emph{non � mai sufficiente}
\end{itemize}
\end{description}
\end{slide}
\begin{slide}
\begin{itemize}[<+->]
\item la CPU � un interprete
\item \texttt{bash} � un interprete
\item la JVM � un interprete
\item \texttt{perl} � un interprete
\end{itemize}
\end{slide}
\begin{slide}
\begin{itemize}[<+->]
\item \texttt{GCC} � un compilatore
\item \texttt{javac} � un compilatore
\item \texttt{perl} � un compilatore
\end{itemize}
\end{slide}
\begin{slide}
\texttt{perl} esamina l'intero programma, e se non ci sono errori lo
\emph{compila} in una struttura dati in RAM, la quale viene poi
\emph{interpretata}
\end{slide}
\subsection{La filosofia}
\begin{slide}
\begin{itemize}[<+->]
\item simile a un linguaggio naturale
\item TMTOWTDI
\item making easy things easy, and hard things possible
\item \emph{manipulexity} vs. \emph{whipuptitude}
\end{itemize}
\end{slide}
\section[Programmi]{Scrivere ed eseguire programmi}
\subsection{File di testo}
\begin{slide}
\uncover<+->{Come la maggior parte dei linguaggi di programmazione,
Perl legge i programmi da semplici file di testo.}
\uncover<+->{Per il momento supponiamo di usare soltanto i caratteri
dell'insieme ASCII (niente accentate)}
\uncover<+->{� pi� semplice se usate i fine-linea normali per la
vostra piattaforma}
\end{slide}
\subsection{Convenzioni}
\begin{slide}
\begin{itemize}[<+->]
\item per i programmi potete usare i nomi che volete
\item certe volte si usa \texttt{.pl} come estensione
\item \texttt{\#!/usr/bin/perl} o \texttt{\#!/usr/bin/env perl}
\item i file che contengono moduli devono avere nomi particolari
\end{itemize}
\end{slide}
\begin{fslide}
\begin{verbatim}
#!/usr/bin/env perl
use strict;
use warnings;
# qui il vostro programma
\end{verbatim}
\end{fslide}
\subsection{Esecuzione}
\begin{slide}
\begin{itemize}[<+->]
\item \texttt{perl nomefile}
\item *NIX: \texttt{chmod +x nomefile; ./nomefile}
\item Windows: trucchi con i file \texttt{.BAT}
\end{itemize}
\end{slide}
\section{Sintassi}
\subsection{Istruzioni}
\begin{slide}
Le istruzioni sono terminate da punto-e-virgola:
\vspace{1em}\hspace{2em}\texttt{print 'Buh!';}
\end{slide}
\subsection{Commenti}
\begin{slide}
Il carattere \texttt{\#} inizia un commento che si estende fino alla
fine della linea:
\vspace{1em}\hspace{2em}\texttt{print 'Buh!'; \# commento}
\end{slide}
\subsection{Spazi}
\begin{slide}
Gli spazi \emph{tra parole} non sono significativi:
\vspace{1em}\hspace{2em}\texttt{print}\\
\hspace{2em}\texttt{\ \ 'Buh!';}
\end{slide}
\begin{slide}
Gli spazi \emph{dentro le stringhe} sono mantenuti:
\vspace{1em}\hspace{2em}\texttt{print 'Buh!}\\
\hspace{2em}\texttt{\ \ Bah!';}
\end{slide}
\subsection{Valori}
\begin{slide}
I numeri si scrivono normalmente:
\begin{itemize}[<+->]
\item \texttt{12}
\item \texttt{7.45}
\item \texttt{7.3e-2}
\item \texttt{015}
\item \texttt{0x40}
\end{itemize}
\end{slide}
\begin{fslide}
Le stringhe si scrivono tra virgolette:
\begin{itemize}[<+->]
\item \texttt{'gino'}
\item \verb|'$&^@$&*^#'|
\end{itemize}
\end{fslide}
\begin{fslide}
Il tipo di virgolette fa differenza!
\addtocounter{beamerpauses}{1}
\begin{itemize}[<+->]
\item \verb|'abc\ndef'| sono 8 caratteri
\item \verb|"abc\ndef"| sono 7 caratteri, e il 4$^o$ � un a-capo
\end{itemize}
\uncover<+->{Le virgolette doppie \emph{interpolano}}
\end{fslide}
\section[Variabili]{Variabili e valori}
\subsection{Tipi}
\begin{fslide}
Perl converte tra numeri e stringhe secondo l'uso:
\begin{itemize}
\item \verb|'23'+2| fa \texttt{25}
\item \verb|23 . 'c'| fa \texttt{'23c'}
\end{itemize}
\end{fslide}
\begin{slide}
I tipi base di Perl sono:
\begin{itemize}[<+->]
\item \emph{scalari}, singoli valori
\item \emph{array}, sequenze di scalari indicati per posizione
\item \emph{hash}, dizionario di scalari indicati con chiave stringa
\end{itemize}
\end{slide}
\subsection[Nomi]{Nomi e visibilit�}
\begin{slide}
Perl usa i \emph{sigilli} per indicare i tipi dei nomi:
\begin{itemize}[<+->]
\item \texttt{\$} indica uno scalare
\item \texttt{@} indica un array
\item \texttt{\%} indica un hash
\end{itemize}
\end{slide}
\begin{frame}[c]
\frametitle{Accedere agli elementi}
\begin{itemize}[<+->]
\item \texttt{\$array[1]} � il secondo elemento (scalare) dell'array
\texttt{@array}
\item \texttt{@array[1,2]} � uno \emph{slice} (pezzo di array)
\item \texttt{\$hash\{a\}} � l'elemento (scalare) dell'hash \texttt{\%hash}
corrispondente alla chiave \texttt{'a'}
\end{itemize}
\end{frame}
\begin{slide}
� buona norma dichiarare i nomi che vogliamo usare:
\vspace{1em}\hspace{2em}\texttt{my \$scalare;}\\
\hspace{2em}\texttt{my @array;}\\
\hspace{2em}\texttt{my \%hash;}
\end{slide}
\begin{fslide}
I nomi dichiarati con \texttt{my} sono visibili solo all'interno del
blocco in cui compare la dichiarazione:
\begin{verbatim}
my $a=3;
{
my $b=5;
print "a=$a\n"; # a=3
print "b=$b\n"; # b=5
}
print "a=$a\n"; # a=3
print "b=$b\n"; # b=
\end{verbatim}
\end{fslide}
\subsection[Contenitori]{Contenitori e durata}
\begin{slide}
\begin{itemize}[<+->]
\item \emph{Non} scendo nei dettagli
\item Un nome riferisce un contenitore di un certo tipo
\item Il contenitore contiene un valore del tipo giusto
\item Pi� nomi possono riferire lo stesso contenitore
\item La memoria occupata viene liberata quando non ce n'� pi� bisogno
(\emph{garbage collection})
\end{itemize}
\end{slide}
\subsection{Valori}
\begin{slide}
Valori immediati:
\begin{itemize}[<+->]
\item numeri: \texttt{2.24}
\item stringhe: \texttt{'gino'}
\item liste: \texttt{(1,2,'pino')}
\item liste con la freccia: \texttt{( a => 1, b => 'buh')}
\end{itemize}
\end{slide}
\begin{slide}
Assegnamento:
\begin{itemize}[<+->]
\item \texttt{\$numero = 2.24;}
\item \texttt{\$stringa = 'gino';}
\item \texttt{@array = (1,2,'pino');}
\item \texttt{\%hash = (a => 1, b => 'buh');}
\end{itemize}
\end{slide}
\begin{slide}
\uncover<+->{Un contenitore scalare cui non � mai stato assegnato
nulla ha valore \texttt{undef}.}
\uncover<+->{\texttt{undef} ha valore numerico \texttt{0} e valore
stringa \texttt{''}}
\end{slide}
\subsection{Contesto}
\begin{slide}
\uncover<+->{Ogni espressione Perl viene valutata in un certo
\emph{contesto}, e il suo valore di solito dipende dal contesto.}
\uncover<+->{Esempi:}
\uncover<.->{\vspace{1em}\hspace{2em}\texttt{@array=1;}}\\
\uncover<+->{array di 1 elemento, \texttt{\$array[0]==1}}
\uncover<+->{\vspace{0.5em}\hspace{2em}\texttt{\$scalare=('a','b','c');}}\\
\uncover<+->{\texttt{\$scalare} vale 'c'}
\uncover<+->{\vspace{0.5em}\hspace{2em}\texttt{@array=('a','b','c');}\\
\hspace{2em}\texttt{\$scalare=@array;}}\\
\uncover<+->{\texttt{\$scalare} vale 3}
\end{slide}
\begin{slide}
Esempi (cont.):
\uncover<+->{\vspace{1em}\hspace{2em}\texttt{\%hash=1;}}\\
\uncover<+->{errore!}
\uncover<+->{\vspace{1em}\hspace{2em}\texttt{\%hash=('a',1);}}\\
\uncover<+->{\texttt{\$hash\{a\}} vale 1}
\uncover<+->{\vspace{0.5em}\hspace{2em}\texttt{\$scalare=\%hash;}}\\
\uncover<+->{\texttt{\$scalare} � 0 se \texttt{\%hash} � vuoto,
qualcos'altro altrimenti}
\end{slide}
\section[Struttura]{Strutture di controllo}
\subsection{Condizionali}
\begin{fslide}[t]
\begin{semiverbatim}
if ($guardia) \{
# blocco da eseguire
# se $guardia e` vero
\}
\only<3->{elsif ($guardia2) \{
# blocco da eseguire
# se $guardia e` falso
# e $guardia2 e` vero
\}
}\only<2->{else \{
}\only<2>{ # blocco da eseguire
# se $guardia e` falso
}\only<3->{ # blocco da eseguire
# se $guardia e` falso
# e $guardia2 e` falso
}\only<2->{\}}
\end{semiverbatim}
\end{fslide}
\begin{fslide}
\begin{verbatim}
unless ($guardia) {
# blocco da eseguire
# se $guardia e` falso
}
\end{verbatim}
\end{fslide}
\begin{frame}
\frametitle{Vero e falso}
\begin{itemize}[<+->]
\item \texttt{0} � falso
\item \texttt{''} (stringa vuota) � falso
\item \texttt{'0'} � falso (!)
\item \texttt{undef} � falso
\item \emph{tutto il resto} � vero
\end{itemize}
\end{frame}
\subsection{Cicli limitati}
\begin{fslide}
\begin{verbatim}
for my $elemento (@array) {
# blocco che usa $elemento
}
\end{verbatim}
\uncover<2->{NOTA: se assegnate a \texttt{\$elemento}, cambiate i
valori in \texttt{@array}.}
\end{fslide}
\begin{fslide}
\begin{verbatim}
for my $elemento (1,2,3,4) {
# blocco che usa $elemento
}
\end{verbatim}
Qui \emph{non potete} assegnare a \texttt{\$elemento}.
\end{fslide}
\begin{fslide}
\begin{verbatim}
for my $elemento (1..4) {
# blocco che usa $elemento
}
\end{verbatim}
Come prima.
\end{fslide}
\subsection{Cicli illimitati}
\begin{fslide}
\begin{verbatim}
while ($guardia) {
# blocco ripetuto
# finche' $guardia e` vero
}
\end{verbatim}
\end{fslide}
\begin{fslide}
\begin{verbatim}
until ($guardia) {
# blocco ripetuto
# finche' $guardia e` falso
}
\end{verbatim}
NOTA: il blocco pu� anche non essere mai eseguito!
\end{fslide}
\begin{fslide}
\begin{verbatim}
for(my $i=0;$i<10;++$i) {
# blocco
}
\end{verbatim} %$
Come in C. Si usa di rado.
\end{fslide}
\subsection{Modificatori}
\begin{fslide}
\begin{semiverbatim}
\uncover<+->{print ``ok\\n'' if $debug;}
\uncover<+->{print ``$_\\n'' for @array;}
\uncover<+->{$i++ while $array[$i]<=0;}
\end{semiverbatim} %$
\end{fslide}
\section[Predefiniti]{Operatori e funzioni predefinite}
\subsection{Aritmetica}
\begin{fslide}
\begin{verbatim}
++$numero; $numero--;
$c = $a * $b; $c = $a / $b; $c = $a % $b;
$c = $a + $b; $c = $a - $b;
\end{verbatim}
\end{fslide}
\subsection{Stringa}
\begin{fslide}
\begin{verbatim}
++$stringa; $stringa--;
$c = $a x $b;
$c = $a . $b;
\end{verbatim}
\end{fslide}
\subsection{Confronto}
\begin{fslide}
\begin{verbatim}
$a < $b $a lt $b
$a <= $b $a le $b
$a == $b $a eq $b
$a >= $b $a ge $b
$a > $b $a gt $b
\end{verbatim}
\end{fslide}
\subsection{Booleani}
\begin{fslide}
\begin{verbatim}
&& and
|| or
! not
\end{verbatim}
\end{fslide}
\subsection{Assegnamento}
\begin{slide}
Quasi tutti gil operatori binari possono essere combinati con
l'assegnamento:
\vspace{1em}\hspace{2em}\texttt{\$a .= \$b;}\\
\hspace{2em}\texttt{\$a += \$b;}
\end{slide}
\section[I/O]{File e I/O}
\subsection[Aprire]{Aprire un file}
\begin{fslide}
\begin{verbatim}
open HANDLE,'<nomefile';
open my $handle,'>','nomefile';
\end{verbatim} %$
\end{fslide}
\subsection[Scrivere]{Scrivere su un file}
\begin{fslide}
\begin{verbatim}
print HANDLE "qualcosa\n";
print $handle $qualcosa,"\n";
\end{verbatim}
\end{fslide}
\subsection[Leggere]{Leggere da un file}
\begin{fslide}
\begin{verbatim}
$linea=<HANDLE>;
@linee=<$handle>;
\end{verbatim}
\uncover<2->{In contesto scalare, \texttt{<>} restituisce
\texttt{undef} a fine file.}
\end{fslide}
\subsection[Chiudere]{Chiudere un file}
\begin{fslide}
\begin{verbatim}
close HANDLE;
close $handle;
\end{verbatim} %$
\uncover<2->{Se usate l'handle scalare, il file viene chiuso dal
garbage collector: non serve chiamare \texttt{close}.}
\end{fslide}
\subsection{Esempio}
\begin{fslide}
\begin{verbatim}
open my $input,'<',$ARGV[0];
open my $output,'>',$ARGV[1];
while (my $linea=<$input>) {
print $output $linea;
}
\end{verbatim}
\end{fslide}
\section{Subroutine}
\subsection[Definire]{Definire una subroutine}
\begin{fslide}
\begin{verbatim}
sub saluta {
print "Ciao!\n";
return;
}
\end{verbatim}
\end{fslide}
\subsection[Parametri]{Il passaggio dei parametri}
\begin{fslide}
Le subroutine ricevono i parametri nell'array \texttt{@\_}.
\begin{verbatim}
sub somma {
my $ret=0;
for my $numero (@_) {
$ret+=$numero;
}
return $ret;
}
\end{verbatim} %$
\end{fslide}
\subsection[Chiamare]{Chiamare una subroutine}
\begin{fslide}
\begin{verbatim}
saluta();saluta;
my $tot=somma(1..10);
\end{verbatim} %$
Le parentesi non sono strettamente necessarie, se avete gi� dichiarato
la subroutine.
\end{fslide}
\subsection[Ritorno]{Valore di ritorno}
\begin{slide}
L'istruzione \texttt{return} viene usata per restituire un valore al
chiamante.
\uncover<2->{L'argomento di \texttt{return} � un'espressione che viene
valutata nel contesto in cui � stata chiamata la subroutine.}
\end{slide}
\begin{fslide}
\begin{verbatim}
sub leggi_file {
my ($filename)=@_;
open my $handle,'<',$filename;
return <$handle>;
}
$prima_riga = leggi_file '/tmp/file1';
@tutte_righe = leggi_file '/tmp/file1';
\end{verbatim} %$
\end{fslide}
\section[Moduli]{Moduli e CPAN}
\subsection[Usare]{Usare i moduli}
\begin{slide}
\texttt{use Text::Wrap;}
\begin{itemize}[<+->]
\item cerca \texttt{Text/Wrap.pm} e lo ``carica''
\item ci sono parecchi dettagli, ma per ora possiamo ignorarli
\end{itemize}
\end{slide}
\begin{fslide}
\begin{verbatim}
use Text::Wrap;
$Text::Wrap::columns=40;
my $result=wrap(' ','',$text);
\end{verbatim} %$
\addtocounter{beamerpauses}{1}
\begin{itemize}[<+->]
\item un modulo spesso introduce un \emph{namespace}
\item un modulo spesso \emph{esporta} delle subroutine
\end{itemize}
\end{fslide}
\subsection{CPAN}
\begin{slide}
\begin{itemize}[<+->]
\item non scendo nei dettagli
\item se avete un problema, molto probabilmente qualcuno l'ha gi�
risolto
\item \texttt{http://search.cpan.org/}
\item 11450 pacchetti, liberamente usabili
\end{itemize}
\end{slide}
\section[Oltre]{Oltre questo corso}
\subsection{Libri}
\begin{slide}
\begin{itemize}
\item Learning Perl
\item Intermediate Perl
\item Programming Perl
\end{itemize}
\end{slide}
\subsection{In rete}
\begin{slide}
\begin{itemize}
\item \texttt{http://www.perl.it/}
\item \texttt{http://use.perl.org/}
\item \texttt{http://learn.perl.org/}
\item \ldots\texttt{/library/beginning\_perl/}
\item \texttt{http://www.perlmonks.org/}
\end{itemize}
\end{slide}
\begin{slide}
\begin{itemize}
\item \texttt{\#perl.it} su FreeNode
\item \texttt{mongers@perl.it}
\end{itemize}
\end{slide}
\end{document}
% -
% Local Variables:
% mode: outline-minor
% outline-regexp: "\\(. -+ \\)\\|\\\\part\\|\\\\section\\|\\\\subsection"
% coding: iso-8859-1
% tex-command: "pdflatex"
% End:
