source: trunk/perl/syntaxe.tex @ 173

% $Id$

\section{Syntaxe}

\subsection{Syntaxe générale}

\begin{frame}[fragile]
\frametitle{Grandes lignes}
\begin{itemize}
\item les espaces sépare les mots
\pause
\item le '\verb+;+' sépare les instructions
\pause
\item le '\verb+,+' sépare les valeurs
\pause
\item \verb+( )+ limite une liste
\pause
\item \verb+{ }+ limite un bloc
\pause
\item tout ce qui suit un \verb+#+ est un commentaire
\pause
\item \verb+__END__+ indique la fin des instructions
\end{itemize}
\pause

\begin{exampleblock}{Tout est permis, y compris apporter de la lisibilité à votre code:}
\begin{verbatim}
      push # création du tableau
(         @tableau
  , $valeur,    $valeur2     );
\end{verbatim}
\end{exampleblock}
\end{frame}

\begin{frame}[fragile]
\frametitle{Structure classique d'un script}
\onslide<1-6>{un shell bang:}
\onslide<2->
\begin{verbatim}
#!env perl
\end{verbatim}
\onslide<3-6>{charger les modules dont on a besoin:}
\onslide<4->
\begin{verbatim}
use strict;
use warnings;
\end{verbatim}
\onslide<5-6>{arrive le code:}
\onslide<6->
\begin{verbatim}
while (<STDIN>) {
    s/ //g;
    print $_;
}
\end{verbatim}
\onslide<7->
\begin{verbatim}
__END__
\end{verbatim}
\end{frame}

\subsection{Controles d'execution}

\begin{frame}[fragile]
\frametitle{if}
\begin{exampleblock}{Bah... if quoi...}
\onslide<1->
\vfill
\begin{verbatim}
if ($var == 0) {
    print "var vaut 0\n";
}
\end{verbatim}
\onslide<3->
\begin{verbatim}
 elsif ($var == 1) {
    print "var vaut 1\n";
}
\end{verbatim}
\onslide<2->
\begin{verbatim}
 else {
    print "var vaut $var\n";
}
\end{verbatim}
\end{exampleblock}
\onslide<4->
\begin{block}{Forme suffixée:}
\begin{verbatim}
print "var vaut 0\n" if ($var == 0);
\end{verbatim}
\end{block}
\end{frame}

\begin{frame}[fragile]
\frametitle{while}
\begin{exampleblock}{Boucle tant qu'une condition est vraie:}
\begin{verbatim}
while ($i < 100) {
    print "$i\n";
    $i++;
}
\end{verbatim}
\pause
\begin{verbatim}
do {
    print "$i\n";
    $i++;
} while($i < 100;
\end{verbatim}
\end{exampleblock}
\vfill
\pause
\begin{block}{Forme suffixée:}
\begin{verbatim}
$i++ while($i < 100);
\end{verbatim}
\end{block}
\end{frame}

\begin{frame}[fragile]
\frametitle{foreach}
\begin{exampleblock}{Boucle \textbf{pour chaque} élément d'une liste:}
\begin{verbatim}
foreach $elem (@tableau) {
    print "$elem\n";
}
\end{verbatim}
\end{exampleblock}

Très pratique, cela évite de s'embeter avec les indices du tableau.
\vfill
\pause

\begin{block}{Forme suffixée:}
\begin{verbatim}
print "$_\n" foreach(@tableau);
\end{verbatim}
\end{block}
\end{frame}

\begin{frame}[fragile]
\frametitle{Sortez moi de là}
\begin{block}{\textbf{next} fait passer à la prochaine itération d'une boucle:}
\begin{verbatim}
foreach $val (@tableau) {
    next if(!$val);
    print "$val\n";
}
\end{verbatim}
\end{block}
\pause
\vfill
\begin{block}{\textbf{last} quitte une boucle:}
\begin{verbatim}
foreach $val (@tableau) {
    if ($val > 1000) {
        print "$val est trop haut, arret\n";
        last;
    }
    print "$val\n";
}
\end{verbatim}
\end{block}
\end{frame}


\subsection{Fonctions et subroutines}

\begin{frame}[fragile]
\frametitle{Fonctions}
\begin{block}{Déclarer une fonction:}
\begin{verbatim}
sub fonction {
    print "Hello World\n";
}
\end{verbatim}
\end{block}
\pause
\begin{block}{Utilisation}
\begin{verbatim}
fonction();

fonction;
\end{verbatim}
\end{block}
\pause
\vfill
\begin{block}{\textit{Sub anonyme}, plus rarement utilisé:}
\begin{verbatim}
my $sub = sub { };
$sub->();
\end{verbatim}
\end{block}
\end{frame}

\begin{frame}[fragile]
\frametitle{Fonction: passage d'arguments}
\begin{block}{les arguments sont passé dans \textbf{@\_}}
\only<2>{On passe 1 arguments}
\only<3>{On n arguments (ici 2)}
\only<5>{on rends le premier arguments obligatoire, les autres
sont optionnels}
\onslide<4>{Via un hash:
\begin{itemize}
\item arguments nommés
\item arguments optionnels
\end{itemize}}
\end{block}
\begin{exampleblock}{}
\pause
\begin{semiverbatim}
sub affiche \{
    (\only<2-3,5->{$arg}\only<3,5->{, }\only<3>{$arg2}\only<4->{\%hash}) = @_;
    print \only<2-3,5->{"$arg\\n"}\only<4>{$hash\{key1\}};
\}

affiche(\only<2,3,5->{"foo"}\only<3,5->{, }\only<3>{"bar"}\only<4->{key1 => "val1"});
\end{semiverbatim}
\end{exampleblock}
\end{frame}

\begin{frame}[fragile]
\frametitle{Retours des valeurs}
\begin{block}{la dernière valeur est retournée}
\pause
\only<2-3>{On renvoit \only<2>{explicitement}\only<3>{implicitement} \$res
\only<3>{ (dernière valeur)}}
\only<4>{On renvoit explicitement le résultat}
\only<5>{le resultat est la dernière valeur\ldots}
\end{block}
\begin{exampleblock}{}
\begin{semiverbatim}
sub addition \{
    ($un, $deux) = @\_;
    \only<2-3>{$res = }\only<4>{return }$un + $deux;
    \only<2>{return }\only<2-3>{$res}
\}

print addition(2, 4);
\end{semiverbatim}
\end{exampleblock}
\end{frame}

\subsection{Traitement sur les listes}

\begin{frame}[fragile]
\frametitle{sort}

\begin{block}{Fonction de tri}
Evalue la comparaison entre \verb+$a+ et \verb+$b+

Selon le résultat, l'une ou l'autre passe devant
\end{block}
\pause

\vfill
\begin{exampleblock}{}
\begin{verbatim}
my @tableau = ('010', '1', '12');
\end{verbatim}
\end{exampleblock}
\pause

\vfill
\begin{exampleblock}{tri numérique}
\begin{verbatim}
sort { $a <=> $b } @tableau;
\end{verbatim}
\end{exampleblock}
\pause

\vfill
\begin{exampleblock}{tri alphabétique}
\begin{verbatim}
sort { $a cmp $b } @tableau;
\end{verbatim}
\end{exampleblock}
\pause

\vfill
\begin{exampleblock}{tri numérique inverse}
\begin{verbatim}
sort { $b <=> $a } @tableau;
\end{verbatim}
\end{exampleblock}

\end{frame}

\begin{frame}[fragile]
\frametitle{grep}
\begin{block}{Fonction de filtre}
Revois chaque valeur placée dans \verb+$_+ si la condition renvoyée est vraie
\end{block}
\pause

\vfill
\begin{exampleblock}{}


\begin{verbatim}
my @tableau = ('010', '1', '12');
\end{verbatim}
\end{exampleblock}
\pause

\vfill
\begin{exampleblock}{valeur vraie}
\begin{verbatim}
grep { $_ } @tableau;
\end{verbatim}
\end{exampleblock}
\pause

\vfill
\begin{exampleblock}{avec une condition}
\begin{verbatim}
grep { $_ > 10 } @tableau;
\end{verbatim}
\end{exampleblock}
\pause

\vfill
\begin{exampleblock}{sans utiliser \$\_}
\begin{verbatim}
my $vrai = 1
grep { $vrai } @tableau;
\end{verbatim}
\end{exampleblock}
\end{frame}

\begin{frame}[fragile]
\frametitle{map}
\begin{block}{mappage des valeurs}
Remplace chaque valeur par l'évaluation retournée

Chaque valeur est placé dans \verb+$_+
\end{block}
\pause

\vfill
\begin{exampleblock}{}
\begin{verbatim}
my @tableau = ('010', '1', '12');
\end{verbatim}
\end{exampleblock}
\pause

\vfill
\begin{exampleblock}{renvois chaque valeur + 1}
\begin{verbatim}
map { $_ + 1 } @tableau;
\end{verbatim}
\end{exampleblock}
\pause

\vfill
\begin{exampleblock}{renvois chaque valeur et chaque valeur + 1}
\begin{verbatim}
map { $_, $_ + 1 } @tableau;
\end{verbatim}
\end{exampleblock}
\end{frame}

\begin{frame}[fragile]
\frametitle{Combinaison pour la forme}

\begin{exampleblock}{humpff\ldots}
\begin{semiverbatim}
my @communes =
    \onslide<5->{# première lettre en majuscule}
    map \{ ucfirst($\_) \}
    \onslide<4->{# tri: ordre alphabétique}
    sort \{ $a cmp $b \}
    \onslide<3->{# filtre: première lettre est un m}
    grep \{ substr($\_, 0, 1) eq 'm' \}
    \onslide<2->{# une liste de villes}
    ('nantes',
     'mont de marsan', 'amiens', 'nancy', 'dijon',
     'bordeaux', 'metz', bordeaux', 'bordeaux', );
\end{semiverbatim}
\end{exampleblock}
\end{frame}

\subsection{Déclarer ses variables}

\begin{frame}[fragile]
\frametitle{my and compagny}
\begin{block}{Perl est très laxiste:}
\pause
\only<2>{Voici un code qui fonctionne, mais pas comme on veut\ldots}
\onslide<3->{
Deux moyens de forcer les décalarations:
\pause
\begin{itemize}
\item \textbf{use strict;} force la declaration des variables
\pause
\item \textbf{use warnings;} produit des warnings sur les actions douteuses
\end{itemize}
}
\only<6->{\textbf{my} sert à déclarer une variable\\
}
\pause
\only<8->{Voilà qui est parfait !}
\end{block}

\onslide<5,7>{
\begin{alertblock}{l'erreur:}
\only<5>{Global symbol "\$latitude" requires explicit package}
\only<7>{Global symbol "\$latitud" requires explicit package}
\end{alertblock}
}

\onslide<1->
\begin{exampleblock}{}
\begin{semiverbatim}
\onslide<5->{use strict;
}
\only<6->{my }$latitude = 5;
print "$latitud\only<8->{e}\\n";
\end{semiverbatim}
\end{exampleblock}

\end{frame}

\begin{frame}
\frametitle{The use strict rules}

\begin{alertblock}{J'ai bien pris note que:}
\only<2->{
J'utiliserais au moins \textit{use strict}\\
}
\only<3->{
J'utiliserais \textbf{toujours} au moins \textit{use strict}\\
}
\only<4->{
\textbf{Jamais} je ne dérangerais un gourou Perl si je n'ai pas utilisé
\textit{use strict}\\
}

\end{alertblock}
\end{frame}

\begin{frame}[fragile]
\frametitle{Portée des variables}
\begin{alertblock}{}
\verb+$var+ différent de \verb+@var+ différent de \verb+%var+ !
\end{alertblock}
\pause
\begin{block}{les règles}
Sans \verb+use strict;+ ni \verb+my+ Perl fait au mieux.\\
\pause
Les déclarations se font n'importe où, mais avant leur utilisation.
\end{block}
\pause
\begin{exampleblock}{example:}
\onslide<4->
\begin{semiverbatim}
use strict;
\onslide<5->{mafonction();}
my $var = 1
sub mafonction \{
    print $var;
    my $fvar = 3;
\}
\end{semiverbatim}
\end{exampleblock}
\end{frame}

\begin{frame}[fragile]
\frametitle{boucles et blocs}
\begin{exampleblock}{limiter la portée en utilisant un bloc}
\begin{verbatim}
my $globalvar = 1;
{
    my $blockvar = 2;
}
\end{verbatim}
\end{exampleblock}
\pause

\begin{exampleblock}{Déclaration dans les boucles}
\begin{verbatim}

my @tableau = (1, 2, 3, 4);

foreach my $item (@tableau) {
    print "$item\n";
}
\end{verbatim}
\end{exampleblock}
\end{frame}