source: trunk/perl/presentation.tex @ 153

% $Id$
\documentclass[notes]{beamer}
\usepackage[frenchb]{babel}
\usepackage[T1]{fontenc}
\usepackage{moreverb}
\usepackage{graphicx}

\mode<presentation>
{
  \definecolor{beamerstructure}{RGB}{143,79,112}
  \definecolor{sidebackground}{RGB}{230,242,250}
  \color{beamerstructure}
  \usetheme{Frankfurt}
  \usepackage{times}
  \userightsidebarcolortemplate{\color{sidebackground}}
  \beamertemplateballitem
}

\title{Perl}
\subtitle{5}
\author{Olivier Thauvin}
\date{\today}

%\AtBeginSection[]
%{
%\begin{frame}<beamer>
%    \frametitle{Plan}
%    \tableofcontents[currentsection]
%\end{frame}
%}

\begin{document}

\frame{\titlepage}

\section*{Sommaire}

\begin{frame}{Plan}
\tableofcontents
\end{frame}

\section{Presentation}

\begin{frame}
\frametitle{PERL}
Perl, écrit par Larry Wall en 1987.
\vfill
\emph{Practical Extraction and Report Language}
(\emph{langage pratique d'extraction et de génération de rapports})
\vfill
\emph{Pathetically Eclectic Rubbish Lister}
(\emph{collectionneur de déchets pathétiquement éclectiques})
\vfill

Je parle de Perl \textbf{5} !

Dernière version 5.10.0 (Rafael Garcia-Suarez)
\vfill

Perl est disponible sur UNIX, Windows (et cygwin), OS2, VMS, \ldots
\end{frame}

\begin{frame}
\frametitle{Pourquoi PERL ?}
\begin{itemize}
\item langage scripté, non compilé
\pause
\item portable
\pause
\item permet une écriture rapide
\pause
\item possède un ramasse miettes (garbage collector)
\pause
\item est orienté objet
\pause
\item possède un grand nombre de modules additionnels
\end{itemize}
\pause
\vfill
\vfill
Utilisation:
\begin{itemize}
\item petits scripts type shell
\pause
\item des programmes complexes
\pause
\item des services de toutes sortes
\pause
\item des sites web
\end{itemize}
\end{frame}

\begin{frame}[fragile]
\frametitle{Exemples}
Exemple de script:
\vfill
\begin{verbatim}
#!env perl

print "Hello World\n";
\end{verbatim}
\vfill
\vfill
Sinon on peut aussi faire ça:
\vfill
\verb+perl -e 'print "Hello World\n"'+
\end{frame}
\begin{frame}[fragile]
\frametitle{bestever.pl}
Sinon ça peut aussi ressembler à ça:
\vfill
\begin{tiny}
\begin{verbatim}
/;{}def/#{def}def/$_={/Times-Bold exch selectfont}#/_{rmoveto}#/"{dup}#/*/!/$
;/q{exch}#/x ; {/J q #}#/.{/T q #}#{stringwidth}#{}#{}# 14 string dup dup dup
260 40 moveto 90 rotate ; %/}};$0='"\e[7m \e[0m"';@ARGV=split//,reverse
q(ThePerl). q(Journal) x 220 ; q ; 0 T putinterval exch 7 J putinterval ;
 ; $_= q /m$ pop T($*!$"=!$ " )pop " * true% ? $ " $!" "  !!  !! % !" !"    !
! charpath {!"""}pop $ pop{""!}pop ! neg{!#}pop 220 ! neg _{!!}pop J false %T
charpath  clip " pop 0 " moveto 6{!!}pop $_= 105{!!}pop {$ ! $ " !  #! ##}
pop{dup dup $ ! " pop pop q{"}pop 22{dup show}repeat {"}pop q 22 mul{$ "} pop
neg{!#! $ "}pop ! 8 .65 mul{$ # # $}pop ! neg{"}pop  _ pop{"}pop } repeat pop
" {  $ " ! ! ! $ " ! !" "#"  #"!"""""! #" " # "m/;@ARGV=(@ARGV[-14..-1])x50;q}
 0 "%};s/m[ou]|[-\dA-ln-z.\n_{}]|\$_=//gx;s/(.)(?{$*=''})/('$*.='.(++$#
%2?'':"$0;").'pop;')x(ord($1)-31).'$*'/gee;s/((.(\e\[.m)*|.){77})/$1\n/g;print
; sub showpage {}
\end{verbatim}
\end{tiny}
\vfill
De Philippe Bruhat (Book).
\end{frame}

\section{Variables}

\subsection{Variables de Perl}

\begin{frame}
\frametitle{types de variables}
\textbf{15} types de variables:
\vfill
\pause
\includegraphics[height=40mm]{Angel_fish}
\pause
\includegraphics[height=40mm]{tableau}
\pause
\includegraphics[height=40mm]{hache}
\pause
\vfill
Et les autres on s'en moque...
\end{frame}

\subsection{Scalaire}

\begin{frame}[fragile]
\frametitle{scalaire}
Un \textbf{scalaire} est une simple valeur:
\pause
\vfill
\begin{itemize}
\item \emph{undef}
\pause
\item définie:
    \begin{itemize}
    \item un chiffre, nombre
    \item une chaine de caractères
    \item une suite d'octets binaires
    \item \ldots
    \end{itemize}
\end{itemize}
\pause
\vfill
\begin{verbatim}
$rien = undef;
$chiffre = 42;
$chaine = "1";
print $chaine + $chiffre;
print $chaine . $chiffre;
\end{verbatim}
\pause
\vfill
Valeur \textit{fausses}: \textit{undef}, 0, ""

Valeur \textit{vraies}: le reste: 1, "0", "un chien ?"
\end{frame}

\subsection{Les tableaux}

\begin{frame}[fragile]
\frametitle{tableau (array)}
Les tableaux sont des piles de \textit{scalaires}.
\pause

Ils sont dynamiques, et a une seule dimension (mais ce n'est pas un problème en fait).
\pause
\vfill
Déclarer le tableau:

\verb+@tableau = ("un", 2);+
\vfill
Accéder aux/Déclarer les valeurs d'un tableau (attention au \$):

\begin{verbatim}
$tableau[3] = 4;
$tableau[-1]; # dernier élément
\end{verbatim}

\pause
\vfill
Mais en fait:\hfill
\begin{tabular}{rcl}
shift <=&\verb+0@@@@@n+&<= push\\
unshift =>&\verb+0@@@@@n+&=> pop\\
\end{tabular}
\pause
\vfill
Nombre d'éléments: \verb+scalar(@tableau)+

Dernier indice: \verb+$#tableau+
\end{frame}

\begin{frame}[fragile]
\frametitle{hash}
Ce sont des tableaux indexés \verb+clef => valeur+.

Ils sont dynamiques.

\pause
\begin{itemize}
\item la clef est une valeur textuelle simple
\item la valeur est un \textbf{scalaire}
\item l'ordre des clefs n'est pas conservé !!!
\end{itemize}

\pause
Déclarer un tableau de hashage:
\begin{verbatim}
%hash = (
    foo => "un"
    bar => 2
);
\end{verbatim}

\pause
Accéder aux/Déclarer les valeurs d'un hash (attention au \$):
\begin{verbatim}
$hash{baz} = 'trois';
$clef = 'clef';
$hash{$clef};
\end{verbatim}

\end{frame}

\begin{frame}[fragile]
\frametitle{Comprendre les listes}
\textbf{Perl aplati les listes !}

Le concept est simple, mais redoutable:
\pause

Prenons deux tableaux de trois entrées:
\begin{verbatim}
@tab1 = (1, 2, 3);
@tab2 = (4, 5, 6);
\end{verbatim}
\pause

Récupérer la première entrée, et le reste de \verb+@tab1+
\begin{verbatim}
($un, @reste) = @tab1;
\end{verbatim}
\pause
Récupérer la première entrée, et le reste de \verb+@tab1+ et \verb+@tab2+
\begin{verbatim}
($un, @reste) = (@tab1, @tab2);
\end{verbatim}
\pause
Récupérer la deuxième entrée, et le reste de \verb+@tab1+ et \verb+@tab2+
\begin{verbatim}
(undef, $deux, @reste) = (@tab1, @tab2);
\end{verbatim}
\end{frame}

\begin{frame}[fragile]
\frametitle{Comprendre les listes: les hash}
Mais le pire, c'est que ce concept s'applique aussi \textbf{hash}
\pause

'\verb+=>+' est un séparateur comme la '\verb+,+', donc c'est une liste:
\begin{verbatim}
%hash = (un => 1, deux => 2);
%hash = (un, 1, deux, 2);
\end{verbatim}
\pause
Si un hash revois une liste et prends une liste\ldots
\begin{verbatim}
@tab = %hash;
\end{verbatim}
\verb+@tab+ contient "un", 1\ldots

\begin{verbatim}
@tab = (1, 2, 3, 4);
%hash = @tab;
%unhash = (%hash2, %hash3);
\end{verbatim}
\verb+%hash+ contient 1 \verb+=>+ 2, 3 \verb+=>+ 4\ldots

Les clef dupliquées sont ecrasées, la dernière gagne !

\end{frame}

\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__+ mets fin au script
\end{itemize}
\pause

Tout est permis, y compris apporter de la lisibilité à votre code:
\begin{verbatim}
      push # création du tableau
(         @tableau
  , $valeur,
    $valeur2                   );
\end{verbatim}
Sauf si vous tenez à faire dans l'obfu !
\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}
\onslide<1->
Bah... if quoi...
\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}
\onslide<4->
Forme suffixée:
\begin{verbatim}
print "var vaut 0\n" if ($var == 0);
\end{verbatim}
\end{frame}

\begin{frame}[fragile]
\frametitle{while}
Boucle tant qu'une condition est vraie:

\begin{verbatim}
while ($i < 100) {
    print "$i\n";
    $i++;
}
\end{verbatim}
\vfill
\pause
Forme suffixée:

\begin{verbatim}
$i++ while($i < 100);
\end{verbatim}
\end{frame}

\begin{frame}[fragile]
\frametitle{foreach}
Boucle \textbf{pour chaque} élément d'une liste:

\begin{verbatim}
foreach $elem (@tableau) {
    print "$elem\n";
}
\end{verbatim}

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

Forme suffixée:

\begin{verbatim}
print "$_\n" foreach(@tableau);
\end{verbatim}
\end{frame}

\begin{frame}[fragile]
\frametitle{Sortez moi de là}
\textbf{next} fait passer à la prochaine itération d'une boucle:

\begin{verbatim}
foreach $val (@tableau) {
    next if(!$val);
    print "$val\n";
}
\end{verbatim}
\pause
\vfill
\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{frame}

\section*{Fin}

\begin{frame}{Questions ?}
\center{
\hfill
}
\end{frame}

\end{document}