Dokuwiki

Outils pour utilisateurs

Outils du site

Piste :
perl:boucles_for_foreach_while

Différences

Ci-dessous, les différences entre deux révisions de la page.

Lien vers cette vue comparative

Les deux révisions précédentesRévision précédente
Prochaine révision		Révision précédente
perl:boucles_for_foreach_while [2009/03/15 00:44] – modification externe 127.0.0.1perl:boucles_for_foreach_while [2013/03/12 23:27] (Version actuelle) – root
Ligne 1: Ligne 1:
 +====== Les boucles ======
 +
 ====== 1. For ====== ====== 1. For ======
  
 On retrouve la forme traditionnelle du C, qui se présente exactement de la même façon : On retrouve la forme traditionnelle du C, qui se présente exactement de la même façon :
 +<code perl>
   for (my $i = 0; $i < 10; $i++) {   for (my $i = 0; $i < 10; $i++) {
   print "$i\n";   print "$i\n";
   }   }
 +</code>
  
 L'instruction attend trois éléments : L'instruction attend trois éléments :
Ligne 12: Ligne 16:
  
 Il est possible d'omettre certaines instructions, par exemple : Il est possible d'omettre certaines instructions, par exemple :
 +<code perl>
   my $i = 0;   my $i = 0;
   for (; $i<10; ) { $i++; }   for (; $i<10; ) { $i++; }
   for (;;) { # boucle infinie }   for (;;) { # boucle infinie }
 +</code>
 On peut également contrôler l'exécution de la boucle pendant l'itération, à l'aide de 3 mots-clés : On peut également contrôler l'exécution de la boucle pendant l'itération, à l'aide de 3 mots-clés :
   * **last** : quitte immédiatement la boucle courante   * **last** : quitte immédiatement la boucle courante
Ligne 22: Ligne 27:
  
 Ces mot-clés s'adressent implicitement à la boucle qui contrôlent le bloc où ils sont invoqués. Exemple : Ces mot-clés s'adressent implicitement à la boucle qui contrôlent le bloc où ils sont invoqués. Exemple :
 +<code perl>
   my ($x, $y);   my ($x, $y);
   for ($x = 0; $x < 80; $x++) {   for ($x = 0; $x < 80; $x++) {
Ligne 29: Ligne 35:
   last if ($x * $x < 900); # Termine la boucle for ($x...)   last if ($x * $x < 900); # Termine la boucle for ($x...)
   }   }
 +</code>
  
 Il est possible toutefois de nommer les boucles, et donc de préciser explicitement quelles boucles on veut arrêter, sauter ou redémarrer : Il est possible toutefois de nommer les boucles, et donc de préciser explicitement quelles boucles on veut arrêter, sauter ou redémarrer :
 +<code perl>
   BOUCLE_X: for (my $x = 0; $x < 80; $x++) {   BOUCLE_X: for (my $x = 0; $x < 80; $x++) {
   BOUCLE_Y: for (my $y = 0; $y < 60; $y++) {   BOUCLE_Y: for (my $y = 0; $y < 60; $y++) {
Ligne 37: Ligne 45:
   last BOUCLE_X if ($x * $x < 900); # Termine la boucle for ($x...)   last BOUCLE_X if ($x * $x < 900); # Termine la boucle for ($x...)
   }   }
 +</code>
  
 Cette forme ayant l'avantage de ne pas être sensible à l'imbrication de nouveaux blocs de code, et éventuellement plus lisible et plus sûre si les boucles sont longues et compliquées. C'est également le meilleur moyen de quitter plusieurs boucles imbriquées de façon simple (il existe aussi le goto, déconseillé). Cette forme ayant l'avantage de ne pas être sensible à l'imbrication de nouveaux blocs de code, et éventuellement plus lisible et plus sûre si les boucles sont longues et compliquées. C'est également le meilleur moyen de quitter plusieurs boucles imbriquées de façon simple (il existe aussi le goto, déconseillé).
Ligne 43: Ligne 52:
  
 Pour itérer sur une liste, il existe une instruction simple, lisible et rapide : Pour itérer sur une liste, il existe une instruction simple, lisible et rapide :
 +<code perl>
   my @courses = ("pain", "beurre", "café");   my @courses = ("pain", "beurre", "café");
   foreach my $produit (@courses) {   foreach my $produit (@courses) {
   print "Acheter du $produit\n";   print "Acheter du $produit\n";
   }   }
 +</code>
  
 Il est possible d'omettre l'itérateur (la variable qui reçoit l'élément suivant de la liste à chaque itération), dans ce cas il s'appelle implicitement $_ : Il est possible d'omettre l'itérateur (la variable qui reçoit l'élément suivant de la liste à chaque itération), dans ce cas il s'appelle implicitement $_ :
 +<code perl>
   foreach (@courses) {   foreach (@courses) {
   print "Acheter du $_\n";   print "Acheter du $_\n";
   }   }
 +</code>
  
 Enfin, on a le droit d'inverser la syntaxe: on peut alors mettre une instruction (et non un bloc) en tête puis le foreach après. Ceci peut être plus lisible pour les boucles simples, et mime parfois le langage naturel : Enfin, on a le droit d'inverser la syntaxe: on peut alors mettre une instruction (et non un bloc) en tête puis le foreach après. Ceci peut être plus lisible pour les boucles simples, et mime parfois le langage naturel :
 +<code perl>
   print "Acheter du $_\n" foreach (@courses); # Notez l'absence de bloc "{}"   print "Acheter du $_\n" foreach (@courses); # Notez l'absence de bloc "{}"
 +</code>
  
 L'argument passé à foreach n'est autre qu'une déclaration de liste, il est donc possible d'écrire : L'argument passé à foreach n'est autre qu'une déclaration de liste, il est donc possible d'écrire :
 +<code perl>
   print "Acheter du $_\n" foreach ("pain", "beurre", "café");   print "Acheter du $_\n" foreach ("pain", "beurre", "café");
   for (0..9) { print "$i\n"; } # Un programmeur écrit les compteurs entiers ainsi !   for (0..9) { print "$i\n"; } # Un programmeur écrit les compteurs entiers ainsi !
 +</code>
  
 On retrouve exactement les mêmes mécanismes de nommage de boucle et de contrôle avec les mots-clés last, next et redo. On retrouve exactement les mêmes mécanismes de nommage de boucle et de contrôle avec les mots-clés last, next et redo.
Ligne 67: Ligne 84:
  
 On retrouve encore une construction qui vient du C, la boucle //while// : On retrouve encore une construction qui vient du C, la boucle //while// :
 +<code perl>
   my $i = 0;   my $i = 0;
   while ($i < 5) {   while ($i < 5) {
   $i++;   $i++;
   }   }
 +</code>
  
 Perl définit aussi son homonyme //until// où la condition est simplement inversée : Perl définit aussi son homonyme //until// où la condition est simplement inversée :
 +<code perl>
   my $i = 0;   my $i = 0;
   until ($i >= 5) {   until ($i >= 5) {
   $i++;   $i++;
   }   }
 +</code>
  
 On peut également utiliser les mots-clés //next//, //last// et //redo//. De même que pour //for// et //foreach//, on peut nommer les boucles pour être plus explicite dans leur usage. Il existe même une forme qui permet de reproduire le 3ème élément d'un //for//, c'est-à-dire une expression qui est toujours évaluée en fin d'itération (qu'elle ait été forcée par un //next// ou non : On peut également utiliser les mots-clés //next//, //last// et //redo//. De même que pour //for// et //foreach//, on peut nommer les boucles pour être plus explicite dans leur usage. Il existe même une forme qui permet de reproduire le 3ème élément d'un //for//, c'est-à-dire une expression qui est toujours évaluée en fin d'itération (qu'elle ait été forcée par un //next// ou non :
 +<code perl>
   my $i = 0;   my $i = 0;
   COMPTEUR: while ($i <= 10) {   COMPTEUR: while ($i <= 10) {
Ligne 86: Ligne 108:
   $i++;   $i++;
   }   }
 +</code>
  
 Enfin, il est possible d'évaluer le test en fin d'itération, ce qui veut dire qu'on aura toujours au moins une itération qui aura lieu, avec le classique //do ... while//. Mais attention, il s'agit d'une construction qui ne fait pas partie du langage et a ses limitations (notamment on ne peut ni les nommer, ni utiliser les mots-clés //next//, //last// et //redo//) : Enfin, il est possible d'évaluer le test en fin d'itération, ce qui veut dire qu'on aura toujours au moins une itération qui aura lieu, avec le classique //do ... while//. Mais attention, il s'agit d'une construction qui ne fait pas partie du langage et a ses limitations (notamment on ne peut ni les nommer, ni utiliser les mots-clés //next//, //last// et //redo//) :
 +<code perl>
   my $i;   my $i;
   do {   do {
   $i++;   $i++;
   } while ($i < 5);   } while ($i < 5);
 +  </code>
perl/boucles_for_foreach_while.1237077870.txt.gz · Dernière modification : 2013/03/12 23:27 (modification externe)