__ ______
            __    __  __  _ ___   __       _  _   _   _\_ _  _   \
           /  \  /  \ \ \ \  _ \ \ .\     | |/ / / / / _  / /.\   \
     .- - / /\ \/ /\ \-\_\ \_\\_\-\_/ ----|   < /_/-/_//_/\/__/    \-  ------.
     :    \ \ \__/ / /                    |_|\_\           \        \        :
     ,     \/      \/                                       \        \       |
     :                                                       \        \      .
     . 11.13   À la conquête du chameau; Part 3               \        \     !
     .             aka                                         \        \    .
     ;          J'aurais mieux aimé camel dise pas              \        \   :
     :                                                           \        \  :
     '-- -----  - -------- --- --------- - --  ------------- --- -\        \-'
                                                                   \____ _ _\



Les dernières parties de ce tutorial étaient plutôt fastoches, on a vu  comment
jouer avec les variables, et comment faire des expressions avec des opérateurs.
Il serait peut-être temps  qu'on voie  des choses  pour enfin programmer! Voici
donc les structures de contrôles et boucles.


L'art de faire 72000 affaires avec if
¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
Bon c'est une  blague, il n'y  a pas vraiment  72000 affaires à  faire avec if,
mais par  contre Perl  offre l'inverse  du if,  le moyen  d'inverser if  et une
manière bizarre de dire else if. Voici donc de quoi tout ça a l'air :
if ($CONDITION) { affaires(); }
Dans le cas la les { } sont OBLIGATOIRE. Que vous faite ça sur une ligne ou
if ($CONDITION) {
	affaires();
}
de  même, vous  avez à  mettre les  {} tout  le temps.  Si vous  vous  demander
pourquoi, ou  bien comment  se débarrasser  de ça,  c'est que  le if agit d'une
manière peu commune :
affaires() if ($CONDITION);
Cette  ligne est  totalement valide.  Évidemment on  exécute affaires()  si la
condition est vrai... Admettons que  vous voulez faire le contraire  de if(si),
disons un if(!$CONDITION), et bien vous pouvez utiliser unless(sauf si) :
unless ($CONDITION) {
	affaires();
}
Le else existe, et le else if  est nommé bizarrement elsif. Il est à  noter que
unless n'a pas de "elsunless". Voici un exemple clair :
if ($CONDITION) {
	affaires();
} elsif ($CONDITION2) {
	affaires2();
} else {
	affaires3();
}
Finalement, l'opérateur conditionnel "? :" (comme en C) existe aussi en Perl :
$CONDITION ? affaires() : affaireselse();


Boucles Boucles Boucles Boucles Boucles
¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
Loops en anglais (moins laid que boucles j'avoue).
On retrouve en Perl les loops que nous sommes habitués de voir :
while($COND) { affaires(); }
until($COND) { affaires(); }
for(my $i = 0; $i <=10; $i++) { affaires(); }
Cependant on retrouve aussi des affaires ésotériques tel que le "continue" :
while($COND) { affaires(); } continue { print "hop! "; }
À chaque itération du while le bloque après continue sera exécuté, un peu  dans
le genre du $i++ dans le for. Aussi, il y a des "shortcuts" qu'on peut prendre.
Admettons qu'on veut  passer à la  prochaine itération de  la boucle sans  tout
exécuter dans les affaires(), et bien on met un next; qui s'occupera de quitter
le code en cours et d'aller à la suite de la boucle. Il existe aussi last;  qui
permet de quitter  la boucle. Et  comme si c'était  pas assé, il  y a redo; qui
refait le block d'affaires à exécuter. Palpitant.
En  plus de  ces boucles,  on retrouve  le fameux  foreach. foreach  permet de
parcourir une liste et d'exécuté le bloc à chaque item de la liste :
foreach $jour (@semaine) { print $jour; }
va imprimer chaque jour dans semaine(exemple poche j'avoue). Pour rajouter plus
de liberté dans  votre vie de  programmeur, foreach est  pareil que for  (huh),
c'est à dire que  si vous écrivez for  $jour (@semaine) et bien  ça va marcher.
Personnellement je préfère écrire foreach car ça se "lit mieux". N'oublier  pas
que le @semaine est traité en valeur de liste, donc on peut utiliser  n'importe
quel fonction  qui retourne  une liste  (comme keys  pour savoir  les clef d'un
hash, de cette manière  : keys %monhash) ou  bien encore écrire directement  la
liste nous même :
foreach $machin ("pwet", "meuh", "ayoye")
ça va marcher. on peut aussi mettre 1..10 pour compter de 1 à 10..
De plus, si vous mettez pas $machin, ça va marcher pareil! Respectivement,
"pwet", "meuh" et "ayoye" vont se retrouver dans $_. Humm bizare ce $_...


Les variables bizares
¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
Perl contient une  panoplie de variables  dites "bizares" ou  "spéciales". Elle
sont spéciales car elles contiennent toute sorte d'affaire magiquement affecté.
Par exemple le $_ contient la "chose" en cours :
foreach (1,2,3) { print $_; }
Va imprimer les 1 2 3 vu que le $machin devant la liste a été ommit.
On peut aussi faire:
foreach (1,2,3) { print; }
car print  imprime $_  lorsqu'on lui  passe aucun  argument ;-)  $_ ne sert pas
juste pour  foreach, il  sert aussi  au pattern  matching, et  lorsqu'on lit un
fichier. Il est aussi appelé $ARG lorsque l'ont met "use English;" au début  de
notre script. D'ailleurs  pour chaque variable  spéciale, il existe  sa version
anglaise, qui est bien  sûr plus longue à  écrire, mais plus facile  à retenir.
Bien qu'il existe plusieurs variables  spéciales, je me sers presque  seulement
de ceux-ci, les autres étant trop précis ou trop compliquer à retenir :
$!
  Contient la dernière erreur
     open FICHIER, "fichier" or die "ne peut ouvrir fichier : $!";
@ARGV
  liste qui contient les arguments passés au script par la command line
%ENV
  hash qui contient l'environnement Unix
     exemple : $ENV{PATH}
$]
  contient la version courante de Perl
     $PERL_VERSION avec use English;
$0
  contient le nom du fichier du script Perl en cours
$^O
  contient le nom du OS pour lequel le binary de Perl a été compilé
@_
  liste qui contient les paramètres d'une sub..
  
(remarquer encore ici le lien logique entre mon dernier mot de cette section et
la prochaine section, hehe)


Les sous-routines (sub)
¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
Un jour va arriver que vos scripts Perl vont commencer à être un peu plus  gros
que 2  lignes. Cette  journée la  vous allez  sûrement aussi  commencer à  vous
servir des subs :
sub zouit { affaires(); }
Cette ligne déclare la sub zouit  qui va exécuter les affaires(). Pour  une sub
avec des paramètres, on la call de la manière suivante :
zouit $param1, $param2;
Dans la déclaration de la sub, il n'y a aucune spécification de paramètres.  La
raison est que chaque paramètre est empilé dans la pile nommée @_, on y  accède
donc de la manière suivante:
sub zouit {
	my $bah = shift @_;
	my $beh = shift @_;
}
On peut  aussi omettre  le @_  et juste  écrire shift,  qui va  le shifter  par
défaut. Si on est sûr qu'on va toujours avoir 2 paramètres, on peut aussi faire
sub zouit {
	my ($bah, $beh) = @_;
}
Rappel : Les parenthèses dans ce cas-ci  serve à donner un contexte de liste  à
$bah et $beh dans le  but de lui associer une  autre liste (le array @_);  Pour
retourner de la sub, on utilise return; (ouf compliqué ça la). Aussi noter  que
dans @_ on mets n'importe quel  variable qu'on veut, autant des hash,  d'autres
listes, des références.


Jouer aux blocs légos c'est funne
¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯

Depuis tantôt qu'on voit des  {} partout. Ordinairement en programmation  on ne
se pose pas trop de questions, ça fait parti de la syntaxe de chaque statement.
Par contre en Perl un {} est appelé un bloc et peut être utilisé seul.
{
	affaires();
}
Bon ok peu pratique, mais on peut faire comme avec les boucles, mettre un  next
dedans et ça va sortir du block.. (même chose avec last, pis on peut même faire
un redo. heh)
{
	next if ($COND);
	affaires();
}
Disons que c'est une façon bizarre de faire un if..


Les bons vieux GOTOs
¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
Depuis tantôt que je parle de boucles, de next, de last et etc.. Les plus futés
d'entre-vous on sûrement aperçu un genre de  goto dans ça. Et bien oui, Perl  a
des GOTOs. On peut même le faire nous autre même. Mettons que j'ai un while, et
bien  je peux  mettre devant  un label  pour spécifier  le nom  du while..  pas
pratique quand il y a juste un while, mais très quand ta 2 boucles imbriquées :
MEUH: for (1..2) {
	for (1..5) {
		print $_;
		next MEUH if ($_ == 2);
	}
}
Plutôt useless, mais ça démontre bien comment s'en servir. Faites attention ici
de ne pas mettre "gogo" lui même à la place de next, bien que ça fasse la  même
chose, le next termine la 2ième boucle  for, alors que le goto garde tout  à la
même place (ce qui  résulte en une boucle  infinie). On peut donc  utiliser les
gotos comme on veut, mais il faut faire attention.. Je pourrais écrire :
goto MEUH;
ici et ça va retourner à ma boucle de tantôt.. comme dans le bon vieux temps de
la programmation en BASIC, heh.


Conclusion
¯¯¯¯¯¯¯¯¯¯
Et voilà, maintenant avec l'accumulation  de mes autres articles,  vous  pouvez
coder des scripts qui ont de l'allure et  comprendre ceux qui sont  déjà écrit.
Les  prochains articles  s'annoncent plus  pratiques que  théoriques, car  coté
théorie de base j'ai déjà fait le tour pas mal, c'est juste que Perl est  conçu
à 99% de  "tip & tricks",  donc il risque  un jour que  d'avoir des articles de
"tips" et de "tricks".. d'ici là, on  va avoir  passé par les modules les  plus
populaires en Perl, et la  programmation orientée objet en Perl.  (Ça parais-tu
je me suis fait un plan pour les futurs articles? haha!)

Dans la prochaine partie de ce  tutorial nous allons  voir le pattern  matching
en Perl  et comment utiliser des modules. Si vous avez des questions  n'hésitez
pas à me  les poser, si pertinentes, elles seront répondues et inclues dans les
futurs articles.

                                                                    - LastCall_



            ___                                                           ___
     .----/   /----------- ---------- --------- - -- - - --- -----------/   /
     |   /   /                                                         /   /|
     :  /   /                                                         /   / :
     | /   /                lastcall@mindkind.org                    /   /  |
     |/   /                                                         /   /   | 
     /___/-- ---------- -----  ----------------- - ------- -- --- -/___/----'