[150] | 1 | % $Id$ |
---|
| 2 | |
---|
[156] | 3 | \section{Variables bis} |
---|
| 4 | |
---|
| 5 | \subsection{Références} |
---|
| 6 | |
---|
| 7 | \begin{frame}[fragile] |
---|
| 8 | \frametitle{Référence: Concept} |
---|
| 9 | C'est une valeur scalaire\ldots |
---|
| 10 | |
---|
| 11 | \pause |
---|
| 12 | \vfill |
---|
| 13 | qui fait référence à un scalaire, un tableau ou un hash. |
---|
| 14 | |
---|
| 15 | \pause |
---|
| 16 | \vfill |
---|
| 17 | \begin{itemize} |
---|
| 18 | \item elle contient l'adresse mémoire de l'élément pointé |
---|
| 19 | \pause |
---|
| 20 | \item plusieurs références peuvent pointer la même variable |
---|
| 21 | \pause |
---|
| 22 | \item on peut faire des tableaux de références\ldots |
---|
| 23 | \end{itemize} |
---|
| 24 | \pause |
---|
| 25 | \vfill |
---|
| 26 | \textbf{Ce n'est pas un pointeur au sens C du terme}: \verb.$ref++;. ne donnera rien de bien !!!! |
---|
| 27 | \end{frame} |
---|
| 28 | |
---|
| 29 | \begin{frame}[fragile] |
---|
| 30 | \frametitle{Créer des références} |
---|
| 31 | \pause |
---|
| 32 | Référence de tableaux: |
---|
| 33 | \pause |
---|
| 34 | \vfill |
---|
| 35 | \begin{verbatim} |
---|
| 36 | my @tableau = (1, 2, 3); |
---|
| 37 | \end{verbatim} |
---|
| 38 | \pause |
---|
| 39 | Récupérer une référence vers: |
---|
| 40 | \begin{verbatim} |
---|
| 41 | my $tabref = \@tableau; |
---|
| 42 | \end{verbatim} |
---|
| 43 | \pause |
---|
| 44 | Créer une référence vers un nouveau tableau: |
---|
| 45 | \begin{verbatim} |
---|
| 46 | my $tabref = [ @tableau ]; |
---|
| 47 | \end{verbatim} |
---|
| 48 | \vfill |
---|
| 49 | \vfill |
---|
| 50 | \pause |
---|
| 51 | Référence de hash: |
---|
| 52 | \pause |
---|
| 53 | \vfill |
---|
| 54 | \begin{verbatim} |
---|
| 55 | my %hash = (a => 1); |
---|
| 56 | \end{verbatim} |
---|
| 57 | \pause |
---|
| 58 | Récupérer une référence vers: |
---|
| 59 | \begin{verbatim} |
---|
| 60 | my $hashref = \%hash; |
---|
| 61 | \end{verbatim} |
---|
| 62 | \pause |
---|
| 63 | Créer une référence vers un nouveau tableau: |
---|
| 64 | \begin{verbatim} |
---|
| 65 | my $hashref = { %hash } ; |
---|
| 66 | \end{verbatim} |
---|
| 67 | \end{frame} |
---|
| 68 | |
---|
| 69 | \begin{frame}[fragile] |
---|
| 70 | \frametitle{Utiliser les références} |
---|
| 71 | Pour accéder au contenu la variable référencée on utilise \verb+->+. |
---|
| 72 | \vfill |
---|
| 73 | Pour acceder à la variable elle même: \verb+$$+, \verb+@$+ et \verb+%$+ pour |
---|
| 74 | respectivement les scalaires, tableaux et les hash. |
---|
| 75 | |
---|
| 76 | \pause |
---|
| 77 | On créer un réference: |
---|
| 78 | \begin{verbatim} |
---|
| 79 | my $tabref = [ 1, 2, 3 ]; |
---|
| 80 | my $hashref = { a => 1 }; |
---|
| 81 | \end{verbatim} |
---|
| 82 | \pause |
---|
| 83 | On accède au tableau via la référence: |
---|
| 84 | \begin{verbatim} |
---|
| 85 | $tabref->[0]; |
---|
| 86 | $hashref->{a}; |
---|
| 87 | \end{verbatim} |
---|
| 88 | \pause |
---|
| 89 | Après tout est presque pareil: |
---|
| 90 | \begin{verbatim} |
---|
| 91 | scalar(@$tabref); |
---|
| 92 | keys %$hashref; |
---|
| 93 | \end{verbatim} |
---|
| 94 | |
---|
| 95 | \end{frame} |
---|
| 96 | |
---|
| 97 | \begin{frame}[fragile] |
---|
| 98 | \frametitle{Pourquoi les références ?} |
---|
| 99 | Perl aplati les listes, remember ? |
---|
| 100 | |
---|
| 101 | \pause |
---|
| 102 | \begin{verbatim} |
---|
| 103 | my @tab1 = (1,2); my @tab2 = (3,4); |
---|
| 104 | my @tab = (@tab1, @tab2); |
---|
| 105 | \end{verbatim} |
---|
| 106 | \verb+@tab+ contient 4 éléments... |
---|
| 107 | \pause |
---|
| 108 | \begin{verbatim} |
---|
| 109 | my @tab1 = (1,2); my @tab2 = (3,4); |
---|
| 110 | my @tab = (\@tab1, \@tab2); |
---|
| 111 | \end{verbatim} |
---|
| 112 | \verb+@tab+ contient 2 éléments qui réferencent des tableaux. |
---|
| 113 | \pause |
---|
| 114 | |
---|
| 115 | On accède aux valeurs: |
---|
| 116 | \begin{verbatim} |
---|
| 117 | $tab[0]->[0]; |
---|
| 118 | \end{verbatim} |
---|
| 119 | \pause |
---|
| 120 | Ou même plus simplement: |
---|
| 121 | \begin{verbatim} |
---|
| 122 | $tab[0][0]; |
---|
| 123 | \end{verbatim} |
---|
| 124 | \ldots qui revient à faire un tableau à 2 dimensions. |
---|
| 125 | |
---|
| 126 | \end{frame} |
---|
| 127 | |
---|
| 128 | \begin{frame}[fragile] |
---|
| 129 | \frametitle{Références: copain de la mémoire} |
---|
| 130 | \begin{small} |
---|
| 131 | \begin{verbatim} |
---|
| 132 | # très gros tableau |
---|
| 133 | my @tab = (); |
---|
| 134 | |
---|
| 135 | fonc(@tab); |
---|
| 136 | |
---|
| 137 | sub fonc { |
---|
| 138 | my @tab = @_; # Créer un copie complète |
---|
| 139 | } |
---|
| 140 | \end{verbatim} |
---|
| 141 | \pause |
---|
| 142 | \begin{verbatim} |
---|
| 143 | # très gros tableau |
---|
| 144 | my @tab = (); |
---|
| 145 | |
---|
| 146 | fonc(\@tab); |
---|
| 147 | |
---|
| 148 | sub fonc { |
---|
| 149 | my ($tab) = @_; # Ne copie que la référence |
---|
| 150 | } |
---|
| 151 | \end{verbatim} |
---|
| 152 | \end{small} |
---|
| 153 | \end{frame} |
---|
| 154 | |
---|
[157] | 155 | \begin{frame}[fragile] |
---|
| 156 | \frametitle{Références: les pièges} |
---|
| 157 | Déférencer un undef: |
---|
| 158 | \begin{verbatim} |
---|
| 159 | perl -we 'my $ref; print @{ $ref }' |
---|
| 160 | Use of uninitialized value $ref in |
---|
| 161 | array dereference at -e line 1. |
---|
| 162 | \end{verbatim} |
---|
| 163 | \pause |
---|
| 164 | Voici l'astuce: |
---|
| 165 | \begin{verbatim} |
---|
| 166 | perl -we 'my $ref; print @{ $ref || [] }' |
---|
| 167 | \end{verbatim} |
---|
| 168 | \pause |
---|
| 169 | \vfill |
---|
| 170 | \vfill |
---|
| 171 | Attention au type de variable référencée: |
---|
| 172 | \begin{verbatim} |
---|
| 173 | perl -we 'my $ref = {}; print @{ $ref }' |
---|
| 174 | Not an ARRAY reference at -e line 1. |
---|
| 175 | \end{verbatim} |
---|
| 176 | \pause |
---|
| 177 | \vfill |
---|
| 178 | \vfill |
---|
| 179 | Attention au structure complexes: |
---|
| 180 | \begin{verbatim} |
---|
| 181 | $ref->[0][2]{daleks}[0]{episode} |
---|
| 182 | {$ennemi}{histoire}[0]; |
---|
| 183 | \end{verbatim} |
---|
| 184 | \end{frame} |
---|
| 185 | |
---|
| 186 | \begin{frame}[fragile] |
---|
| 187 | \frametitle{Références: dernières choses} |
---|
| 188 | On peut connaitre le type de référence avec \verb+ref()+ |
---|
| 189 | \begin{verbatim} |
---|
| 190 | perl -we 'my $ref = {}; print ref $ref' |
---|
| 191 | HASH |
---|
| 192 | \end{verbatim} |
---|
| 193 | \vfill |
---|
| 194 | \vfill |
---|
| 195 | \pause |
---|
| 196 | Tout est là:\\ |
---|
| 197 | \verb+man perlreref+ |
---|
| 198 | \end{frame} |
---|
| 199 | |
---|
| 200 | \subsection{les descripteurs de fichier} |
---|
| 201 | |
---|
| 202 | \begin{frame}[fragile] |
---|
| 203 | \frametitle{Fichiers: Version simple} |
---|
| 204 | Version moderne: |
---|
| 205 | |
---|
| 206 | Ouvrir un fichier en lecture: |
---|
| 207 | \begin{verbatim} |
---|
| 208 | open(my $handle, '<', 'fichier'); |
---|
| 209 | \end{verbatim} |
---|
| 210 | \pause |
---|
| 211 | Lire une ligne: |
---|
| 212 | \begin{verbatim} |
---|
| 213 | my $line = <$handle>; |
---|
| 214 | chomp($line); # strip cariage return |
---|
| 215 | \end{verbatim} |
---|
| 216 | \pause |
---|
| 217 | Fermer le fichier: |
---|
| 218 | \begin{verbatim} |
---|
| 219 | close($handle); |
---|
| 220 | \end{verbatim} |
---|
| 221 | \pause |
---|
| 222 | \vfill |
---|
| 223 | Ancienne méthode: |
---|
| 224 | \begin{verbatim} |
---|
| 225 | open(HANDLE, '<', 'fichier'); |
---|
| 226 | my $line = <HANDLE>; |
---|
| 227 | chomp($line); # strip cariage return |
---|
| 228 | close(HANDLE); |
---|
| 229 | \end{verbatim} |
---|
| 230 | \end{frame} |
---|
| 231 | |
---|
| 232 | \begin{frame}[fragile] |
---|
| 233 | \frametitle{Fichier: version simple (suite)} |
---|
| 234 | |
---|
| 235 | Ouvrir: |
---|
| 236 | \begin{verbatim} |
---|
| 237 | open(my $handle, '>', 'fichier'); |
---|
| 238 | \end{verbatim} |
---|
| 239 | \pause |
---|
| 240 | Écrire: |
---|
| 241 | \begin{verbatim} |
---|
| 242 | print $handle "Exterminate !\n"; |
---|
| 243 | \end{verbatim} |
---|
| 244 | \begin{textbf}Attention à \verb+print+: pas de \verb+,+ après le file handle\end{textbf} |
---|
| 245 | |
---|
| 246 | \pause |
---|
| 247 | \vfill |
---|
| 248 | Fermer: |
---|
| 249 | \begin{verbatim} |
---|
| 250 | close($handle); |
---|
| 251 | \end{verbatim} |
---|
| 252 | \pause |
---|
| 253 | Trois file handle par défaut: \verb+STDIN+, \verb+STDOUT+, \verb+STDERR+ |
---|
| 254 | (entrée, sortie, sortie d'erreur). |
---|
| 255 | \end{frame} |
---|
| 256 | |
---|
| 257 | \begin{frame}[fragile] |
---|
| 258 | \frametitle{Fichiers: Version compliquée} |
---|
| 259 | Pour des besoins très spécifiques: |
---|
| 260 | \begin{itemize} |
---|
| 261 | \item open()/close() |
---|
| 262 | \item read()/print() |
---|
| 263 | \end{itemize} |
---|
| 264 | |
---|
| 265 | \vfill |
---|
| 266 | ou: |
---|
| 267 | \vfill |
---|
| 268 | \pause |
---|
| 269 | \begin{itemize} |
---|
| 270 | \item sysopen()/sysclose() |
---|
| 271 | \item sysread()/syswrite() |
---|
| 272 | \end{itemize} |
---|
| 273 | \pause |
---|
| 274 | \vfill |
---|
| 275 | \vfill |
---|
| 276 | Si vraiment vous voulez en savoir plus: \verb+man+ |
---|
| 277 | \begin{itemize} |
---|
| 278 | \item perlfunc |
---|
| 279 | \pause |
---|
| 280 | \item perlopentut |
---|
| 281 | \end{itemize} |
---|
| 282 | \end{frame} |
---|
| 283 | |
---|