source: trunk/perl/variables.tex @ 176

% $Id$

\section{Variables}

\subsection{Variables de Perl}

\begin{frame}
\frametitle{types de variables}
\textbf{15} types de variables:
\pause
\begin{itemize}
\item scalaires (scalar)
\pause
\item tableaux (array)
\pause
\item hash (hash)
\pause
\end{itemize}
\vfill
\onslide<2->
\includegraphics[height=40mm]{Angel_fish}
\onslide<3->
\includegraphics[height=40mm]{tableau}
\onslide<4->
\includegraphics[height=40mm]{hache}
\onslide<5->
\vfill
Et les autres on s'en moque...
\end{frame}

\subsection{Scalaire}

\begin{frame}[fragile]
\frametitle{scalaire}
\begin{block}{Un \textbf{scalaire} est une simple valeur:}
\begin{itemize}
\pause
\item \emph{undef}
\pause
\item définie:
    \begin{itemize}
    \item un chiffre, nombre
    \item une chaine de caractères
    \item \ldots
    \end{itemize}
\end{itemize}
\end{block}
\pause
\vfill
\begin{block}{Convertion}
Perl évalue et converti les valeurs numériques au vol!
\end{block}
\pause
\vfill

\begin{exampleblock}{Exemple de valeur de scalaire}
\begin{verbatim}
$rien = undef;
$chiffre = 42; $chaine = "1";
print $chaine + $chiffre;
print $chaine . $chiffre;
\end{verbatim}
\end{exampleblock}
\end{frame}

\begin{frame}[fragile]
\frametitle{Scalair: Vrai ou Faux ?}
\begin{block}{}
Valeur \textit{fausses}: \textit{undef}, 0, "0", ""

Valeur \textit{vraies}: le reste: 1, "1", "un chien ?"
\end{block}
\pause
\vfill

\begin{exampleblock}{Exemple de test}
\begin{verbatim}
$valeur = "0"; 
if ($valeur) # faux, "0" => 0
if ($valeur == 0) # vrai "0" => 0
if ($valeur eq "") # faux, chaine non vide
\end{verbatim}
\end{exampleblock}
\pause
\vfill

\begin{exampleblock}{0 but True}
\begin{verbatim}
$valeur = "0E0";
\end{verbatim}
\end{exampleblock}
\end{frame}

\subsection{Les tableaux}

\begin{frame}[fragile]
\frametitle{Tableau (array)}
\begin{block}{Les tableaux sont des piles de scalaires}
\begin{verbatim}
$valeur = 3;
@tableau = ($valeur, "chaines");
\end{verbatim}
\end{block}
\pause

\vfill
\begin{block}{}
Ils sont dynamiques, et a une seule dimension
\end{block}
\end{frame}

\begin{frame}[fragile]
\frametitle{Tableau: Exemples}
\begin{exampleblock}{Utilisation:}
\begin{verbatim}
@tableau = (1, 2, 3);
$tableau[3] = 4;
$tableau[-1]; # dernier élément
\end{verbatim}
\end{exampleblock}
\pause
\vfill
\begin{alertblock}{Attention au \$}
\begin{verbatim}
@tableau;
$tableau[1];
\end{verbatim}
\end{alertblock}
\pause
\vfill
\begin{block}{}
Nombre d'éléments: \verb+scalar(@tableau)+

Dernier indice: \verb+$#tableau+
\end{block}
\pause
\vfill
\begin{block}{Les bouts du tableau}
\begin{tabular}{rcl}
shift <=&\verb+0$$$$$n+&<= push\\
unshift =>&\verb+0$$$$$n+&=> pop\\
\end{tabular}
\end{block}
\end{frame}

\subsection{Les tables de hashage}

\begin{frame}[fragile]
\frametitle{hash}
\begin{block}{tables de hashage}
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}
\end{block}

\end{frame}
\begin{frame}[fragile]
\frametitle{hash: exemple}
\begin{exampleblock}{Utiliser tableau de hashage:}
\begin{verbatim}
%hash = ( foo => "un"
          bar => 2 );
print $hash{'bar'};
$clef = 'clef'; $hash{$clef};
\end{verbatim}
\end{exampleblock}
\pause
\vfill
\begin{alertblock}{Attention au \$}
\begin{verbatim}
%hash;
$hash{baz};
\end{verbatim}
\end{alertblock}
\vfill
\pause
\begin{block}{keys: renvois les clefs}
\begin{verbatim}
keys(%hash);
\end{verbatim}
\end{block}

\end{frame}

\subsection{Les listes}

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

Le concept est simple, mais redoutable:
\end{alertblock}
\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}
\begin{block}{}
'\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);
@tab = %hash; %hash = @tableau;
\end{verbatim}
\verb+@tab+ contient "un", 1\ldots
\end{block}
\pause
\begin{block}{hash vers hash}
\begin{verbatim}
%unhash = (%hash2, %hash3);
\end{verbatim}
\verb+%hash+ contient 1 \verb+=>+ 2, 3 \verb+=>+ 4\ldots
\end{block}
\pause
\begin{alertblock}{}
Les clefs dupliquées sont ecrasées, la dernière gagne !
\end{alertblock}
\end{frame}

\subsection{les variables magiques}

\begin{frame}[fragile]
\begin{block}{Elles existent dans tout programme perl.}
Les principales à connaitre:\\
\pause
\vfill

\begin{tabular}{ll}
\verb+$_+&stockage par défaut\\
\pause
\verb+@_+&paramètres des subroutines\\
\pause
&\\
\verb+@ARGV+&les arguments passés aux programmes\\
\pause
&\\
\verb+$a+ et \verb+$b+&utilisé par sort\\
\end{tabular}
\end{block}
\pause

\vfill
\vfill
\begin{alertblock}{Attention à \$\_}
\verb+$_+ permet d'écrire du code succin, mais n'augmente pas la visibilité:
\begin{verbatim}
$entier = int;
\end{verbatim}
\end{alertblock}
\end{frame}