source: trunk/perl/presentation.tex @ 159

% $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}
}

\AtBeginSubsection[]
{
\begin{frame}<beamer>
    \frametitle{Plan}
    \tableofcontents[currentsubsection]
\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}

\subsection{Les listes}

\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}

\subsection{Fonctions et subroutines}

\begin{frame}[fragile]
\frametitle{Fonctions}
Déclarer une fonction:

\begin{verbatim}
sub fonction {
    print "Hello World\n";
}
\end{verbatim}
\pause
On l'appelle:

\begin{verbatim}
fonction();
\end{verbatim}

ou tout simplement:
\begin{verbatim}
fonction;
\end{verbatim}
\pause
\vfill
Sub anonyme, plus rarement utilisé:

\begin{verbatim}
my $sub = sub { };
$sub->();
\end{verbatim}

\end{frame}

\begin{frame}[fragile]
\frametitle{Fonction passage d'arguments}
Perl est un langage qui fonctionne avec un pile:
\pause
\vfill
\begin{itemize}
\item on pouse des élément sur la piles
\item on récupère la pile
\item on pose les résultat sur la pile
\item on récupère la pile
\end{itemize}
\vfill
La pile est une liste.
\end{frame}

\begin{frame}[fragile]
\frametitle{Fonction passage d'arguments}
Exemple:
\pause

\onslide<2->
\begin{verbatim}
sub fonction {
\end{verbatim}
\onslide<3->
\begin{verbatim}
    my ($param) = @_;
\end{verbatim}
\onslide<4->
\begin{verbatim}
    return("-- $param --");
\end{verbatim}
\onslide<2->
\begin{verbatim}
}
\end{verbatim}
\onslide<2>
\begin{verbatim}
fonction();
\end{verbatim}
\onslide<4->
\begin{verbatim}
my $resultat =
\end{verbatim} 
\onslide<3->
\begin{verbatim}
    fonction("perl");
\end{verbatim}

\end{frame}

\subsection{Déclarer ses variables}

\begin{frame}[fragile]
\frametitle{my and co}
Perl est très laxiste:
\pause

\onslide<2-4>
\begin{verbatim}
$latitude = 5;
print "$latitud\n";
\end{verbatim}

\onslide<2->
Deux moyens de forcer les décalarations:
\pause
\begin{itemize}
\item \verb+use strict;+ force la declaration des variables
\pause
\item \verb+use warnings;+ produit des warnings sur les actions douteuses
\end{itemize}

\onslide<5>
\begin{verbatim}
use strict;

my $latitude = 5;
print "$latitude\n";
\end{verbatim}


\end{frame}

\begin{frame}[fragile]
\frametitle{Portée des variables}
\verb+$var+ différent de \verb+@var+ différent de \verb+%var+ !

Sans \verb+use strict;+ Perl fait au mieux.

\pause
Les déclarations se font n'importe où, mais avant leur utilisation:

\onslide<3->
\vfill
\only<3>{Un script propre:}
\only<4>{Déclaration d'une variable globale:}
\only<5>{Au sein d'un bloc, on déclare un variable:}
\only<6>{On peut utiliser la variable globale:}
\only<7>{Attention avant l'initialisation !:}

\onslide<3->
\begin{verbatim}
use strict;
\end{verbatim}

\onslide<7->
\begin{verbatim}
mafonction();
\end{verbatim}

\onslide<4->
\begin{verbatim}
my $var = 1
\end{verbatim}

\onslide<5->
\begin{verbatim}
sub mafonction {
\end{verbatim}
\onslide<6->
\begin{verbatim}
    print $var;
\end{verbatim}
\onslide<5->
\begin{verbatim}
    my $fvar = 3;
}
\end{verbatim}
\end{frame}

\begin{frame}[fragile]
\frametitle{boucles et blocs}
Pour les instruction qui engendre un bloc, les déclarations font partie du bloc:

\pause
Ici la variables \verb+$item+ apartiens au bloc \verb+foreach+:

\begin{verbatim}

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

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

\end{frame}


\section{Variables bis}

\subsection{Références}

\begin{frame}[fragile]
\frametitle{Référence: Concept}
C'est une valeur scalaire\ldots

\pause
\vfill
qui fait référence à un scalaire, un tableau ou un hash.

\pause
\vfill
\begin{itemize}
\item elle contient l'adresse mémoire de l'élément pointé
\pause
\item plusieurs références peuvent pointer la même variable
\pause
\item on peut faire des tableaux de références\ldots
\end{itemize}
\pause
\vfill
\textbf{Ce n'est pas un pointeur au sens C du terme}: \verb.$ref++;. ne donnera rien de bien !!!!
\end{frame}

\begin{frame}[fragile]
\frametitle{Créer des références}
\pause
Référence de tableaux:
\pause
\vfill
\begin{verbatim}
my @tableau = (1, 2, 3);
\end{verbatim}
\pause
Récupérer une référence vers:
\begin{verbatim}
my $tabref = \@tableau;
\end{verbatim}
\pause
Créer une référence vers un nouveau tableau:
\begin{verbatim}
my $tabref = [ @tableau ];
\end{verbatim}
\vfill
\vfill
\pause
Référence de hash:
\pause
\vfill
\begin{verbatim}
my %hash = (a => 1);
\end{verbatim}
\pause
Récupérer une référence vers:
\begin{verbatim}
my $hashref = \%hash;
\end{verbatim}
\pause
Créer une référence vers un nouveau tableau:
\begin{verbatim}
my $hashref = { %hash } ;
\end{verbatim}
\end{frame}

\begin{frame}[fragile]
\frametitle{Utiliser les références}
Pour accéder au contenu la variable référencée on utilise \verb+->+.
\vfill
Pour acceder à la variable elle même: \verb+$$+, \verb+@$+ et \verb+%$+ pour
respectivement les scalaires, tableaux et les hash.

\pause
On créer un réference:
\begin{verbatim}
my $tabref = [ 1, 2, 3 ];
my $hashref = { a => 1 };
\end{verbatim}
\pause
On accède au tableau via la référence:
\begin{verbatim}
$tabref->[0];
$hashref->{a};
\end{verbatim}
\pause
Après tout est presque pareil:
\begin{verbatim}
scalar(@$tabref);
keys %$hashref;
\end{verbatim}

\end{frame}

\begin{frame}[fragile]
\frametitle{Pourquoi les références ?}
Perl aplati les listes, remember ?

\pause
\begin{verbatim}
my @tab1 = (1,2); my @tab2 = (3,4);
my @tab = (@tab1, @tab2);
\end{verbatim}
\verb+@tab+ contient 4 éléments...
\pause
\begin{verbatim}
my @tab1 = (1,2); my @tab2 = (3,4);
my @tab = (\@tab1, \@tab2);
\end{verbatim}
\verb+@tab+ contient 2 éléments qui réferencent des tableaux.
\pause

On accède aux valeurs:
\begin{verbatim}
$tab[0]->[0];
\end{verbatim}
\pause
Ou même plus simplement:
\begin{verbatim}
$tab[0][0];
\end{verbatim}
\ldots qui revient à faire un tableau à 2 dimensions.

\end{frame}

\begin{frame}[fragile]
\frametitle{Références: copain de la mémoire}
\begin{small}
\begin{verbatim}
# très gros tableau
my @tab = ();

fonc(@tab);

sub fonc {
    my @tab = @_; # Créer un copie complète
}
\end{verbatim}
\pause
\begin{verbatim}
# très gros tableau
my @tab = ();

fonc(\@tab);

sub fonc {
    my ($tab) = @_; # Ne copie que la référence
}
\end{verbatim}
\end{small}
\end{frame}

\begin{frame}[fragile]
\frametitle{Références: les pièges}
Déférencer un undef:
\begin{verbatim}
perl -we 'my $ref; print @{ $ref }'
Use of uninitialized value $ref in 
array dereference at -e line 1.
\end{verbatim}
\pause
Voici l'astuce:
\begin{verbatim}
perl -we 'my $ref; print @{ $ref || [] }'
\end{verbatim}
\pause
\vfill
\vfill
Attention au type de variable référencée:
\begin{verbatim}
perl -we 'my $ref = {}; print @{ $ref }'
Not an ARRAY reference at -e line 1.
\end{verbatim}
\pause
\vfill
\vfill
Attention au structure complexes:
\begin{verbatim}
$ref->[0][2]{daleks}[0]{episode}
    {$ennemi}{histoire}[0];
\end{verbatim}
\end{frame}

\begin{frame}[fragile]
\frametitle{Références: dernières choses}
On peut connaitre le type de référence avec \verb+ref()+
\begin{verbatim}
perl -we 'my $ref = {}; print ref $ref'
HASH
\end{verbatim}
\vfill
\vfill
\pause
Tout est là:\\
\verb+man perlreref+
\end{frame}

\subsection{les descripteurs de fichier}

\begin{frame}[fragile]
\frametitle{Fichiers: Version simple}
Version moderne:

Ouvrir un fichier en lecture:
\begin{verbatim}
open(my $handle, '<', 'fichier');
\end{verbatim}
\pause
Lire une ligne:
\begin{verbatim}
my $line = <$handle>;
chomp($line); # strip cariage return
\end{verbatim}
\pause
Fermer le fichier:
\begin{verbatim}
close($handle);
\end{verbatim}
\pause
\vfill
Ancienne méthode:
\begin{verbatim}
open(HANDLE, '<', 'fichier');
my $line = <HANDLE>;
chomp($line); # strip cariage return
close(HANDLE);
\end{verbatim}
\end{frame}

\begin{frame}[fragile]
\frametitle{Fichier: version simple (suite)}

Ouvrir:
\begin{verbatim}
open(my $handle, '>', 'fichier');
\end{verbatim}
\pause
Écrire:
\begin{verbatim}
print $handle "Exterminate !\n";
\end{verbatim}
\begin{textbf}Attention à \verb+print+: pas de \verb+,+ après le file handle\end{textbf}

\pause
\vfill
Fermer:
\begin{verbatim}
close($handle);
\end{verbatim}
\pause
Trois file handle par défaut: \verb+STDIN+, \verb+STDOUT+, \verb+STDERR+
(entrée, sortie, sortie d'erreur).
\end{frame}

\begin{frame}[fragile]
\frametitle{Fichiers: Version compliquée}
Pour des besoins très spécifiques:
\begin{itemize}
\item open()/close()
\item read()/print()
\end{itemize}

\vfill
ou:
\vfill
\pause
\begin{itemize}
\item sysopen()/sysclose()
\item sysread()/syswrite()
\end{itemize}
\pause
\vfill
\vfill
Si vraiment vous voulez en savoir plus: \verb+man+
\begin{itemize}
\item perlfunc
\pause
\item perlopentut
\end{itemize}
\end{frame}

\section{Traiter les chaines de caractères}

\subsection{quote}

\begin{frame}[fragile]
\frametitle{Délimiteurs}
On peut utiliser les délimiteurs:
\begin{itemize}
\item n'importe quel caractères
\item les couples logiques \verb+()+, \verb+[]+, \verb+{}+
\end{itemize}

Exemple: \verb+q//+, \verb+q;;+, \verb+q[]+, \verb+q{}+

\pause
\vfill
Chaine interpolées:

\begin{verbatim}
my $var = "UMR7620";

print "nous somme $var";
pinrt qq{nous somme "$var"};
\end{verbatim}

\pause
\vfill
Chaine non interpolées:

\begin{verbatim}
my $var = 'UMR7620';

print '$var est une variable';
print q{'$var' est une variable};
\end{verbatim}
\end{frame}

\begin{frame}[fragile]
\frametitle{quote quote}
Pour les longues chaines:
\vfill
\begin{verbatim}
my $var = 42;

print <<FIN_DU_TEXTE;
La réponse à la question
universelle est $var.
FIN_DU_TEXTE
\end{verbatim}
\vfill
\end{frame}

\subsection{RegExp}

\begin{frame}
\frametitle{Perl ça pue...}
\vfill
\emph{Perl ça pue, y'a pas de fonction pour travailler avec des regexp comme en php}
\vfill
\pause

Les expressions régulières de Perl sont très puissantes !

\pause
\vfill
Ce qui a donné la lib PCRE (Perl Compatible Regular Expressions).
\end{frame}

\section*{Fin}

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

\end{document}