Apprenez A Programmer en Perl PDF

Apprenez
programmer en Perl !
Par Erd ,
Kharec
et nohar
www.openclassrooms.com
Licence Creative Commons 7 2.0

Dernire mise jour le 2/08/2012
2/61
Sommaire
Sommaire ...........................................................................................................................................
Lire aussi ............................................................................................................................................
Apprenez programmer en Perl ! ......................................................................................................
Partie 1 : Introduction Perl ...............................................................................................................
2
1
3
5
Qu'est-ce que Perl ? .......................................................................................................................................................... 5

Prsentation ................................................................................................................................................................................................................ 5
Quels outils faut-il pour programmer en Perl ? ........................................................................................................................................................... 7
Sous Windows ............................................................................................................................................................................................................ 7
Sous GNU/Linux, Mac OS X, et autres UNIX .............................................................................................................................................................. 8
Excuter un script ........................................................................................................................................................................................................ 9
Cration du programme .............................................................................................................................................................................................. 9
Premiers pas ................................................................................................................................................................... 11

Hello, world! ............................................................................................................................................................................................................... 12
Premiers lments de langage ................................................................................................................................................................................. 12
la dcouverte des variables ................................................................................................................................................................................... 14
Le mot-cl "my" ......................................................................................................................................................................................................... 15
Affecter une valeur une variable ............................................................................................................................................................................. 15
Les scalaires ............................................................................................................................................................................................................. 16
Notion de typage ....................................................................................................................................................................................................... 16
Les nombres ............................................................................................................................................................................................................. 17
Les chanes de caractres ........................................................................................................................................................................................ 18
Oprations sur les chanes de caractres ................................................................................................................................................................. 20
Do what I mean! ........................................................................................................................................................................................................ 21
Place la pratique ! ................................................................................................................................................................................................... 22
Diamonds are a girl's best friend ............................................................................................................................................................................... 22
vos claviers ! .......................................................................................................................................................................................................... 23
Les branchements conditionnels .................................................................................................................................... 26

Prdicats et boolens ................................................................................................................................................................................................
Posons le contexte ....................................................................................................................................................................................................
Les boolens .............................................................................................................................................................................................................
Oprateurs de comparaison ......................................................................................................................................................................................
Oprateurs logiques ..................................................................................................................................................................................................
La fonction defined ....................................................................................................................................................................................................
if, else, et unless .......................................................................................................................................................................................................
O en sommes nous ? ..............................................................................................................................................................................................
if et else .....................................................................................................................................................................................................................
Branchements en srie .............................................................................................................................................................................................
unless ........................................................................................................................................................................................................................
Travailler avec des blocs ...........................................................................................................................................................................................
Mise en forme et indentation du code .......................................................................................................................................................................
Notion de porte lexicale ...........................................................................................................................................................................................
La syntaxe en ligne .............................................................................................................................................................................................
TP : jeu de devinettes (premire version) .................................................................................................................................................................
26
26
27
27
29
33
34
34
35
36
38
38
38
40
41
42
Processus itratifs et boucles ......................................................................................................................................... 45

La boucle de base : while .......................................................................................................................................................................................... 45
Ordre d'excution ...................................................................................................................................................................................................... 46
Oprateurs d'incrmentation et de dcrmentation .................................................................................................................................................. 47
TP : jeu du plus ou moins .......................................................................................................................................................................................... 48
Tirer un nombre au hasard ........................................................................................................................................................................................ 48
La boucle principale .................................................................................................................................................................................................. 49
Programme final ........................................................................................................................................................................................................ 49
Traitement de fichiers ................................................................................................................................................................................................ 50
open et close ............................................................................................................................................................................................................. 50
Lecture et criture ..................................................................................................................................................................................................... 51
Les fichiers et la boucle while ................................................................................................................................................................................... 52
Exercices ................................................................................................................................................................................................................... 53
La variable implicite $_ .............................................................................................................................................................................................. 55
La vrit sur l'oprateur <> ....................................................................................................................................................................................... 56
D'autres types de boucles ......................................................................................................................................................................................... 56
La boucle until ........................................................................................................................................................................................................... 56
La boucle do while ................................................................................................................................................................................................ 57
La boucle for .............................................................................................................................................................................................................. 58
La syntaxe en ligne ................................................................................................................................................................................................... 58
Sommaire
3/61
Apprenez programmer en Perl !

Le tutoriel que vous tes en train de lire est en bta-test. Son auteur souhaite que vous lui fassiez part de vos
commentaires pour l'aider l'amliorer avant sa publication officielle. Notez que le contenu n'a pas t valid par
l'quipe ditoriale du Site du Zro.
Par
nohar et
Kharec et
Erd
Mise jour : 02/08/2012

Difficult : Facile
Connaissez-vous Perl ? Seulement de nom ? Cela ne m'tonne pas !
Assez mconnu de nos jours, notamment depuis la naissance et l'envol de PHP dans les annes 1990, Perl est un langage de
programmation la rputation sotrique. Certains poussent mme le vice jusqu' le qualifier de difficile comprendre, lui
donnant l'image d'un outil terrifiant au moyen duquel les nerds du ct obscur de la Force produisent des programmes
cryptiques que bien peu de courageux aventuriers ne tentent de modifier aprs leur passage. Programmer en Perl relverait donc,
dans l'imaginaire collectif, tant de l'exploit que de la magie noire
Eh bien c'est faux !
Si vous lisez ces quelques mots, c'est que vous vous apprtez apprendre programmer en Perl. Vous tes donc sur le point
de dcouvrir un langage qui a justement t conu pour tre plus facile et convivial utiliser que les langages qui tiennent le
devant de la scne tels que C ou Java, tout en restant un outil particulirement puissant, capable de traiter d'normes volumes de
donnes en trs peu de lignes de code, tel point que ses caractristiques ont t imites dans la conception d'autres langages
trs utiliss dans le domaine du web, comme PHP ou Ruby. Il est le compagnon de route de nombreux administrateurs systme
sous Unix, mais aussi la matire premire de plusieurs gros sites et applications connues, tels qu'Amazon, IMDb, slashdot, les
serveurs Bugzilla, ou encore une partie du gestionnaire de version git.
Perl est un langage pragmatique, de la puissance duquel il est facile de tirer profit afin de crer des scripts et des programmes en
trs peu de temps. Ces caractristiques lui valent son surnom de rouleau de scotch de l'Internet. Cela ne vous est-il jamais arriv
de vous sentir dmuni parce que vous n'aviez pas de scotch sous la main pour fabriquer ou rparer un objet indispensable en
deux temps, trois mouvements ?
qui est destin ce tutoriel ?
Vous n'avez jamais cod de votre vie, mais vous souhaitez dcouvrir la programmation pour dvelopper vos propres
outils ou vos premiers petits jeux ?
Vous tes en stage ou travaillez dans une entreprise dans laquelle on vous a demand d'crire ou maintenir un script en
Perl ?
Vous connaissez dj un autre langage comme C++ ou Java, mais ressentez le besoin d'un outil de beaucoup plus haut
niveau pour faire communiquer vos programmes entre eux ?
Ou bien vous tes simplement curieux et joueur, et vous voulez passer gratuitement pour un mage noir aux yeux de vos
amis geeks ?
Si vous avez rpondu oui l'une de ces questions, ce cours est fait pour vous !
4/61
En lisant ce tutoriel, qui dmarre depuis zro, vous apprendrez :

les bases de la programmation imprative,
les caractristiques qui font de Perl un indispensable couteau suisse,
comment passer d'un problme concret l'criture du programme qui le rsoud,
les problmatiques courantes en programmation : la lecture et l'criture dans des fichiers et dans des flux de donnes,
comment faire communiquer des programmes sur un rseau
les notions de base de la programmation oriente objet.
Nous serons amens raliser plusieurs programmes en suivant ce cours, tels que de petits jeux, des outils d'administration, et
mme un petit serveur web ! Alors, tents ?
5/61
Partie 1 : Introduction Perl

Dans cette premire partie vous apprendrez les bases de Perl de manire tre aptes, raliser vos premiers scripts.
Qu'est-ce que Perl ?

Bienvenue dans le premier chapitre de ce tutoriel !
Vous apprendrez d'abord ce qu'est Perl, puis quels outils il vous faut pour programmer en Perl.
A la fin, vous excuterez votre premier programme.
Prsentation
Perl est un langage de programmation cr en 1987 par Larry Wall. l'origine, il tait surtout utilis pour le dveloppement de
scripts d'administration systme sous UNIX, mais, avec les annes, et aprs plusieurs rvisions importantes du langage, Perl est
rapidement devenu un outil polyvalent, puissant et extrmement pratique, ce qui lui vaut aujourd'hui le surnom humoristique de
rouleau de scotch de l'internet .
Un langage de script
On entend souvent parler de langage de script
lorsque l'on dsigne certains langages comme Perl,
PHP, Python ou encore Ruby, mais que signifie cette
expression, au juste ? Pour comprendre cette
distinction, il nous faut examiner brivement les
diffrentes faons dont les programmes peuvent
tre excuts sur un ordinateur.
Au dpart, un programme se prsente toujours
comme un ensemble de fichiers qui ne contiennent
rien d'autre que du texte. Cet ensemble de fichiers
forme ce que l'on appelle le code-source du
programme. Le code-source est rdig dans un
langage de programmation qui est comprhensible
par les humains (du moins ceux qui savent
programmer
). Il existe de trs nombreux
langages de programmation, dont Perl fait partie.
Larry Wall, crateur de Perl
Crdit photo : Randal Schwartz
Lorsque l'on veut excuter un programme dont on possde le code-source, la premire chose faire est de le compiler. La
compilation, c'est simplement le fait de transformer un programme crit dans le langage X afin de lui donner une reprsentation
abstraite que l'ordinateur peut comprendre. Typiquement, cette reprsentation abstraite modlise une srie d'instructions. Cette
tape de compilation est ralise par ce que l'on appellera pour l'instant un super-programme.
Aprs la phase de compilation, il peut se passer plusieurs choses, selon le langage (ou plutt la technologie) utilis(e) :
Le super-programme peut dcider d'excuter directement les instructions qu'il vient de compiler. Dans ce cas de figure, le
super-programme s'appelle un interprteur.
Alternativement, le super-programme peut dcider de crer un nouveau fichier, dans lequel il va crire les instructions
qu'il vient de compiler, dans un langage comprhensible cette fois directement par l'ordinateur (le langage machine), et ce
super-programme s'appelle alors, simplement, et par abus de langage, un compilateur.
Il existe encore d'autres cas de figure possibles que nous tairons ici (ce n'est pas le sujet), mais ce qu'il faut retenir, c'est
simplement que dans un cas, le programme que l'on vient de compiler est excut par l'interprteur, alors que dans l'autre cas, le
programme peut tre excut directement par la machine. Dans ces conditions, ce que l'on appelle un langage de script, c'est un
langage avec lequel les programmes sont compils et interprts dans la foule. Ceci a l'avantage de rendre les programmes
faciles maintenir et corriger (sans passer par une tape de compilation indpendante qui peut parfois tre longue).
En ce qui nous concerne, les programmes (ou scripts) que l'on crit en Perl sont excuts par un interprteur qui se nomme
perl.
6/61
partir de maintenant, nous ferons toujours rfrence au langage en crivant Perl avec un P majuscule, et
l'interprteur en crivant perl avec un p minuscule.
D'autres, parmi lesquels le crateur de Perl, Larry Wall, considrent que ce qui dfinit les langages de scripts est leur haut niveau
d'abstraction (c'est--dire qu'ils vitent au dveloppeur de grer manuellement des aspects rbarbatifs de la programmation, tels
que la gestion de la mmoire), et dont le but avou est d'tre simple utiliser afin que ce qui est possible devienne facile , et
que ce qui est difficile devienne possible .
Que peut-on programmer en Perl ?

Comme on l'a dit plus haut, bien que Perl ait initialement t conu pour tre un langage de scripts d'administration systme sous
UNIX (rle qu'il remplit encore trs bien aujourd'hui), il s'agit vritablement d'un langage gnraliste (y compris sous Windows),
et qui est employ sur des projets de toutes tailles, soit comme langage principal, soit, comme en atteste son surnom, la faon
d'un rouleau de scotch grce auquel on peut faire communiquer des programmes entre eux pour former de gros systmes.
videmment, l o il est le plus fort et le plus intressant, cela reste le traitement de fichiers et de donnes, mais grce ses
nombreux modules, Perl permet de produire trs rapidement des programmes capables de se connecter Internet, des sites et des
applications web ou des logiciels avec des interfaces graphiques ! titre d'exemples d'applications et de sites web connus qui
utilisent Perl aujourd'hui, on pourra citer BugZilla, Amazon.com ou encore IMDb.
La philosophie de Perl
Tous les langages de programmation s'articulent autour d'une philosophie de base qui les dfinit. Celle de Perl tient globalement
en une poigne de devises :
Do what I mean .
Perl est un langage rput pour accomplir la volont du programmeur plutt que d'excuter "btement" ce qu'on lui dit.
Cela signifie que le langage est assez intelligent pour comprendre, suivant le contexte, ce que l'on veut faire. Ainsi, pour
faire accomplir une tche donne Perl, on peut la plupart du temps se contenter de formuler les tapes principales de
l'algorithme : le langage est conu de manire excuter automatiquement la plupart des conversions et des micro-tches
que requiert chaque tape, que l'on serait oblig d'expliciter dans un langage de moins haut niveau d'abstraction tel que C
ou C++.
There is more than one way to do it .
En Perl, pour raliser une opration donne, ou rsoudre un problme, il existe toujours une multitude de solutions
diffrentes, plus ou moins videntes, plus ou moins explicites, plus ou moins lgantes, plus ou moins efficaces. Cela
signifie que lorsque l'on cherche coder rapidement quelque-chose et que l'on est habitu utiliser Perl, on se retrouve
rarement sans ressource, devoir rflchir pendant longtemps : il nous vient toujours au moins une solution directe pour
rsoudre le problme.
Things that are different should look different .
Il s'agit l de l'un des aspects de Perl sur lesquels on plaisante le plus souvent : un code-source crit en Perl a la
rputation d'tre moche regarder. Cela est d au choix du crateur de Perl de faire en sorte que les lments du langage
de natures ou de fonctions diffrentes soient facilement reconnaissables visuellement, en usant notamment de symboles
(les fameux sigils). En usant de ces symboles, le programmeur Perl peut exprimer avec trs peu de texte des instructions
compliques, et comprendre en un coup d'il ce quoi chaque mot fait rfrence.
Vous l'aurez compris : Perl est un langage orient pratique, qui est conu pour accomplir le boulot, quel qu'il soit, et quels que
soient les moyens employs. C'est un langage pragmatique, et c'est la raison pour laquelle il est autant affectionn par les
administrateurs systmes qui ont souvent besoin de raliser un script en 3 minutes montre en main pour accomplir et automatiser
une tche donne.
Enfin, on pourra noter que la communaut Perl n'est pas dnue d'humour. Le fait qu'il existe toujours plusieurs faons d'exprimer
la mme chose en Perl permet aux dveloppeurs qui pratiquent ce langage de raliser, pour s'amuser, les scripts les plus courts,
ou les moins lisibles dont ils soient capables (notamment des one-liners, ces programmes complets qui tiennent en une ligne) : il
s'agit d'une activit amusante et stimulante, qui demande souvent de rflchir la manire d'exprimer une instruction de la faon
la plus concise possible.
Perl 5 et Perl 6
7/61
Logo de Perl 5 ( gauche) et de Perl 6 ( droite)

Actuellement, il existe deux versions indpendantes de Perl, appeles trompeusement Perl 5 et Perl 6.
La version que l'on appelle Perl 5 est la cinquime version du Perl d'origine, dont le dveloppement est dirig par Larry Wall
en personne. Cette version de Perl existe et volue depuis 1994 : c'est le Perl d'aujourd'hui, la version qui est installe par dfaut
sur tous les systmes d'exploitation drivs d'UNIX, et qui est de trs loin la plus utilise dans le monde.
Paralllement, depuis quelques annes, un nouveau Perl est en cours de dveloppement, baptis Perl 6. Il s'agit d'un langage
diffrent qui partage seulement la philosophie de base et la syntaxe de Perl 5. Perl 6, l'heure o sont crites ces lignes, est
encore en cours de dveloppement, un stade exprimental. Cela signifie qu'il faudra encore attendre un moment avant d'obtenir
une version stable du langage, qui puisse tre utilise en production.
tant donn l'aspect pragmatique du langage, ce cours est bas sur Perl 5.
Quels outils faut-il pour programmer en Perl ?

Pour travailler avec Perl, vous allez avoir besoin de deux programmes : un interprteur Perl et un diteur de texte.
Sous Windows
Linterprteur Perl
Pour installer Perl sur votre machine, rendez vous sur http://strawberryperl.com/, puis cliquez sur la version qui correspond
votre ordinateur. Si vous ne savez pas laquelle prendre, choisissez la version "32-bit". Ensuite, contentez-vous de lancer
l'installeur que vous venez de tlcharger, et laissez-vous guider par les instructions qui s'affichent l'cran.
Perl est maintenant install sur votre machine.
Si ce n'est pas le cas, recherchez sur Google l'erreur qui apparat l'cran : il s'agit bien souvent de la mthode la plus rapide pour
solutionner un problme. Si, malgr tout, vous ne trouvez toujours pas, vous pouvez demander de l'aide sur les forums du Site
du Zro.
L'diteur de texte
Sous Windows, vous avez le fameux Bloc-notes install par dfaut. Il est assez simple d'utilisation. Le seul inconvnient est
qu'il ne gre pas la coloration syntaxique, c'est--dire le systme qui permet d'afficher du code en coloriant les mots selon leur
signification, et ainsi d'avoir une lecture plus aise du programme.
Pour pallier ce problme, il existe un diteur de texte trs pratique, nomm Notepad++ (n++ pour les intimes) qui supporte de
nombreuses options utiles pour les programmeurs, dont la coloration syntaxique.
8/61
Vous le trouverez cette adresse : http://notepad-plus-plus.org/fr.

Tlchargez-le, puis installez-le comme tout autre programme.
a y est, tout s'est bien pass ? Vous pouvez passer la partie "Excuter un script".
Sous GNU/Linux, Mac OS X, et autres UNIX

Sur les systmes d'exploitation compatibles POSIX, vous n'allez pas avoir besoin de chercher bien loin pour installer Perl : il est
dj sur votre machine !
Pour vous en convaincre, ouvrez un terminal puis tapez la commande suivante :
Code : Console
perl -v
Perl vous rpondra alors un petit texte du mme got que ceci :
Code : Console
This is perl 5, version 14, subversion 2 (v5.14.2) built for i686-linuxthread-multi
Copyright 1987-2011, Larry Wall
9/61
Perl may be copied only under the terms of either the Artistic License or the
GNU General Public License, which may be found in the Perl 5 source kit.
Complete documentation for Perl, including FAQ lists, should be found on
this system using "man perl" or "perldoc perl". If you have access to the
Internet, point your browser at http://www.perl.org/, the Perl Home Page.
Il est possible que votre version de Perl diffre de celle qui est affiche ici. Si c'est le cas, ne paniquez pas ! Du moment qu'il s'agit
de Perl 5.x, vous pourrez largement suivre l'intgralit de ce cours sans que cela ne pose le moindre problme.
Choix d'un diteur de texte

Sous GNU/Linux, en ce qui concerne les diteurs de texte ou les environnements de dveloppement pour travailler avec Perl,
vous avez l'embarras du choix, tous les diteurs grent la coloration syntaxique !
Citons, titre d'exemple gEdit et Geany, qui sont plutt adapts aux environnements Gnome et Unity, Kate, qui est, lui, plutt fait
pour KDE, ou encore, les incontournables et innarrables diteurs stars : Vim et Emacs, qui demanderont aux dbutants un temps
certain d'adaptation ainsi que de faire un choix cornlien (il faut choisir l'un ou l'autre), mais s'avreront tre, sur le long terme,
des outils de dveloppement complets, puissants, et irremplaables (ainsi qu'une source de troll intarissable).
Vim sous Ubuntu
Excuter un script
Maintenant que vous avez tous les outils ncessaires pour coder en Perl, nous allons enfin raliser notre premier programme !
Cration du programme
Ouvrez votre diteur prfr, puis crez un nouveau programme et enregistrez-le sous le nom de "helloworld.pl".
Code : Perl
use strict;
use warnings;
10/61
print "Hello, world!";

<>;
Il vous suffira, sous Windows, ensuite de double-cliquer sur l'icne du script afin de lancer celui-ci, ce qui devrait vous donner
un rsultat similaire ceci :
Facile, non ?
Lancer le programme en ligne de commande

Si vous travaillez sous UNIX, il y a des chances pour que vous fassiez partie de ces gens qui n'ont pas peur d'une simple ligne
de commande.
Pour ouvrir une console sous Windows, appuyez simultanment sur les touches Windows et R, puis tapez "cmd" dans le champ
qui apparat.
Pour excuter un script en ligne de commande, la faon la plus simple de faire est de lancer explicitement perl dans la console,
comme ceci :
Code : Console
perl /chemin/vers/votre/script/helloworld.pl
Sous Linux et UNIX uniquement : le shebang

Alternativement, sous les systmes compatibles UNIX, vous pouvez rajouter cette ligne (que l'on appelle un shebang) au tout
dbut de votre script (obligatoirement en premire ligne) :
Code : Perl
#!/usr/bin/env perl
11/61
Cette ligne vous permet d'excuter votre script sans avoir besoin d'appeler explicitement l'interprteur. Pour cela, il faut que vous
vous donniez les droits d'excution sur votre script, comme ceci :
Code : Console
cd /dossier/du/script
chmod +x helloworld.pl
./helloworld.pl
# Active les droits d'excution

# Lance le script
Pouah, mais c'est moche !
Il faudra vous y habituer, parce que nous travaillerons pendant trs longtemps en console comme ici. L'avantage de la console
est qu'elle permet d'apprendre les rudiments du langage sans nous pencher sur le ct graphique qui n'est pas encore votre
porte.
Vous savez maintenant qui ressemble Perl et comment vous en servir. Dans le prochain chapitre vous ferez vos tous premiers
pas avec ce langage !
12/61
Premiers pas
Il est temps maintenant de nous lancer dans l'apprentissage de Perl, et de crer nos premiers programmes.
Dans ce chapitre, nous allons apprendre beaucoup de choses fondamentales ! En particulier nous allons dcouvrir :
Ce qu'est une fonction, un argument, une variable ;
La faon dont Perl reprsente les donnes ;
Une manire de rcuprer la saisie de l'utilisateur au clavier ;
Ce qui diffrencie Perl de la plupart des autres langages de programmation.
Soyez donc trs attentifs, car c'est ici que tout va se jouer.
Hello, world!
Depuis toujours, la coutume veut que lorsque l'on apprend un nouveau langage de programmation, le premier programme que
l'on crive ne fasse qu'une chose trs simple : dire bonjour au nouveau monde qui s'ouvre nous. Nous n'allons bien
videmment pas droger la rgle.
Ouvrez votre diteur de texte, et tapez le programme suivant :
Code : Perl
use strict;
use warnings;
<>;
Sauvegardez ce fichier en lui donnant le nom helloworld.pl.

Lorsque vous excutez ce programme, le texte Hello, world! devrait apparatre dans la console. Appuyez sur la touche
Entre pour quitter le programme.
Premiers lments de langage

Le programme que nous venons d'crire comporte quatre instructions qui se terminent chacune par un point-virgule et que perl
a excutes l'une aprs l'autre.
Les deux premires instructions que nous avons crites sont use strict; et use warnings;. Pour dire les choses
simplement, elles servent rendre Perl moins permissif, ce qui nous sera extrmement utile pour dtecter rapidement de
nombreuses erreurs dans le code (comme, par exemple, le fait d'oublier le point virgule la fin d'une instruction). Ces deux
instructions figureront en prambule de tous les programmes que nous crirons dans ce cours.
La troisime instruction que nous avons crite est de loin la plus intressante : il s'agit du cur du programme lui-mme.
Code : Perl
Une instruction est un ordre

Tout d'abord, il nous faut remarquer que chaque instruction que vous crirez en Perl est un ordre qui est donn la machine. En
effet, les trois instructions que nous avons crites jusqu'ici sont construites de la mme faon qu'une phrase dcrivant un ordre
dans un langage naturel comme le franais ou l'anglais :
13/61
VERBE COMPLMENTS,
o le VERBE est conjugu l'impratif, comme dans l'injonction fais tes devoirs ! . En Perl, nous n'allons pas parler d'un
VERBE, mais plutt d'une fonction. Dans notre exemple, il s'agit de la fonction print, qui signifie afficher en anglais, et sert ici
crire du texte l'cran. De la mme faon qu'un VERBE accepte un ou plusieurs COMPLMENTS, on dit que les fonctions en
Perl acceptent un ou plusieurs arguments. Ici, l'argument que nous avons pass la fonction print est le texte "Hello,
world!".
Remarquez qu'en Perl, les instructions suivantes sont strictement quivalentes :
Code : Perl
Code : Perl
print
"Hello, world!"
Code : Perl
print("Hello, world!");
Code : Perl
print
"Hello, world!"
;
Comme vous le voyez, Perl est trs tolrant sur la faon dont il lit les instructions que vous lui donnez. Nanmoins, dans ce
cours, nous allons faire l'effort de toujours prsenter nos programmes de faon claire et cohrente, pour les rendre le plus simple
possible lire et corriger. C'est une habitude vitale, lorsque l'on code !
Mettre le programme en pause

Tout la fin de notre script, nous avons rajout une dernire ligne un petit peu particulire :
Code : Perl
<>;
Cette ligne, qui n'est pas indispensable au fonctionnement du programme, sert simplement ici marquer une pause dans
l'excution de votre script, jusqu' ce que l'utilisateur appuie sur la touche Entre.
Ceci est trs pratique sous Windows si vous dcidez d'excuter votre script en double-cliquant sur le fichier. En effet, sans elle,
vous n'auriez pas le temps de lire le contenu de la console qui apparat : celle-ci se ferme aussitt l'excution termine. En
revanche, si vous travaillez sous Linux, il y a des chances que cette ligne soit inutile. A fortiori si, comme l'auteur de ce chapitre,
vous prenez l'habitude d'excuter vos scripts dans la console, en appelant perl en ligne de commande, ce comportement peut
mme s'avrer contre-intuitif et gnant.
De faon ne pas surcharger nos scripts dans toute la suite de ce cours, nous ne ferons pas systmatiquement figurer
14/61
cette ligne dans les codes suivants. Ce sera donc vous de l'ajouter le cas chant, selon votre faon de travailler.
Les commentaires
Une autre bonne habitude prendre est celle de placer des commentaires dans nos programmes, de faon expliquer ce qui s'y
passe. En Perl, les commentaires sont introduits par un dise (#), et se poursuivent jusqu' la fin de la ligne.
Voici par exemple notre premier programme, agrment de quelques commentaires :
Code : Perl
# Ces instructions rendent Perl moins permissif
use strict;
use warnings;
print "Hello, World!"; # Affiche "Hello, World!" dans la console
<>; # Met le programme en pause jusqu' ce que l'utilisateur appuie
# sur la touche "Entre"
Avant de passer la suite, vous pouvez vous amuser modifier ce script afin qu'il affiche autre chose que "Hello, World!" dans
la console, par exemple. En particulier, vous pouvez chercher faire planter ce script !
En effet, c'est en dcouvrant par vous-mmes tout ce qui est susceptible de dclencher des erreurs que vous retiendrez la
syntaxe de Perl.
la dcouverte des variables

Nous allons maintenant tudier un nouveau script. crivez le programme suivant dans un nouveau fichier et excutez-le :
Code : Perl
use strict;
use warnings;
my $nom = "Perl";
print "$nom c'est coolympique !";
Voici ce que cela va donner dans la console :

Code : Console
Perl c'est coolympique !
Remarquez que la ligne 4 prsente bon nombre d'lments nouveaux. Afin de mieux examiner ce qui s'y passe, dcomposons
cette ligne en deux instructions :
Code : Perl
my $nom;
$nom = "Perl";
Nous allons analyser ces deux lignes en dtail.
15/61
Le mot-cl "my"
La premire nouveaut que nous avons croise dans ce script est l'utilisation du mot-cl my (le possessif mon en anglais). Ce
mot-cl sert dclarer une variable, c'est--dire, intuitivement, crer une bote vide, sur laquelle on colle une tiquette pour
dcrire ce qu'elle va contenir. Ici, nous avons appel notre variable $nom, mais nous aurions tout aussi bien pu l'appeler
$Jean_Pierre, $choucroute ou $KevinDu35. Les variables sont simplement des conteneurs , des rcipients dans
lesquels on peut mettre des objets, nous sommes donc libres de coller sur ces rcipients les tiquettes que l'on veut !
Enfin presque : il y a quand mme deux rgles simples suivre pour nommer nos variables.
D'abord, les noms de variables commencent tous par un symbole spcial ; ici le "dollar" : $. Ce symbole, que l'on appelle un
sigil , a une signification trs prcise en Perl, que nous tudierons beaucoup plus loin dans ce cours. Pour l'heure, nous allons
commencer par utiliser uniquement des "variables dollar", qui portent le nom de scalaires (scalar en anglais).
La deuxime rgle respecter, c'est que les noms des variables doivent se composer uniquement de caractres alpha-numriques
(c'est--dire de chiffres et de lettres), majuscules ou minuscules, ou d'underscores (_), sans espace.
En Perl, lorsque vous utilisez le pragma strict (avec use strict;), vous devez dclarer vos nouvelles variables avec le
mot-cl my avant de les utiliser. Bien que cela semble contraignant, vous vous rendrez trs vite compte qu'il s'agit d'un moyen de
dtecter certaines erreurs d'inattention btes et mchantes, comme une faute de frappe dans le nom d'une variable, par exemple.
Affecter une valeur une variable

Pour placer une valeur dans une variable, on utilise l'oprateur = comme dans la ligne suivante :
Code : Perl
$nom = "Perl"; # J'affecte la valeur "Perl" la variable $nom.
Ainsi, notre variable $nom contient maintenant la valeur "Perl". Chaque fois que vous utiliserez cette variable $nom dans
votre script, celle-ci sera remplace par la valeur "Perl" jusqu' ce que vous lui affectiez une nouvelle valeur.
C'est en particulier ce qu'il s'est pass la ligne suivante :
Code : Perl
print "$nom c'est coolympique !";
Lorsqu'il a interprt cette ligne, perl a remplac $nom par la valeur "Perl" dans la chane "$nom c'est coolympique
!", afin de former une nouvelle chane de caractres : "Perl c'est coolympique !". On appelle ce phnomne
l'interpolation ; nous allons y revenir dans quelques instants.
Exercice
Avant de poursuivre ce chapitre et d'tudier les scalaires en dtail, essayez de deviner ce que les codes suivants vont afficher
dans la console :
Code : Perl
my $a = "Bonjour";
my $b = "madame";
print "$a, $b.";
16/61
Code : Perl
my $age = 13;
print "PS : j'ai $age ans.";
Code : Perl
my $a = 3;
my $b = 2;
my $somme = $a + $b;
print "$a + $b = $somme";
Les scalaires
Comme nous l'avons vu plus haut, les variables qui commencent par le sigil $ sont appeles en Perl des scalaires. Cette notion
de scalaire est l'une de celles qui font de Perl un langage trs pratique utiliser, puisqu'elle dcoule directement de l'une des
devises de la philosophie de Perl : Do what I mean .
Notion de typage
Le typage est une notion que l'on retrouve dans tous les langages de programmation. Bien qu'elle puisse s'exprimer de plein de
faons diffrentes, elle reflte toujours cette mme vrit simple et profonde : on ne mlange pas les torchons et les serviettes !
En programmation, ce dicton signifie simplement que les donnes que l'on manipule ont un type, et que l'on ne peut pas faire
n'importe quoi avec n'importe quelle donne de n'importe quel type. Au travers des exemples de code que nous avons examins
jusqu' prsent, vous avez rencontr sans le savoir deux types de donnes diffrents : les chanes de caractres (comme
"hello") et les nombres entiers (comme 42).
Vous viendrait-il l'esprit de calculer la somme de "hello" et de 42 ? Cela n'aurait aucun sens, n'est-ce pas ?
Tenez, soyons fous, et essayons quand mme pour voir ce qu'en dit Perl :
Code : Perl
use strict;
use warnings;
my $a = "hello";
my $b = 42;
my $somme = $a + $b;
print "Resultat: $somme";
Voici ce qu'il nous rpond :

Code : Console
Argument "hello" isn't numeric in addition (+) at test.pl line 6.
Resultat: 42
La premire ligne de la rponse de perl est ce que l'on appelle un warning : perl vous dit grosso-modo que vous venez de lui
demander de faire quelque-chose qu'il a du mal comprendre, savoir ajouter 42 une valeur non numrique. Il vous prcise
d'ailleurs que c'est la ligne 6 que cela se passe. Comme vous le voyez, perl rpugne mlanger les torchons et les serviettes.
Cela dit, vous remarquerez qu'il affiche quand mme sur la deuxime ligne le rsultat du programme, ce qui signifie qu'il a quand
mme ralis le calcul en considrant que la valeur qu'il ne comprenait pas ("hello") valait 0. Voil qui est trange : dans
pratiquement n'importe quel autre langage de programmation, ce script aurait plant !
17/61
Cet exemple illustre ce que l'on appelle la force du typage. Lorsqu'un langage est fortement typ, il dclenche des erreurs chaque
fois que vous tentez de raliser une opration avec des donnes du mauvais type, ou de types incompatibles entre eux.
l'inverse, lorsque le typage est faible, le langage se montre plus conciliant, et essaye de vous fournir un rsultat. On dira donc
que Perl est un langage faiblement typ. En ralit, Perl regroupe des donnes de natures diffrentes sous un mme type : les
scalaires.
Nous allons ici examiner les types les plus importants : les nombres et les chanes de caractres. Nous en dcouvrirons d'autres
au fur et mesure que nous avancerons dans les chapitres de ce cours.
Les nombres
Les donnes les plus simples que l'on puisse traiter en programmation sont probablement les nombres. En toute rigueur, on peut
distinguer au moins deux types de nombres : les nombres entiers et les nombres dcimaux (ou, vulgairement, nombres
virgule ). Bien que l'interprteur perl sache faire la diffrence entre les deux dans son fonctionnement interne, celle-ci n'est que
trs peu marque dans le langage, comme en atteste le script suivant :
Code : Perl
use strict;
use warnings;
my
my
my
my
my
my
$a = 4;
$b = 5.5;
$somme
$difference
$produit
$quotient
print "$a
$a - $b =
$a * $b =
$a / $b =
=
=
=
=
$a
$a
$a
$a
+
*
/
$b;
$b;
$b;
$b;
#
#
#
#
addition
soustraction
multiplication
division
+ $b = $somme
$difference
$produit
$quotient";
Voici le rsultat :
Code : Console
4
4
4
4
+
*
/
5.5
5.5
5.5
5.5
=
=
=
=
9.5
-1.5
22
0.727272727272727
Pour peu que vous ayez dj utilis une calculatrice dans votre vie, ce code ne devrait vous poser aucun problme.
On pourra noter aussi l'oprateur d'exponentiation **, qui sert exprimer une puissance :
Code : Perl
my $quatre_au_carre = 4 ** 2
# 16
my $racine_de_quatre = 4 ** (1/2) # 2
Il existe encore beaucoup (beaucoup, beaucoup) d'autres oprateurs que l'on peut utiliser sur des nombres en Perl, mais il ne
serait pas judicieux de vous les prsenter ds maintenant. Nous nous contenterons pour l'instant de ceux que nous venons de
voir, et gardons la dcouverte des autres pour plus tard. Si vous tes curieux, vous pouvez toujours consulter la page "perlop"
(en anglais) de la documentation de Perl, sur laquelle vous les trouverez tous. Gare l'indigestion !
18/61
Ce qu'il faut retenir, c'est que Perl peut manipuler des nombres, que les nombres sont des scalaires, et que l'on n'a pas besoin de
traiter diffremment les nombres entiers et les nombres dcimaux : la plupart du temps, on se moque compltement de la
diffrence, et a, Perl l'a bien compris !
Les chanes de caractres

Les chanes de caractres sont probablement le type le plus important en Perl. En effet, Perl est dlicieusement pratique pour
manipuler du texte de faon simple et intuitive. C'est d'ailleurs sans conteste LE langage de programmation le plus dou pour a,
tel point que de nombreux autres langages, comme PHP et Ruby, s'inspirent librement de ce savoir-faire.
Plusieurs faons d'crire une chane

Jusqu'ici, nous avons toujours prsent nos chanes de caractres de la mme faon, c'est--dire en les entourant de guillemets
doubles (ou double-quotes), comme ceci :
Code : Perl
my $chaine = "Je suis une chaine de caractres";
Mais que faire si nous voulons afficher une chane qui contient des guillemets ?
Nous avons pour cela au moins deux solutions. La premire, c'est d'chapper les guillemets au moyen d'un antislash (\), comme
ceci :
Code : Perl
my $chaine = "\"Cessons ce marivaudage !\", dit le marquis.";
print $chaine;
Ce qui donne en console :

Code : Console
"Cessons ce marivaudage !", dit le marquis.
La seconde solution, c'est d'utiliser une reprsentation alternative pour notre chane, en l'entourant de guillemets simples :
Code : Perl
my $chaine = '"Cessons ce marivaudage !", dit le marquis.';
Nous allons maintenant nous attarder un petit peu sur ce qu'impliquent ces deux solutions.
Les caractres chapps et les caractres spciaux

Nous venons de voir qu'au moyen d'un antislash, il tait possible d'chapper des guillemets. Cette pratique est trs courante en
programmation, et permet non seulement d'viter des confusions, mais aussi de reprsenter des caractres invisibles, comme les
passages la ligne ("\n") ou les tabulations ("\t") :
Code : Python
19/61
print "Ceci est un passage a la ligne : \nTadaaa!\n\n";

print "Les\ttabulations\tsont\tpratiques\n";
print "pour\taligner\t\tdu\ttexte.";
Jugez par vous-mmes :

Code : Console
Ceci est un passage a la ligne :
Tadaaa!
Les
pour
tabulations
aligner
sont
du
pratiques
texte.
Mais alors, si l'antislash permet d'chapper des caractres spciaux, comment diable pourrais-je afficher un antislash ? vous
demandez-vous certainement. Eh bien, en l'chappant lui-mme, tout simplement :
Code : Perl
print "Ceci est un antislash : \\";
Code : Console
Ceci est un antislash : \
Comme pour les oprateurs mathmatiques, il existe de trs nombreux caractres spciaux en Perl, et, l aussi, il serait inutile de
vous en dresser une liste complte que vous ne sauriez retenir. Nous nous contenterons donc, cette fois encore, de les dcouvrir
au fur et mesure que nous en aurons besoin dans ce cours, par la pratique.
Interpolation et guillemets simples

Depuis le dbut de ce chapitre, nous utilisons l'interpolation pour crire le contenu de nos variables dans des chanes de
caractres. Il est important de noter, ce sujet, que les chanes dlimites par des guillemets simples ne se comportent
absolument pas de la mme faon que les autres. Regardez :
Code : Perl
my $un_fruit = "une pomme";
print "Hier, j'ai mang $un_fruit.\n";
print 'Hier, j\'ai mang $un_fruit.\n';
Code : Console
Hier, j'ai mang une pomme.
Hier, j'ai mang $un_fruit.\n
Comme vous le constatez, dans la seconde chane, la variable $un_fruit n'a pas t remplace par sa valeur, et le caractre
20/61
spcial "\n" n'a pas t remplac par un retour la ligne. Par contre, l'apostrophe a bien t chappe, elle.
Ainsi, le choix d'utiliser des guillemets simples ou doubles pour dlimiter les chanes de caractres en Perl n'est pas qu'une simple
affaire de got : cela dpend avant tout du fait de vouloir que les variables et les caractres spciaux soient interpols ou non.
Oprations sur les chanes de caractres

Comme on vient de le dire, Perl permet de raliser beaucoup d'oprations diffrentes sur les chanes de caractres. Dcouvronsen quelques unes ensemble.
Longueur d'une chane

La longueur d'une chane de caractres, c'est tout simplement le nombre de caractres qu'elle contient. Celle-ci peut tre
dtermine au moyen de la fonction length (qui signifie longueur , en anglais).
Code : Perl
my $chaine = "coolympique";
my $longueur = length $chaine;
print "La chaine '$chaine' contient $longueur caracteres.";
Code : Console
La chaine 'coolympique' contient 11 caracteres.
Rptition et concatnation
C'est un fait tabli et connu de longue date : les programmeurs sont des gens flemmards qui n'aiment pas se rpter. Aussi, ils
prfrent laisser leurs ordinateurs rpter les choses leur place. C'est pourquoi Perl possde un oprateur nomm x (comme la
lettre "x"), qui sert rpter une chane un certain nombre de fois. Regardez :
Code : Perl
print "bla" x 10;
Code : Console
blablablablablablablablablabla
Remarquez que cet oprateur n'est pas du tout le mme que celui qui sert multiplier deux nombres : c'est un dtail qui a son
importance !
Un autre oprateur utile est celui de concatnation, que l'on symbolise par un point (.). Concatner deux chanes de caractres
signifie les coller bout bout, comme ceci :
Code : Perl
my $chaine = 'cool' . 'ympique';
print $chaine;
21/61
Code : Console
coolympique
Enfin, il est bien sr possible de combiner ces deux oprateurs, comme cela :
Code : Perl
print 'tro' . 'lo' x 4;
Code : Console
trololololo
Do what I mean!
Maintenant que nous avons vu diverses manires de manipuler des scalaires, nous allons pouvoir nous pencher sur ce qui fait
tout leur intrt, savoir le principe do what I mean , qui est la fois une spcificit et l'une des plus grandes forces de Perl.
Cette devise signifie fais ce que je veux ! , par opposition fais ce que je dis ! . Avec les scalaires, elle se traduit par le fait
que Perl comprendra toujours (non, vraiment, TOUJOURS !) ce que vous avez l'intention de faire, sans que vous ayez besoin de
le lui dire explicitement.
Dmonstration, ouvrez grand vos mirettes :
Code : Perl
use strict;
use warnings;
my
my
my
my
my
my
$quatre = "4";
$deux = "2";
$quatre_et_deux
$quatre_plus_deux
$quatre_x_deux
$quatre_fois_deux
print
print
print
print
=
=
=
=
$quatre
$quatre
$quatre
$quatre
.
+
x
*
$deux;
$deux;
$deux;
$deux;
#
#
#
#
concatnation
addition
rptition
multiplication
'$quatre_et_deux = ' . "$quatre_et_deux\n";

'$quatre_plus_deux = ' . "$quatre_plus_deux\n";
'$quatre_x_deux = ' . "$quatre_x_deux\n";
'$quatre_fois_deux = ' . "$quatre_fois_deux\n";
Code : Console
$quatre_et_deux
$quatre_plus_deux
$quatre_x_deux
$quatre_fois_deux
=
=
=
=
42
6
44
8
Remarquez que les variables $quatre et $deux, telles que nous les avons dfinies, sont censes tre des chanes de
caractres. Pour autant, nous avons pu aussi bien les additionner et les multiplier entre elles comme deux nombres que les
22/61
concatner et les utiliser avec l'oprateur de rptition comme les chanes de caractres qu'elles sont ; Perl n'a absolument pas
bronch !
Ceci est d au fait que les oprateurs de Perl sont trs spcifiques. En utilisant l'oprateur +, on sait trs bien ce que l'on
demande Perl : on lui demande d'additionner deux nombres. Et pourtant, les deux valeurs que nous lui avons donnes taient
des chanes de caractres reprsentant des nombres. Qu' cela ne tienne, au lieu de faire ce que nous lui avons dit, c'est--dire
essayer d'appliquer une addition deux chanes (ce qui aurait immanquablement plant dans pratiquement n'importe quel
langage de programmation), Perl a fait ce que nous avions l'intention de faire : il a pris les devants, converti nos deux chanes en
nombres, et en a calcul la somme.
Il est trs important de noter que ceci est rendu possible par le fait que Perl donne un sens plus fort aux oprateurs qu'aux types
des variables qu'il manipule. C'est l'opration que l'on utilise, ou plutt, le contexte dans lequel on utilise les donnes, qui
dtermine leur type, et non l'inverse. Trs peu de langages traitent leurs donnes de cette faon, et Perl est le seul le faire
parfaitement bien (c'est--dire sans jamais provoquer de mauvaise surprise pour l'utilisateur, comme c'est parfois le cas de PHP).
Les autres langages cousins de Perl, comme par exemple Python, suivent en gnral la logique inverse : dans ces langages, c'est
le type des donnes qui est le plus important, et qui dcide de la signification des oprateurs.
Comprendre cette diffrence est fondamental pour bien programmer en Perl. C'est souvent cause d'elle que naissent des
disputes sans fin entre les partisans des langages fortement typs comme Python, et des langages faiblement typs comme Perl.
La vrit ce sujet, c'est que ni les uns, ni les autres n'ont raison. Ce qui importe n'est pas la force ni les caractristiques du
typage ; c'est avant tout que celui-ci s'inscrive dans une philosophie claire et cohrente. ce titre, Python et Perl sont deux
langages de grande qualit : chacun est fermement ancr dans une philosophie qui lui est propre et laquelle il adhre jusque
dans ses moindres dtails. Le reste n'est vritablement qu'une question de confort et d'habitude.
Place la pratique !
On vous l'a dit, Perl est un langage conu pour tre pratiqu. Son intrt rside dans le fait que plus vous l'utiliserez, plus vous
trouverez en lui un outil commode et puissant. C'est pour cette raison que ce cours va contenir autant de thorie que d'exercices
et de TP.
En ce qui nous concerne sur ce chapitre, il vous manque encore une toute petite notion acqurir avant que vous puissiez crire
des programmes qui font quelque chose, et avec lesquels vous pourrez frimer devant les filles : la possibilit de leur donner un
peu d'interactivit. Dans ce cours, ou du moins les chapitres qui viennent, celle-ci va passer par une petite instruction que nous
avons rencontre au tout dbut de ce chapitre, et qui ressemble une espce de diamant : <>.
Diamonds are a girl's best friend

Essayez le code suivant :
Code : Perl
use strict;
use warnings;
print "Comment vous appelez-vous ? ";
my $nom = <>; # Rcupration du nom de l'utilisateur
chomp $nom;
# Retrait du saut de ligne
print "Bonjour, $nom !\n";
Ce programme attend que vous entriez votre nom avant de vous dire bonjour. Voici un exemple d'excution :
Code : Console
Comment vous appelez-vous ? Obi-Wan Kenobi
Bonjour, Obi-Wan Kenobi !
La vritable signification de l'oprateur <>
23/61
Vous l'avez srement devin, ce petit diamant ne fait pas que mettre le script en pause le temps d'appuyer sur Entre, il sert aussi
rcuprer ce que l'utilisateur a entr au clavier.
En fait, la vrit est encore plus vaste que cela. Le symbole <> est un lment de syntaxe servant lire une ligne dans un flux
de donnes. Tel quel, il s'agit d'un raccourcis pour lire une ligne sur l'entre standard du programme, ce qui devrait normalement
s'crire <STDIN> (essayez, et vous verrez que le programme ne changera pas de comportement).
Nous aurons l'occasion de revenir sur ce sujet (les flux de donnes et les entres/sorties standards) plusieurs reprises dans ce
cours. Pour l'heure, retenez donc que ce petit diamant sert lire une ligne que l'utilisateur peut saisir au clavier.
Chomp, chomp, chomp...

Derrire ce nom amusant se trouve une petite fonction trs pratique, qui sert retirer les sauts de ligne la fin d'une chane de
caractres. En effet, lorsque l'utilisateur saisit une donne au clavier, il valide celle-ci en appuyant sur la touche Entre. Cela
explique la prsence d'un passage la ligne la fin de la chane de caractres que l'on rcupre. Cette fonction sert simplement
purer la saisie de l'utilisateur, de faon ne rcuprer que le texte.
Pour rendre ces explications plus claires, regardez ce qui se passerait si l'on ne chomp-ait pas l'entre de l'utilisateur :
Code : Perl
use strict;
use warnings;
print "Comment vous appelez-vous ? ";
my $nom = <>;
# chomp $nom;
print "Bonjour, $nom !";
Code : Console
Comment vous appelez-vous ? Raoul
Bonjour, Raoul
!
Vous voyez ?
Ainsi donc, repensez simplement cette citation de Jean de LOLafontaine chaque fois que vous voudrez saisir une entre de
l'utilisateur : Ah, vous m'coutiez ? Eh bien chomp-ez maintenant ! .
vos claviers !
Il est maintenant temps pour vous de sortir vos mains de vos poches et de coder. Voici une petite srie d'exercices qui va vous
permettre d'appliquer tout ce que nous venons d'apprendre.
iPunish
Commenons par crer une petite application tendance et extrmement pratique, destine crire vos punitions votre place.
Imaginez que vous ayez copier 500 fois la phrase Je ne dois pas bavarder en classe. . Quelle galre ! Tout ce temps perdu
alors que vous pourriez l'employer ne rien faire Grce iPunish, cette poque est maintenant rvolue !
Entrez simplement une phrase et le nombre de fois que vous voulez la recopier, et iPunish fera le travail votre place, tout cela
dans le raffinement et l'lgance d'une interface en ligne de commande.
Regardez :
24/61
Code : Console
arnaud@netbook(~)% perl iPunish.pl
Entrez une phrase : Je ne recopierai plus mes punitions a la main.
Combien de copies ? 10
-----------------------------Je ne recopierai plus mes punitions a la main.
Je ne recopierai plus mes punitions a la main.
Tout ce dont vous avez besoin pour raliser cet exercice a t abord dans ce chapitre, vous devriez donc tre capables d'y
arriver seuls.
Correction :
Secret (cliquez pour afficher)
Code : Perl - iPunish.pl
use strict;
use warnings;
# Rcupration de la phrase
# On ne la chompe pas, pour conserver le retour la ligne
print "Entrez une phrase : ";
my $phrase = <>;
# Rcupration du nombre de copies
print "Combien de copies ? ";
my $nb = <>;
chomp $nb;
# On affiche une jolie ligne pour sparer le rsultat
# de la saisie
print '-' x 30 . "\n";
# Puis on recopie la phrase $nb fois
print $phrase x $nb;
# <>; # Pause de l'excution sous Windows
Table de multiplication
crivez un script qui demande un nombre l'utilisateur et rcite sa table de multiplication comme ceci :
Code : Console
Entrez un nombre: 7
7 x 1 = 7
7 x 2 = 14
7 x 3 = 21
7 x 4 = 28

7
7
7
7
7
7
x
x
x
x
x
x
25/61
5 = 35
6 = 42
7 = 49
8 = 56
9 = 63
10 = 70
Vous allez vous apercevoir que ce code est trs rptitif crire. Dans un prochain chapitre, nous dcouvrirons un (et mme
plusieurs) moyen(s) de le rendre beaucoup plus concis.
Correction :
Code : Perl
use strict;
use warnings;
print "Entrez un nombre: ";
my $nb = <>;
chomp $nb;
print
print
print
print
print
print
print
print
print
print
"$nb
"$nb
"$nb
"$nb
"$nb
"$nb
"$nb
"$nb
"$nb
"$nb
x
x
x
x
x
x
x
x
x
x
1 = " . $nb * 1 .
2 = " . $nb * 2 .
3 = " . $nb * 3 .
4 = " . $nb * 4 .
5 = " . $nb * 5 .
6 = " . $nb * 6 .
7 = " . $nb * 7 .
8 = " . $nb * 8 .
9 = " . $nb * 9 .
10 = " . $nb * 10
"\n";
"\n";
"\n";
"\n";
"\n";
"\n";
"\n";
"\n";
"\n";
. "\n";
Nous en avons termin avec ce premier chapitre. Il est temps pour nous de rsumer l'essentiel que vous devez en retenir :
Un programme en Perl se prsente comme une srie d'instructions, servant manipuler des donnes.
Les instructions, en programmation, sont des ordres que l'on donne la machine.
Les donnes, dans l'ordinateur, ont des types diffrents.
Perl est un langage faiblement typ. Cela signifie qu'il est plutt tolrant si vous vous trompez de type.
Ceci est d au fait que Perl regroupe les types de donnes les plus lmentaires (nombres et chanes de caractres) sous
la notion de scalaire.
En Perl, c'est le contexte qui dcide du type des donnes qui sont manipules et non l'inverse.
Il est possible que vous vous sentiez un petit peu assomm sous la quantit d'informations que vous venez d'emmagasiner.
Prenez donc le temps de les digrer avant de passer la suite.
Si vous avez bien suivi ce chapitre, les suivants devraient vous sembler beaucoup plus lgers !
26/61
Les branchements conditionnels

Maintenant que nous avons appris les lments de base du langage Perl, nous allons pouvoir, ds prsent, et ce jusqu' la fin
de cette premire partie du cours, dcouvrir des mcanismes qui vont nous permettre d'crire des scripts de plus en plus
sophistiqus.
Dans ce chapitre, nous allons rendre nos scripts capables de prendre des dcisions. Nous dcouvrirons cette occasion :
les scalaires permettant de manipuler des propositions logiques,
diffrentes faons de reprsenter une condition,
la notion de bloc de code,
la notion de porte d'une variable.
Prdicats et boolens
Posons le contexte
Imaginons un programme dont l'excution ressemblerait ceci :
Code : Console
arnaud@netbook(perl)% perl password.pl
Entrez le mot de passe : ssame ouvre-toi
Accs refus.
Allez vous faire voir !
arnaud@netbook(perl)% perl password.pl
Entrez le mot de passe : s'il te plait
Accs autoris.
Bienvenue.
Il est vident que nous ne connaissons pas encore assez de Perl pour crire un tel programme ( juste titre, puisque c'est l'objet
de ce chapitre) mais avant de plonger le nez dans du code, essayons dj de comprendre ce qui se passe.
Nous avons excut le mme programme deux fois. Lors de la premire excution :
Le programme demande l'utilisateur de rentrer le mot de passe
L'utilisateur entre le mot de passe : "ssame ouvre-toi"
Ce n'est pas le bon mot de passe
Le programme envoie balader l'utilisateur
Lors de la seconde excution :
Le programme demande l'utilisateur de rentrer le mot de passe
L'utilisateur entre le mot de passe : "s'il te plait"
C'est le bon mot de passe
Le programme accueille l'utilisateur
Nous voyons bien que le mot de passe entr par l'utilisateur conditionne le reste de l'excution du programme : deux chemins
sont possibles, ici symboliss par la couleur du texte (rouge ou vert). Puisque nous avons sous les yeux tous les cas d'excution
possibles, nous pouvons en dduire la structure logique du programme :
Le programme demande l'utilisateur d'entrer son mot de passe
L'utilisateur entre un mot de passe
SI le mot de passe est "s'il te plait"
SINON
27/61
Ceci met en vidence deux notions compltement nouvelles pour nous. La premire, c'est bien videmment cette structure
SI SINON . On appelle cette structure un branchement conditionnel, et nous verrons un petit peu plus loin comment
cela se traduit en Perl.
La seconde, que nous allons tudier tout de suite, c'est cette phrase colorie en bleu : le mot de passe est "s'il te plait". En effet,
cette phrase n'est pas un ordre puisqu'elle n'exprime pas une action ; il s'agit d'une proposition qui peut tre soit vraie, soit
fausse. Une telle proposition s'appelle un prdicat.
Les boolens
Comme on vient de le dire, un prdicat est une proposition qui peut tre vraie ou fausse. La premire chose que nous devrions
chercher savoir serait donc comment reprsenter le vrai ou le faux en programmation. En ralit, il n'y a rien de plus
simple. Perl utilise pour cela les boolens.
Un boolen, en thorie, ce n'est rien d'autre qu'un objet qui peut prendre uniquement deux valeurs : vrai ou faux. Ce qu'il est
important de remarquer en revanche, c'est qu'en Perl, les boolens ne sont pas un "type" proprement parler. Il s'agit plutt d'un
contexte dans lequel on value les valeurs scalaires.
Ainsi, le nombre 0 en Perl est valu comme tant faux, alors que toutes les autres valeurs numriques diffrentes de 0 sont
values comme vraies. De mme, toutes les chanes de caractres sont values comme vraies, hormis la chane vide (""), ainsi
que la chane "0".
Il existe enfin une valeur spciale, undef, qui est value comme tant fausse, mais nous en reparlerons plus tard.
Oprateurs de comparaison
Il est temps pour nous maintenant d'exprimer nos premiers prdicats.
Comparaison de nombres
C'est ici que le discours de ce dbut de chapitre va certainement avoir l'air compliqu pour pas grand chose. En effet, le terme
prdicat , que vous ne connaissiez peut-tre pas, semble bien pompeux, quand on sait que vous en avez certainement dj
rencontr. Tenez, voici quelques exemples prdicats impliquant des comparaisons de nombres :
4 est suprieur 3.
3 est suprieur 4.
10 est infrieur 2.
2 est infrieur ou gal 10.
16 est gal 16.
16 est diffrent de 2.
15 est suprieur ou gal 16.
15 est suprieur ou gal 15.
(vrai)
(faux)
(faux)
(vrai)
(vrai)
(vrai)
(faux)
(vrai)
Vous voyez ? Ce n'est vraiment pas sorcier ! Voici les oprateurs de Perl qui vont nous permettre d'exprimer ces prdicats :
Expression Perl
Prdicat
$a < $b
$a est infrieur $b
$a > $b
$a est suprieur $b
$a == $b
$a est gal $b
$a != $b
$a est diffrent de $b
$a <= $b
$a est infrieur ou gal $b
$a >= $b
$a est suprieur ou gal $b
Voyons un peu ce que cela donne dans un script. Vous remarquerez que pour pouvoir afficher correctement les valeurs
boolennes, nous sommes obligs de les convertir explicitement en nombres entiers, au moyen de la fonction int. Ainsi, ce
code affichera 1 devant les propositions vraies, et 0 pour les fausses. C'est la faon la plus simple dont on puisse reprsenter un
28/61
boolen.
Code : Perl
use strict;
use warnings;
my $a = 2;
my $b = 4;
# La fonction "int" permet de convertir explicitement un scalaire
# en un nombre entier.
print
print
print
print
print
print
print
print
"$a
"$a
"$a
"$a
"$a
"$a
"$a
"$a
< $b : " . int ($a < $b) .

> $b : " . int ($a > $b) .
== $b : " . int ($a == $b)
== $a : " . int ($a == $a)
!= $b : " . int ($a != $b)
!= $a : " . int ($a != $a)
<= $b : " . int ($a <= $b)
<= $a : " . int ($a <= $a)
"\n";
"\n";
. "\n";
. "\n";
. "\n";
. "\n";
. "\n";
. "\n";
Code : Console
2
2
2
2
2
2
2
2
< 4
> 4
== 4
== 2
!= 4
!= 2
<= 4
<= 2
:
:
:
:
:
:
:
:
1
0
0
1
1
0
1
1
Comparaison de chanes de caractres

Il n'y a pas que les nombres que nous pouvons comparer entre eux. Les chanes de caractres, elles aussi, ont leurs oprateurs
de comparaison
Quoi ? Mais qu'est-ce que a peut bien vouloir dire, comparer des chanes de caractres ?
Pose comme cela, il est vrai que cette question ne semble pas vidente. Pourtant, il y a fort parier que vous ayez dj feuillet
un dictionnaire ou un annuaire dans votre vie, et que vous sachiez dj qu'il existe un ordre dans lequel on peut classer les mots
: l'ordre alphabtique (vous croiserez probablement aussi le terme d'ordre lexicographique, qui est plus gnral et ne s'applique
pas seulement des chanes de caractres). Eh bien comparer deux chanes de caractres, c'est simplement dterminer laquelle
des deux vient en premier dans l'ordre alphabtique.
On dira donc qu'une chane $a est plus petite qu'une chane $b si $a est range avant $b dans l'ordre alphabtique.
Ds lors, nous pouvons en dduire tous les autres oprateurs, par analogie avec les comparaisons de nombres. En Perl ces
oprateurs sont des mots-cls forms de faon mnmotechnique :
Expression
Prdicat
Signification
$a lt $b $a est plus petite que $b
lesser than (plus petit)
$a gt $b $a est plus grande que $b
greater than (plus grand)
$a eq $b $a est gale $b
equals
29/61
$a ne $b $a est diffrente de $b
not equal
$a le $b $a est infrieure ou gale $b
lesser or equal
$a ge $b $a est suprieure ou gale $b greater or equal
Voici quelques exemples d'application que vous tes invits complter avec vos propres tests :
Code : Perl
use strict;
use warnings;
print
"\n";
print
print
print
"\n";
"'cool' lt 'coolympique' : " . int('cool' lt 'coolympique') .

"'C' gt 'Perl' : " . int('C' gt 'Perl') . "\n";
"'bla' eq 'bla' : " . int('bla' eq 'bla') . "\n";
"'cool' ne 'coolympique' : " . int('cool' ne 'coolympique') .
Code : Console
'cool' lt 'coolympique' : 1
'C' gt 'Perl' : 0
'bla' eq 'bla' : 1
'cool' ne 'coolympique' : 1
Il existe encore d'autres styles de prdicats que nous pouvons utiliser sur des chanes de caractres que l'on appelle des
expressions rgulires, et qui sont emblmatiques de Perl. tant donnes leur puissance et la complexit de leur syntaxe, nous
consacrerons, plus loin dans ce cours, un chapitre entier leur tude.
Oprateurs logiques
La ngation
La ngation, dsigne par l'oprateur unaire ! en Perl, sert simplement inverser une valeur boolenne :
Code : Perl
print "!0 : " . int (!0) . "\n";
print "!1 : " . int (!1) . "\n";
Code : Console
!0 : 1
!1 : 0
Le OU logique
Les logiciens sont des gens parfois difficiles cerner. Voici ce qui pourrat tre un dialogue entre deux d'entre eux :
30/61
Salut. J'ai une grande nouvelle. Ma femme vient d'accoucher, je suis papa !
Oh, flicitations ! C'est un garon ou une fille ?
Absolument !
*bide*
Cette boutade repose sur la signification du terme OU en logique. En franais, la conjonction de coordination ou peut avoir
plusieurs sens. Son utilisation la plus courante vise proposer un choix entre plusieurs alternatives notre interlocuteur. Ainsi,
la question Est-ce un garon ou une fille ? n'appelle que deux rponses possibles : soit c'est un garon , soit c'est une
fille (quoique l'on pourrait envisager une troisime alternative, plutt rare dans ce contexte : ce n'est ni un garon, ni une
fille ).
En revanche, dans la phrase Je ne reste chez moi que lorsque le temps est la pluie ou la neige. , le ou ne reprsente pas un
choix, mais prend ici le mme sens que le OU logique. Ainsi cette phrase signifie que :
S'il pleut mais qu'il ne neige pas, je prfre rester chez moi.
S'il ne pleut pas mais qu'il neige, je prfre galement rester chez moi.
S'il ne pleut pas, et qu'il ne neige pas non plus, je ne reste pas chez moi (et tant pis s'il grle).
S'il pleut et qu'il neige en mme temps, je reste chez moi.
Dans les phrases ci-dessus, on peut considrer que les propositions il pleut et il neige sont des prdicats. Le OU sert ici
combiner ces deux prdicats pour en former un seul et unique, que l'on va valuer de la faon suivante :
Il pleut Il neige Il pleut OU il neige
FAUX
FAUX
FAUX
FAUX
VRAI
VRAI
VRAI
FAUX
VRAI
VRAI
VRAI
VRAI
Ainsi, on peut rsumer le sens du OU logique, en disant que le prdicat A OU B est vrifi si au moins l'une des deux
propositions A et B est vraie. Ceci explique notre boutade de tout l'heure : en considrant que c'est un garon et c'est une
fille sont deux propositions logiques, on sait bien qu'au moins l'une des deux alternatives sera vraie, alors notre ami logicien a
valu que le prdicat c'est un garon OU une fille tait vrifi, d'o sa rponse. titre purement informatif, on dit qu'une
telle proposition logique qui ne peut jamais tre fausse s'appelle une tautologie.
En Perl, nous n'avons pas UN, mais DEUX oprateurs qui reprsentent le OU logique (souvenez-vous : TIMTOWTDI !) :
l'oprateur || et l'oprateur or. Regardez :
Code : Perl
print
print
print
print
print
print
print
print
print
'0 or
'0 or
'1 or
'1 or
"\n";
'0 ||
'0 ||
'1 ||
'1 ||
0
1
0
1
:
:
:
:
'
'
'
'
.
.
.
.
(0
(0
(1
(1
or
or
or
or
0)
1)
0)
1)
.
.
.
.
"\n";
"\n";
"\n";
"\n";
0
1
0
1
:
:
:
:
'
'
'
'
.
.
.
.
(0
(0
(1
(1
||
||
||
||
0)
1)
0)
1)
.
.
.
.
"\n";
"\n";
"\n";
"\n";
Code : Console
0 or 0 : 0
0 or 1 : 1
1 or 0 : 1
31/61
1 or 1 : 1
0
0
1
1
||
||
||
||
0
1
0
1
:
:
:
:
0
1
1
1
Mais, mais Mais pourquoi avoir cr deux syntaxes diffrentes pour le mme oprateur ? C'est dbile !
En ralit, ces deux oprateurs ne sont pas strictement identiques, comme nous le verrons un petit peu plus bas. Il est vrai que
pour l'instant, notre niveau de progression dans ce cours, cela ne semble pas trs intressant, mais nous aurons l'occasion, au
fur et mesure que nous avancerons, de trouver des usages divers et varis au OU logique, au travers desquels le choix de l'un
ou l'autre de ces oprateurs aura de l'importance.
Pourquoi ne pas avoir utilis la fonction int dans le prcdent code ?
En voil une question dlicate !

C'est li la faon dont Perl value les expressions composes par le OU logique. Lorsque Perl rencontre une expression du type
$a or $b (ou bien $a || $b), il va d'abord valuer $a dans le contexte boolen. Si $a est valu comme vraie, alors on sait
dj que $a or $b sera vraie, donc Perl donne directement $a or $b la valeur de $a (sa vraie valeur scalaire, pas sa
valeur boolenne) et il n'value pas $b (puisque c'est inutile). Par contre, si $a est fausse, alors Perl donne cette expression la
valeur de $b (sa vraie valeur scalaire, encore une fois).
Ce fonctionnement peut vous sembler quelque peu tarabiscot. En ralit, vous n'avez pas besoin de le retenir pour le moment.
Nous aurons l'occasion, l encore, d'y revenir en temps utile.
Le ET logique
Le ET logique sert vrifier que deux propositions sont vraies la fois. Ici, il n'y a pas d'ambigut sur le sens de la conjonction
et. Il s'agit bien du mme connecteur qu'en franais. Ainsi, on peut analyser la proposition suivante Je suis attir par les
femmes qui sont jolies et intelligentes de faon logique, comme ceci :
Si une femme est jolie et intelligente la fois, alors elle est attirante du point de vue du locuteur.
Si une femme est jolie mais pas intelligente, alors elle n'attire pas le locuteur.
Si une femme n'est pas jolie, mais qu'elle est intelligente, alors elle n'attire pas le locuteur non plus.
Si une femme n'est ni jolie, ni intelligente, alors cette fois encore, le locuteur ne la trouvera pas attirante.
On peut donc en dduire la table de vrit du ET logique :
Jolie
Intelligente Jolie ET intelligente
FAUX FAUX
FAUX
FAUX VRAI
FAUX
VRAI FAUX
FAUX
VRAI VRAI
VRAI
Comme pour le OU logique, Perl dispose de deux oprateurs pour exprimer le ET : l'oprateur && et l'oprateur and.
Code : Perl

print
print
print
print
print
print
print
print
print
32/61
'0 and 0 : ' . (0 and 0)

'0 and 1 : ' . (0 and 1)
'1 and 0 : ' . (1 and 0)
'1 and 1 : ' . (1 and 1)
"\n";
'0 && 0 : ' . (0 && 0) .
'0 && 1 : ' . (0 && 1) .
'1 && 0 : ' . (1 && 0) .
'1 && 1 : ' . (1 && 1) .
.
.
.
.
"\n";
"\n";
"\n";
"\n";
"\n";
"\n";
"\n";
"\n";
Code : Console
0
0
1
1
and
and
and
and
0
0
1
1
&&
&&
&&
&&
0
1
0
1
0
1
0
1
:
:
:
:
:
:
:
:
0
0
0
1
0
0
0
1
En ce qui concerne l'valuation de l'expression $a and $b, nous avons l aussi un fonctionnement similaire au OU logique :
Perl value d'abord $a dans le contexte boolen. Si $a est fausse, alors inutile d'aller plus loin, l'expression ($a and $b) prend
la valeur scalaire de $a. Sinon, l'expression prend la valeur scalaire de $b.
Prcdence des oprateurs logiques

Il est maintenant temps de rpondre la question que l'on a pose plus haut : qu'est-ce qui diffrencie les oprateurs && et ||
des oprateurs and et or ?
La rponse tient en un mot : leur prcdence. La prcdence d'un oprateur, c'est sa priorit. Elle dtermine l'ordre dans lequel
les expressions sont values.
Regardez :
Code : Perl
print
print
print
print
print
'0 and 1 or 1 : ' . (0 and 1 or 1) . "\n";

'0 and 1 || 1 : ' . (0 and 1 || 1) . "\n";
'0 && 1 or 1 : ' . (0 && 1 or 1) . "\n";
'0 and (1 or 1) : ' . (0 and (1 or 1)) . "\n";
'(0 and 1) or 1 : ' . ((0 and 1) or 1) . "\n";
Code : Console
0 and 1 or 1 :
0 and 1 || 1 :
0 && 1 or 1 :
0 and (1 or 1)
(0 and 1) or 1
1
0
1
: 0
: 1
Cet exemple illustre trs bien le fait que les oprateurs && et || ont une priorit beaucoup plus forte que les oprateurs and et
or. Il vous est trs fortement conseill de drouler mentalement ces expressions jusqu' ce que vous en compreniez tous les
tenants et les aboutissants.
33/61
Le OU exclusif (XOR)
Le dernier oprateur que nous verrons ici est le OU exclusif, que l'on note XOR. Pour dire les choses simplement, A XOR B est
vraie si A est vraie OU BIEN B est vraie, mais pas les deux. En franais, ce OU-l s'exprime souvent grce l'expression ou
bien , comme dans la phrase suivante : Pour tenter un tel exploit, il faudrait tre remarquablement brave, ou bien compltement
stupide .
Voici la table de vrit du XOR :
A
A XOR B
FAUX FAUX
FAUX
FAUX VRAI
VRAI
VRAI FAUX
VRAI
VRAI VRAI
FAUX
Contrairement aux deux prcdents oprateurs logiques, le ou exclusif ne peut se traduire que d'une seule faon en Perl, au
moyen de l'oprateur xor. Cette fois, nous sommes obligs d'utiliser la fonction int pour afficher le rsultat des expressions,
car il n'y a pas de mcanisme comparable aux deux prcdents : toutes les expressions sont values, il n'y aurait donc pas
d'intrt ce que le rsultat soit autre chose qu'un boolen.
Code : Perl
print
print
print
print
'0
'0
'1
'1
xor
xor
xor
xor
0
1
0
1
:
:
:
:
'
'
'
'
.
.
.
.
int
int
int
int
(0
(0
(1
(1
xor
xor
xor
xor
0)
1)
0)
1)
.
.
.
.
"\n";
"\n";
"\n";
"\n";
Code : Console
0
0
1
1
xor
xor
xor
xor
0
1
0
1
:
:
:
:
0
1
1
0
La fonction defined
La fonction defined permet de vrifier qu'une variable est dfinie. On dit qu'une variable est dfinie si une valeur lui a t
affecte. Si ce n'est pas le cas, on dit que la variable n'est pas dfinie, et on symbolise sa valeur par la valeur spciale undef. Un
exemple valant mieux qu'un long discours, regardez plutt :
Code : Perl
use strict;
use warnings;
my $var;
# $var est dclare, mais elle n'est pas dfinie
print 'defined $var : ' . int (defined $var) . "\n";

$var = 42;
# $var est maintenant dfinie
print "\$var = $var \n";
34/61

$var = undef; # $var n'est maintenant plus dfinie
print "\$var = undef \n";
Code : Console
defined $var : 0
$var = 42
defined $var : 1
$var = undef
defined $var : 0
Exemple avanc
En combinant cette fonction avec le mcanisme d'valuation des oprateurs logiques de Perl, on peut obtenir quelques
comportements intressants, bien que difficiles lire au premier abord, comme celui-ci :
Code : Perl
use strict;
use warnings;
my $error = "\$var n'est pas dfinie.\n";
my $var;
# $var est dclare, mais elle n'est pas dfinie
defined $var && print "\$var = $var\n" or print $error;
$var = 42; # $var est maintenant dfinie
$var = undef; # $var n'est maintenant plus dfinie
Code : Console
$var n'est pas dfinie.
$var = 42
$var n'est pas dfinie.
La comprhension de ce code vous est laisse titre d'exercice. Celle-ci n'est absolument pas indispensable pour suivre le reste
de ce chapitre (on est dj au-del du niveau attendu), mais rsume somme toute assez bien tout ce que nous avons vu jusqu'
maintenant.
if, else, et unless

O en sommes nous ?
Reprenons, si vous le voulez bien, la structure logique du programme que nous avons imagin au tout dbut de ce chapitre.
Le programme demande l'utilisateur d'entrer son mot de passe
35/61
L'utilisateur entre un mot de passe

SI le mot de passe est "s'il te plait"
SINON
Nous savons maintenant exprimer le prdicat le mot de passe est "s'il te plait", nous pouvons donc crire une premire
version de ce programme.
Code : Perl
use strict;
use warnings;
print "Entrez le mot de passe : ";
my $pass = <>;
chomp $pass;
my $acces = $pass eq "s'il te plait";
print '$acces : ' . int($acces) . "\n";
Code : Console
Entrez le mot de passe : ssame ouvre-toi
$acces : 0
Code : Console
Entrez le mot de passe : s'il te plait
$acces : 1
Il nous reste donc maintenant exprimer en Perl cette structure SI SINON . Il suffit pour cela de parler un petit peu
anglais.
if et else
En anglais, si se traduit par if et sinon se traduit par else . C'est pour cette raison que les principaux mots-cls
servant exprimer un branchement conditionnel sont if et else. Voici la structure gnrale d'un tel branchement :
Code : Perl
my $predicat; # ici le prdicat tester
if ($predicat)
{
# code excuter si le prdicat est vrifi
}
else
{
# code excuter si le prdicat n'est pas vrifi
}
Comme vous le voyez, un branchement conditionnel s'exprime grce deux blocs de code, dlimits par des accolades ({}).
Plutt que de nous attarder dcrire le fonctionnement de ces deux blocs, voici un exemple grce auquel vous le comprendrez
36/61
directement :
Code : Perl
use strict;
use warnings;
my $pass = <>;
chomp $pass;
if ($pass eq "s'il te plait")
{
# le mot de passe entr par l'utilisateur
# est bien "s'il te plait"
}
else
{
print "Accs autoris.\n";

print "Bienvenue.\n";

# n'est pas le bon
print "Accs refus.\n";
print "Allez vous faire voir !\n";
Essayez-le, et vous constaterez qu'il s'agit bien du programme complet que nous avions imagin au dbut.
Exercice
crivez un programme qui demande l'utilisateur d'entrer la lettre H si c'est un homme, ou F si c'est une femme, et qui le salue en
lui disant Bonjour monsieur ou Bonjour madame le cas chant.
Branchements en srie
Pour l'instant, nous avions le choix entre deux alternatives grer : soit le mot de passe est le bon, soit il ne l'est pas.
Imaginons maintenant que ce programme ait deux utilisateurs autoriss (donc deux mots de passe possibles). Le premier
utilisateur, Jean, a pour mot de passe s'il te plait , et le second utilisateur, Marie, a pour mot de passe sesame ouvre-toi .
Comment coder ceci en Perl ?
Une premire ide serait de faire quelque chose comme ceci :
Code : Perl
use strict;
use warnings;
my $pass = <>;
chomp $pass;
{
# est "s'il te plait"

print "Bienvenue, Jean.\n";

else
{
if ($pass
{
print
print
}
else
{
print
print
}
37/61
eq "sesame ouvre-toi")
"Accs autoris.\n";
"Bienvenue, Marie.\n";
"Accs refus.\n";
"Allez vous faire voir !\n";
Comme vous le constatez, on teste d'abord si le mot de passe entr par l'utilisateur est celui de Jean, sinon, on teste si le mot de
passe est celui de Marie, sinon, on envoie balader l'utilisateur. Cela fonctionne bien, certes, mais il existe une faon plus lgante
d'crire ce code en Perl. Ce "else if" peut tre contract au moyen du mot-cl elsif, comme cela :
Code : Perl
use strict;
use warnings;
my $pass = <>;
chomp $pass;
{
}
elsif ($pass eq "sesame ouvre-toi")
{
print "Bienvenue, Marie.\n";
}
else
{
}
C'est quand mme un peu plus joli, non ? Imaginez ce que cela aurait pu donner si nous avions eu 15 utilisateurs diffrents !
Notez que l'on n'est pas oblig, ni dans ce cas, ni dans le prcdent, de mettre une clause else notre programme. On peut trs
bien crire un bloc if tout seul : si le prdicat n'est pas satisfait, alors le programme ne fera rien :
Code : Perl
use strict;
use warnings;
my $pass = <>;
chomp $pass;
# si le mot de passe est le bon,
# on salue Jean
{
38/61
}
# sinon, on ne fait rien
Exercice
crivez un programme qui demande l'utilisateur d'entrer "F" si c'est une femme ou "H" si c'est un homme, et qui lui rpond
"Bonjour Monsieur" ou "Bonjour Madame" si c'est un homme ou une femme, ou bien "Salut machin" si la lettre entre par
l'utilisateur n'est ni "F" ni "H". Utilisez pour ce faire une clause elsif.
unless
Pour en finir avec les branchements conditionnels, examinons le dernier bloc que l'on peut utiliser : unless. En anglais,
unless signifie moins que . Il s'agit en fait de l'inverse de if en Perl.
Code : Perl
use strict;
use warnings;
my $pass = <>;
chomp $pass;
# Quitter le programme en envoyant balader l'utilisateur
# MOINS QUE le mot de passe rentr soit le bon.
unless ($pass eq "s'il te plait")
{
print "Accs refus.\nAllez vous faire voir !\n";
exit(1); # quitter le programme
}
print "Bienvenue.\n";
# ... suite du programme
Il est aussi possible d'adjoindre un bloc else un bloc unless (ce qui permet d'excuter du code si le prdicat valu par
unless n'est pas vrifi), mais lorsque l'on y rflchit bien, la structure " moins que sinon" n'est pas trs intuitive
comprendre. Pour cette raison, il est plutt dconseill d'utiliser conjointement unless et else, par soucis de lisibilit.
Travailler avec des blocs
Dans la prcdente sous-partie, nous avons fait connaissance avec les blocs de code, dlimits par des accolades. Profitons-en
pour voquer quelques bonnes pratiques adopter lorsque l'on les utilise.
Mise en forme et indentation du code

Commenons par enfoncer des portes ouvertes. Un bloc, c'est d'abord une frontire qui permet de diffrencier le code qui est
l'intrieur de celui qui est l'extrieur (nous allons voir en quoi dans un instant). ce titre, il est indispensable de rendre ceci
visible. Par convention, on met en vidence cette diffrence en indentant le code qui se trouve l'intrieur du bloc. Indenter
signifie dcaler le code vers la droite. En gnral, ce dcalage est d'une tabulation ou de 4 espaces, comme ceci :
Code : Perl
print "code l'extrieur du bloc";
{
39/61
# cette ligne est indente.

print "code l'intrieur du bloc";
Pour la position des accolades, il existe plusieurs conventions, qui sont toutes acceptables. Dans ce cours, nous prendrons le
parti de toujours aligner l'accolade ouvrante et mme niveau que l'accolade fermante.
Ceci permet de rendre le code lisible, et il est primordial que vous preniez cette habitude ds maintenant. Constatez la diffrence
par vous-mme :
Code non indent (mauvais exemple) :
Code : Perl
use strict;
use warnings;
my $pass = <>;
chomp $pass;
{
}
else
{
if ($pass eq "sesame ouvre-toi")
{
}
else
{
}
}
Code bien indent (bon exemple) :

Code : Perl
use strict;
use warnings;
my $pass = <>;
chomp $pass;
{
}
else
{
if ($pass eq "sesame ouvre-toi")
{

}
else
{
40/61

Prsentation alternative (bon exemple) :

Code : Perl
use strict;
use warnings;
my $pass = <>;
chomp $pass;
if ($pass eq "s'il te plait") {
}
else {
if ($pass eq "sesame ouvre-toi") {
}
else {
}
}
Niveau lisibilit, il n'y a pas photo
Notion de porte lexicale

Cette notion est extrmement importante. Jusqu' prsent, lorsque nous travaillions sans placer de code dans des blocs, nous
dfinissions toutes nos variables sur le mme plan . Or lorsque l'on dfinit une variable dans un bloc, on doit se soucier de sa
porte, c'est--dire des endroits dans le code o elle existe.
Pour faire simple, une variable existe dans le bloc dans lequel elle a t dfinie, et dans les blocs contenus l'intrieur de celui-ci,
mais pas l'extrieur. On dira donc, pour bien faire, que la porte lexicale d'une variable est locale au bloc dans lequel elle est
dclare.
Voyons cela au travers d'un exemple.
Code : Perl
use strict;
use warnings;
my $var = "Hello";
{
my $var2 = "World";
print $var; # affiche "Hello".
print $var2; # affiche "World".
41/61
print $var; # affiche "Hello".

print $var2; # /!\ ERREUR, Perl va vous envoyer ballader car $var2
n'existe plus
# et le script ne sera pas excut.
Il est aussi important de noter que nous devons ce comportement (cette scurit, en fait) au mode strict de Perl. En effet, si
nous n'avions pas invoqu le pragma strict au dbut de ce programme, l'instruction print $var2 aurait simplement t
value comme l'affichage d'une variable que l'on dclare dans la foule, et n'aurait donc rien affich (en toute rigueur, elle aurait
affich la reprsentation sous forme d'une chane de la valeur undef, c'est--dire rien du tout).
Ainsi le programme n'aurait pas plant, mais le warning suivant serait quand mme apparu :
Code : Console
Use of uninitialized value $var2 in print at test.pl line 13.
Et bien sr, si nous avions aussi oubli d'activer les warnings au moyen de l'instruction "use warnings;", ce warning ne
serait pas apparu non plus, le code se serait excut, et cette ligne n'aurait rien affich sans aucune explication, d'o l'importance
de ces deux pragmas !
La syntaxe en ligne
Et si on commenait rendre nos codes un peu plus perlesques ?
Cette sous-partie est ici titre d'exhaustivit, car nous trouverons, pour l'instant, relativement peu de cas dans lesquels utiliser
cette syntaxe en ligne .
Il arrive que dans un code, on crive un bloc if ou un bloc unless qui tienne en une seule ligne, comme ceci :
Code : Perl
use strict;
use warnings;
print "Entrez le mot de passe : "; # eh oui, encore cet exemple !
my $pass = <>;
chomp $pass;
# moins que le mot de passe soit "s'il te plait"
unless ($pass eq "s'il te plait")
{
# Quitter en affichant une erreur
die "Erreur d'authentification";
}
# Droulement normal du programme.
print "Bienvenue\n";
# etc.
Ici, la fonction die, qui est nouvelle pour vous (et qui signifie "meurs") sert dclencher une erreur dans le programme. Si cette
erreur n'est pas rattrape (nous verrons comment faire dans un autre chapitre), alors le programme se termine en affichant l'erreur
donne en argument die.
Comme vous le constatez, ce bloc prend visuellement pas mal de place, d'autant que sa fonction est plutt simple : quitter si le
mot de passe est erron.
Lorsqu'il s'agit d'un tel bloc if ou unless, sans clause else, on peut l'crire en une seule ligne, et ce sans perdre en lisibilit,
comme cela :
42/61
Code : Perl
use strict;
use warnings;
my $pass = <>;
chomp $pass;
# Quitter MOINS QUE le mot de passe soit "s'il te plait".
die "Erreur d'authentification" unless $pass eq "s'il te plait";
# alternativement, on aurait pu crire ceci :
# Quitter SI le mot de passe n'est pas "s'il te plait".
die "Erreur d'authentification" if $pass ne "s'il te plait";
# Suite du programme
print "Bienvenue\n";
# etc.
Comme vous le voyez, on ajoute simplement une condition l'excution de la ligne, et les parenthses entourant le prdicat ne
sont plus ncessaires. Il s'agit vritablement de sucre syntaxique, mais vous remarquerez que le code se lit finalement exactement
de la mme faon que sa signification, ce qui permet de ne pas surcharger le programme visuellement, tout en gardant une
syntaxe claire et lisible.
TP : jeu de devinettes (premire version)

Afin d'appliquer ce que nous avons appris dans ce chapitre, nous allons, en guise de TP corrig, crer un petit jeu de devinettes
tout simple que nous amliorerons plus tard.
L'utilisateur doit choisir un animal parmi une liste donne. Le programme va ensuite poser des questions l'utilisateur, auxquelles
celui-ci devra rpondre par oui (o) ou non (n), jusqu' ce qu'il ait devin de quel animal il s'agit.
Voici deux exemples d'excution :
Code : Console
Choisissez un animal parmi les suivants :
Chat, Mouette, Lama, Chouette
-----------------------------Est-ce que c'est un oiseau [o/n] ? n
Est-ce que cet animal crache [o/n] ? o
C'est un lama !
Code : Console
Choisissez un animal parmi les suivants :
Chat, Mouette, Lama, Chouette
-----------------------------Est-ce que c'est un oiseau [o/n] ? o
Est-ce que c'est un oiseau nocturne [o/n] ? o
C'est une chouette !
Bien entendu, pour russir, vous allez devoir appliquer ce que nous avons vu dans ce chapitre, et utiliser des blocs if/else.
Dans un prochain TP, nous ferons en sorte que la liste puisse augmenter et que le jeu soit capable d'apprendre deviner de
nouvelles entres au fur et mesure que l'on y joue.
43/61
Bon courage !
Correction
Code : Perl
#!/usr/bin/env perl
#
#
#
#
Jeu de devinettes
----------------L'utilisateur choisit un animal parmi une liste
donne, et le programme doit deviner duquel il s'agit.
use strict;
use warnings;
print "Choisissez un animal parmi les suivants :\n";
print "Chat, Mouette, Lama, Chouette\n";
print '-' x 30 . "\n";
print 'Est-ce que c\'est un oiseau [o/n] ? ';
my $choice = <>;
chomp $choice;
# la fonction 'lc' sert convertir une chane lettres en
minuscules
# lc : lower case
if (lc($choice) eq 'o')
{
# c'est un oiseau
print 'Est-ce que c\'est un oiseau nocturne [o/n] ? ';
$choice = <>;
chomp $choice;
{
print "C'est une chouette !\n";
}
else
{
print "C'est une mouette !\n";
}
}
else
{
print 'Est-ce que cet animal crache [o/n] ? ';
$choice = <>;
chomp $choice;
{
print "C'est un lama !\n";
}
else
{
print "C'est un chat !\n";
}
}
# <>;
Vous pouvez souffler ! Nous sommes arrivs au bout de ce chapitre.
44/61
Rsumons donc les notions essentielles que nous venons de voir :

Contrairement une instruction, un prdicat n'est pas un ordre, mais une proposition qui peut tre vraie ou fausse.
On peut construire des prdicats en comparant des scalaires entre eux.
La valeur de vrit d'un prdicat est une donne boolenne.
Les boolens peuvent tre combins entre eux au moyen d'oprateurs logiques.
Grce la construction if/else, un programme peut prendre des dcisions et excuter du code diffrent selon les
conditions dans lesquelles il se trouve.
Les variables dfinies avec le mot-cl my en Perl ne sont pas accessibles partout dans le code : celles-ci ont une porte
locale au bloc dans lequel elles sont dfinies.
Comme vous le voyez, nos programmes commencent ressembler quelque chose, puisque leur excution peut maintenant
passer plusieurs chemins diffrents en fonction des dcisions qu'ils prennent. Dans le prochain chapitre, nous dcouvrirons un
autre style de blocs qui nous permettra d'effectuer des tches rptitives l'infini.
45/61
Processus itratifs et boucles

Dans le chapitre prcdent, vous avez dcouvert vos premires structures de contrle de flux avec les constructions if/else
et unless. prsent, nous allons poursuivre notre lance en travaillant sur un autre type de structure de contrle : les
boucles.
Comme vous le savez srement, le principal avantage des programmes et des robots sur nous est qu'ils peuvent rpter
inlassablement les mmes actions sans jamais se tromper ni se fatiguer. C'est prcisment ce que nous allons tudier : comment
faire en sorte que vos programmes se rptent.
Dans ce chapitre vous apprendrez :
caractriser un processus itratif,
crer une boucle while en Perl,
ouvrir, lire, crire et fermer des fichiers sur votre ordinateur,
utiliser d'autres types de boucles (unless, do while et for) et les choisir selon vos besoins.
Allez, on s'y colle !
La boucle de base : while

De la mme faon que dans le chapitre prcdent, commenons par examiner l'excution d'un programme afin d'illustrer le
comportement nouveau que nous allons tudier dans ce chapitre.
Code : Console
Je vais compter les lamas pour m'endormir.
Jusqu' combien dois-je compter ? 13
1 lama
2 lamas
3 lamas
4 lamas
5 lamas
6 lamas
7 lamas
8 lamas
9 lamas
10 lamas
11 lamas
12 lamas
13 lamas
ZZZZzzzzzzz...
En effet, aussi bte que cela en a l'air, nous ne sommes pas encore capables, avec nos connaissances actuelles, d'crire un vrai
programme capable de compter jusqu' une valeur arbitraire Rassurez-vous cependant, car nous allons combler cette lacune
trs vite !
Pour cela, commenons par comprendre ce qu'il se passe lorsque l'on compte jusqu' 13.
D'abord, supposons que l'on travaille avec une variable que l'on va nommer $compteur. Au tout dbut, on initialise ce
compteur avec la valeur 1, puis on nonce 1 lama . Ensuite, c'est l que les choses se corsent. Tant que notre compteur n'est
pas arriv 13, on le fait avancer d'un cran (dans le jargon des programmeurs, on dit que l'on incrmente sa valeur), puis on
nonce $compteur lamas . Dans notre exemple, cette opration est rpte 12 fois. Enfin, une fois que l'on est arrivs 13,
on s'arrte.
Cela se rsume en pseudo-code comme ceci :
$compteur = 1
print "$compteur lama"
Tant que $compteur < 13:
$compteur = $compteur + 1
print "$compteur lamas"
print "ZZZZZzzzz..."
46/61
Comme vous le voyez, nous sommes dj pratiquement capables d'crire ce programme entirement en Perl, l'exception d'un
dtail : cette construction Tant que. Celle-ci sert dcrire ce que l'on appelle un processus itratif , c'est--dire un processus
dans lequel une mme opration est ralise de faon rptitive et progressive. Plus prcisment, ce tant que permet de
dcrire une boucle.
Considrons la phrase suivante :
Il insistera tant qu'elle ne l'aura pas gifl.
On peut dcouper cette phrase en trois lments :
Il insistera tant qu'elle ne l'aura pas gifl.
En vert, nous avons l'expression d'une action. En rouge, nous avons la cl de la construction de cette phrase, savoir la
locution tant que . En bleu, nous avons une condition, ou plutt un prdicat. Intuitivement, nous savons, la lecture de cette
phrase, que l'action va tre rpte encore et encore, en boucle , jusqu'au moment o PAF ! , le prdicat ne sera plus
vrifi, auquel cas la boucle sera rompue, et l'action s'arrtera pour passer autre chose.
En Perl, une telle boucle peut tre cre en traduisant simplement ce Tant que par son synonyme anglais, while :
Code : Perl
while ($predicat) # Tant que le prdicat est vrifi
{
action ();
# Rpter la mme action en boucle
}
Nous sommes donc en mesure d'crire le code de l'exemple de tout l'heure :

Code : Perl
use strict;
use warnings;
print "Je vais compter les lamas pour m'endormir.\n";
my $limite;
print "Jusqu' combien dois-je compter ? ";
$limite = <>;
# Situation initiale, le compteur est 1
my $compteur = 1;
print "$compteur lama\n";
# Tant que le compteur n'a pas atteint sa limite
while ($compteur < $limite)
{
# On compte
$compteur = $compteur + 1;
print "$compteur lamas\n";
}
print "ZZZZZZzzzzzz...\n";
Ordre d'excution
47/61
Comme vous le constatez, nous commenons faire face des programmes qui ne suivent plus forcment l'ordre du fichier
source, mais sont capables de revenir en arrire de quelques lignes pour se rpter. ce titre, il est bon de fixer ds
maintenant dans votre esprit la faon dont une boucle while est excute par perl.
Celle-ci ne diffre pas de la faon dont les boucles sont excutes dans les autres langages impratifs :
Lorsque l'interprteur arrive au niveau du while, celui-ci commence par valuer le prdicat.
Si ce dernier est vrifi, l'interprteur excute tout le contenu du bloc ( moins de tomber sur une instruction spciale,
mais nous y reviendrons au moment voulu), sinon, il passe son chemin et reprend l'excution aprs le bloc.
Une fois le bloc excut, l'interprteur va valuer nouveau le prdicat.
Si le prdicat est encore vrifi, l'interprteur va excuter nouveau tout le contenu du bloc.
Cela peut sembler idiot rappeler, mais il s'agit d'un point sur lequel beaucoup de dbutants commettent des erreurs ; on ne sort
de la boucle que lorsque le bloc a fini d'tre excut, et que le prdicat n'est plus vrifi.
Code : Perl
my $var = 12;
while ($var != 13)
{
$var = 13;
# ce niveau le prdicat n'est plus vrifi
print "$var\n"; # mais cette ligne sera quand mme excute

} # c'est seulement une fois rendu ici, la fin du bloc,
# que le prdicat sera nouveau valu
# et que l'on sortira de la boucle.
Oprateurs d'incrmentation et de dcrmentation

Dans l'exemple du dbut de ce chapitre, on trouve l'instruction suivante.
Code : Perl
$compteur = $compteur + 1;
En programmation imprative, on utilise trs souvent ce genre d'instructions, que l'on appelle une incrmentation. C'est la raison
pour laquelle Perl dispose d'une syntaxe plus lgre pour effectuer cette opration :
Code : Perl
$compteur
$compteur
$compteur
$compteur
$compteur
$compteur
= 4;
+= 1; # 5
+= 2; # 7
-= 1; # 6
/= 2; # 3
.= " petits cochons"; # "3 petits cochons"
D'ailleurs, dans les cas trs particuliers o l'on souhate simplement ajouter ou retrancher la valeur 1 une variable, il existe mme
une syntaxe encore plus courte, consistant utiliser les oprateurs unaires d'incrmentation (++) ou de dcrmentation (--) :
Code : Perl

$compteur = 4;
$compteur++;
++$compteur;
$compteur--;
--$compteur;
48/61
#
#
#
#
5
6
5
4
Quelle est la diffrence entre $compteur++ et ++$compteur ?
Il faut savoir qu'en Perl, toutes les instructions retournent une valeur. La diffrence entre ces deux syntaxes est que lorsque
l'oprateur est situ aprs la variable, l'instruction prend la valeur de la variable avant que celle-ci soit incrmente. l'inverse,
lorsque l'oprateur est situ avant la variable, l'instruction prend la valeur de la variable aprs incrmentation :
Code : Perl
my $compteur = 4;
print $compteur++; # affiche 4
print $compteur;
# affiche 5
print ++$compteur; # affiche 6
TP : jeu du plus ou moins

Avant de poursuivre, passons ds maintenant la pratique et examinons un programme dont le fonctionnement repose sur une
boucle while.
Nous allons programmer le clbre jeu du plus ou moins. Il s'agit d'un petit jeu trs simple, dont le but est de deviner un nombre
choisi au hasard entre 1 et 100 par l'ordinateur :
Code : Console
Devinez le nombre mystre.
> 50
C'est moins.
> 25
C'est moins.
> 12
C'est plus.
> 18
C'est plus.
> 21
Gagn !
Pour programmer ce petit jeu, nous devons commencer par l'analyser, tape par tape. Voici ce que cela devrait donner :
L'ordinateur choisit un nombre alatoirement entre 0 et 100.
Tant que le joueur n'a pas trouv le nombre mystre :
Le joueur entre un nombre
Si le nombre est plus grand que le nombre mystre, l'ordinateur rpond C'est moins .
Sinon, s'il est plus petit que le nombre mystre, l'ordinateur rpond C'est plus .
Une fois que le joueur a trouv le nombre mystre, la partie est termine.
Maintenant que l'algorithme du programme est dfini, il ne nous reste plus qu' trouver comment coder chaque tape.
Tirer un nombre au hasard

49/61
Pour gnrer une valeur alatoire, en Perl, nous allons utiliser la fonction rand. Celle-ci, lorsqu'on l'appelle sans lui donner
d'argument, retourne alatoirement un nombre dcimal compris entre 0 et 1.
On peut aussi lui passer un argument, pour choisir un nombre au hasard entre 0 et une valeur donne (exclue) :
Code : Perl
my $val = rand 10
# retourne un nombre compris entre 0 et 9.999999
Dans notre cas, puisque nous voulons choisir au hasard un nombre entier compris entre 0 et 100, il nous suffira donc d'appeler
rand en fixant sa limite 101, et de convertir le rsultat en un nombre entier, avec la fonction int, que nous avons rencontre
dans le chapitre prcdent, comme ceci :
Code : Perl
my $nb_mystere = int (rand 101); # Tirage alatoire d'un nombre
# compris entre 0 et 100
La boucle principale
Une fois que nous avons choisi un nombre mystre, il faut que l'utilisateur essaye de le deviner. Pour cela, nous allons crer une
boucle : tant que le joueur n'aura pas trouv le nombre mystre, on lui donnera des indices pour l'y aider.
Code : Perl
# /!\ N'EXCUTEZ PAS CE SCRIPT TEL QUEL /!\
use strict;
use warnings;
my $nb_mystere = int (rand 101);
my $essai = -1;
print "Devinez le nombre mystre.\n";
while ($essai != $nb_mystere)
{
# Le joueur essaye de deviner le nombre mystre
}
# Si l'on arrive ici, c'est que le joueur a gagn.
print "Gagn !"
Il y a plusieurs remarques faire sur ce code. Tout d'abord, ne l'excutez pas tel quel ! En effet, tant donn que nous n'avons
encore rien plac dans le corps de la boucle, la valeur de $essai ne sera jamais modifie, et le programme va tourner dans le
vide indfiniment. Il vous faudrait alors, pour pouvoir terminer ce programme, l'interrompre en appuyant simultanment sur les
touches Ctrl + C, de faon que le processus soit tu par votre systme d'exploitation.
On remarque aussi que la variable $essai, qui va servir rcuprer les tentatives du joueur, est initialise -1. De cette faon,
lorsque le prdicat du while sera valu pour la premire fois, celui-ci sera vrifi, ce qui permettra au programme d'entrer dans
la boucle.
Programme final
50/61
Il ne nous reste plus qu' coder le droulement d'un tour du jeu, ce qui n'est pas compliqu en soi : on rcupre dans la variable
$essai l'entre de l'utilisateur, puis on compare cette valeur au nombre mystre. Il s'agit d'une simple clause if/elsif, comme
nous en avons crois dans le prcdent chapitre :
Code : Perl
use strict;
use warnings;
my $essai = -1;
while ($essai != $nb_mystere)
{
print '> ';
$essai = <>;
if ($essai < $nb_mystere)

{
print "C'est plus.\n";
}
elsif ($essai > $nb_mystere)
{
print "C'est moins.\n";
}
print "Gagn !";
Vous remarquerez que l'on ne chomp-e pas, dans ce code, l'entre de l'utilisateur. En effet, puisque la variable $essai va tre
compare au nombre mystre au moyen des oprateurs < et >, celle-ci sera automatiquement convertie en nombre, opration
pendant laquelle le "\n" en fin de ligne sera ignor.
Traitement de fichiers
L'un des usages les plus courants de la boucle while en Perl est lorsque le programme doit lire ou crire dans un fichier sur le
disque dur. Nous allons donc, dans les prochains exemples, apprendre interagir de faon basique avec des fichiers texte.
Comme vous allez le voir, ce n'est vritablement pas sorcier, mais cela vous permettra de crer ds maintenant des scripts utiles et
intressants !
open et close
Que ce soit pour lire ou pour crire dans un fichier, il est vident qu'il faut que nous soyons capables de les ouvrir. Pour ce faire,
Perl nous propose la fonction open. Un petit coup d'il sur la documentation de cette fonction vous fera comprendre trs
rapidement qu'il existe moult faons de l'utiliser. Afin de ne pas surcharger ce chapitre inutilement, nous nous contenterons
d'examiner ici son usage le plus commun, c'est--dire la syntaxe utilisant trois arguments :
open FILEHANDLE, MODE, EXPR
o :
FILEHANDLE est un filehandle (littralement, une poigne sur un fichier ), c'est--dire ni plus ni moins qu'une
variable un peu spciale qui reprsente le fichier avec lequel on interagit. Nous y reviendrons.
MODE est une chane de caractres qui dcrit l'usage que l'on va faire de ce fichier (lecture, criture, ajout).
EXPR est une autre chane de caractres qui contient le chemin du fichier.
En ce qui concerne le MODE, nous allons nous contenter des trois plus courants pour ce chapitre. Vous aurez probablement
l'occasion d'en rencontrer d'autres, beaucoup plus subtils et moins usits, dans la suite de ce cours, ou simplement en consultant
la documentation en fonction de vos besoins. Ces trois MODEs sont en fait rigoureusement identiques ce que vous pourrez
51/61
rencontrer dans la syntaxe d'un shell Unix :

Mode
Signification
'<'
Ouvrir le fichier en lecture.

L'appel open choue si le fichier n'existe pas.
'>'
Ouvrir le fichier en criture.

L'appel open choue si l'utilisateur n'a pas les droits d'accs sur ce fichier ou son dossier.
Si le fichier n'existe pas, un nouveau est cr.
Si le fichier existe, son contenu prcdent est effac.
'>>'
Ouvrir le fichier en mode "ajout".

Sensiblement la mme chose que le mode criture.
Si le fichier existe dj, tout ce que l'on crira dedans sera plac la suite du contenu actuel.
N'est-il pas possible d'ouvrir un fichier la fois en lecture et en criture ?
Dans l'absolu, si. Nanmoins, il est trs peu probable que vous en ayez rellement besoin dans un programme, et il s'agit d'une
pratique qui peut s'avrer dangereuse pour vos fichiers si vous ne savez pas exactement ce que vous tes en train de faire. C'est
la raison pour laquelle nous ferons l'impasse sur ce sujet dans ce cours. Les plus tmraires d'entre vous pourront toujours
consulter la documentation de Perl pour trouver comment faire.
Les chemins des fichiers, quant eux, dpendent de votre systme d'exploitation. Ainsi, sous Windows, les dossiers doivent tre
spars par des antislashes, il faut donc faire attention les chapper, ainsi que les espaces
("C:\\Mes\ Documents\\Perl\\fichier_test.txt"). Sous les OS bass sur Unix, en revanche, les dossiers sont
classiquement spars par des slashes ("/home/arnaud/perl/fichier_test.txt"), ce qui rend la tche plus aise.
D'une faon gnrale, il est conseill d'viter de crer des chemins ou des fichiers dont les noms contiennent des
espaces ou des caractres spciaux/accentus.
Enfin, pour fermer un fichier, une fois que vous avez fini de travailler avec, vous pouvez utiliser la fonction close en lui passant
en argument le filehandle du fichier que vous avez ouvert.
Rsumons-nous dans un exemple :
Code : Perl
# Chemin du fichier ouvrir en criture.
# my $filename = "C:\\fichier_test.txt"; # Sous Windows
my $filename = "/home/arnaud/fichier_test.txt"; # Sous Linux
my $fh;
open ($fh, '>', $filename) or die "Impossible d'ouvrir le fichier
$filename en criture";
# ... code qui crit dans le fichier ...
close $fh;
open ($fh, '<', $filename) or die "Impossible d'ouvrir le fichier
$filename en lecture";
# ... code qui lit le fichier ...
close $fh;
Remarquez que le rsultat de la fonction open est valu comme faux lorsque l'ouverture du fichier choue. Ceci nous permet de
rajouter la petite clause or die "...", qui sert quitter le programme en affichant un message d'erreur en cas d'chec.
Alternativement, vous pouvez vrifier que l'ouverture a bien fonctionn en testant le filehandle avec la fonction defined. Si
l'ouverture a chou, alors la variable $fh (dans l'exemple) n'est pas dfinie.
Lecture et criture
52/61
Jusqu'ici, pour afficher du texte dans la console, nous avons utilis la fonction print. Eh bien dornavant, pour crire des
donnes dans un fichier, nous utiliserons aussi la fonction print ! Regardez plutt :
Code : Perl
use strict;
use warnings;
open (my $fh, '>', 'fichier_test.txt') or die "Impossible d'ouvrir
le fichier";
print $fh "Hello, World !\n"; # On prcise la fonction print le
# filehandle dans lequel on dsire
crire
close $fh;
Si vous lancez ce script, celui-ci va crer un fichier appel fichier_test.txt, et crire la chane "Hello, World !"
l'intrieur. Vrification sous Linux :
Code : Console
arnaud@laptop(perl)% perl helloworld_fichier.pl
arnaud@laptop(perl)% cat fichier_test.txt
Hello, World !
Vous remarquerez que pour afficher le contenu du fichier dans cet exemple, on a utilis le programme cat , que tous les
utilisateurs d'Unix connaissent bien, et qui sert simplement afficher le contenu d'un fichier, ou bien envoyer sur la sortie
standard le texte qu'il reoit en entre. Dans un instant, nous reprogrammerons cet utilitaire en une seule ligne de Perl.
Revenons notre code : vous n'aurez pas manqu de remarquer que nous avons simplement prcis la fonction print le
filehandle dans lequel nous dsirions crire. En effet, jusqu' maintenant, nous n'avions utilis cette fonction que dans le cas
particulier o l'on ne prcise aucun filehandle print, auquel cas celle-ci ragit simplement en crivant sur le flux de sortie
standard du programme, c'est--dire, par dfaut, dans la console. crire dans un fichier est donc in fine tout aussi simple que
d'crire dans la console : il suffit de dire Perl o envoyer les donnes.
Pour lire les donnes d'un fichier, vous n'allez pas franchement vous sentir dpayss non plus. Vous connaissez dj l'oprateur
qui va nous permettre de le faire, puisque vous l'avez dj utilis, mais, cette fois encore, vous ne l'avez utilis jusqu' maintenant
que dans le cas o vous ne prcisiez pas Perl o vous vouliez qu'il lise des donnes :
Code : Perl
use strict;
use warnings;
open (my $fh, '<', 'fichier_test.txt') or die "Impossible d'ouvrir
le fichier";
my $ligne = <$fh>; # Eh ouais, les diamants sont ternels !
close $fh;
print $ligne;
En effet, le petit diamant que nous utilisions pour lire une ligne entre par l'utilisateur dans la console (plus prcisment, pour lire
une ligne sur l'entre standard du programme) peut aussi tre utilis pour lire une ligne dans un fichier, si vous lui prcisez sa
provenance.
Nous allons pouvoir maintenant appliquer ces quelques notions dans un ou deux petits programmes.
53/61
Les fichiers et la boucle while

Il a srement d vous paratre surprenant que nous abordions l'interaction avec les fichiers dans un chapitre sur les boucles. En
ralit, a le serait vraiment dans n'importe quel autre langage que Perl. La diffrence avec les autres langages tient dans le fait
que Perl a t pens de telle manire ce que la syntaxe de lecture des fichiers pouse parfaitement celle de la boucle while.
En effet, lorsque Perl lit un fichier, l'instruction $ligne = <$fh>; est systmatiquement value comme tant vraie, jusqu'
ce que le fichier soit entirement lu. Ainsi, il est tout fait naturel, en Perl, de lire un fichier complet, ligne par ligne, de la faon
suivante :
Code : Perl
use strict;
use warnings;
my $filename = "fichier_test.txt";
open (my $fh, '<', $filename) or die "Erreur : impossible d'ouvrir
le fichier '$filename'";
while (my $line = <$fh>)
{
print $line;
}
close $fh;
Exercices
Numrotation de lignes
crivez un programme en Perl qui ouvre un fichier, et l'affiche en numrotant ses lignes dans la console.
Par exemple, avec ce fichier texte :
Citation : lorem ipsum
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nulla porta adipiscing
purus vitae pretium. Fusce leo libero, placerat eu lacinia non, malesuada eu
eros. Nullam mi leo, adipiscing nec sollicitudin eu, varius at velit. Donec
molestie lobortis accumsan. Vestibulum iaculis, ligula sit amet aliquet
pretium, elit elit eleifend metus, non molestie turpis turpis ac nibh. Donec
dictum nunc vel ligula commodo ac pellentesque odio blandit. Aliquam et diam eu
augue tempor rutrum. Integer eleifend lorem et arcu pellentesque interdum.
Integer ac mi leo. Cum sociis natoque penatibus et magnis dis parturient
montes, nascetur ridiculus mus. Curabitur nunc elit, pellentesque sollicitudin
congue at, gravida ac nulla. Vestibulum faucibus risus in turpis tristique
adipiscing. Vestibulum tempor, mi eu imperdiet ornare, lectus sapien dapibus
diam, eget facilisis mi enim ac sapien. Fusce vel enim justo. Etiam suscipit
iaculis commodo.
Le rsultat produit devrait ressembler ceci :

Code : Console
arnaud@laptop(perl)% perl numlignes.pl
1
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nulla porta adipiscing
2
purus vitae pretium. Fusce leo libero, placerat eu lacinia non, malesuada eu

3
4
5
6
7
8
9
10
11
12
13
54/61
eros. Nullam mi leo, adipiscing nec sollicitudin eu, varius at velit. Donec
molestie lobortis accumsan. Vestibulum iaculis, ligula sit amet aliquet
pretium, elit elit eleifend metus, non molestie turpis turpis ac nibh. Donec
dictum nunc vel ligula commodo ac pellentesque odio blandit. Aliquam et diam eu
augue tempor rutrum. Integer eleifend lorem et arcu pellentesque interdum.
Integer ac mi leo. Cum sociis natoque penatibus et magnis dis parturient
montes, nascetur ridiculus mus. Curabitur nunc elit, pellentesque sollicitudin
congue at, gravida ac nulla. Vestibulum faucibus risus in turpis tristique
adipiscing. Vestibulum tempor, mi eu imperdiet ornare, lectus sapien dapibus
diam, eget facilisis mi enim ac sapien. Fusce vel enim justo. Etiam suscipit
iaculis commodo.

Code : Perl
use strict;
use warnings;
my $filename = "/home/arnaud/prg/perl/lorem_ipsum.txt";
open (my $fh, '<', $filename)
or die "Impossible d'ouvrir le fichier '$filename' en
lecture";
my $compteur = 1;
while (my $ligne = <$fh>)
{
print "$compteur\t$ligne";
++$compteur;
}
close $fh;
Copier un fichier
crivez un programme qui recopie un fichier texte fichier_test1.txt dans un nouveau fichier appel
fichier_test2.txt.
Code : Perl
use strict;
use warnings;
my $fichier_src = "fichier_test1.txt";
my $fichier_dst = "fichier_test2.txt";
open (my $fh_src, '<', $fichier_src)
or die "impossible d'ouvrir le fichier '$fichier_src' en
lecture";
open (my $fh_dst, '>', $fichier_dst)
or die "impossible d'ouvrir le fichier '$fichier_dst' en
criture";
55/61
while (my $ligne = <$fh_src>)

{
print $fh_dst $ligne;
}
close $fh_src;
close $fh_dst;
La variable implicite $_
Il est temps maintenant de faire connaissance avec votre premier mcanisme magique en Perl. Essayez de deviner ce que fait le
programme suivant :
Code : Perl
use strict;
use warnings;
my $filename = "fichier_test.txt";
open (my $fh, '<', $filename)
or die "Erreur : impossible d'ouvrir le fichier '$filename'";
# Vous prendrez bien une petite tasse de magie noire ?
while(<$fh>)
{
print;
}
close $fh;
Cette boucle bizarre, qui semble n'utiliser aucune variable, lit le contenu d'un fichier et l'affiche dans la console. Elle repose sur le
mcanisme de la variable implicite $_ que l'on appelle et prononce "it" (comme dans rhino-pharyngite).
En Perl, chaque fois qu'une instruction est excute, sa valeur de retour est assigne cette variable spciale. C'est ce qui se
passe chaque fois que l'instruction <$fh> est excute dans le prdicat de la boucle while.
Lorsque l'on appelle ensuite la fonction print sans argument (mais ce n'est pas rserv print, a pourrait aussi tre chomp
ou une autre fonction), Perl, ne trouvant pas d'argument, va utiliser par dfaut le contenu de cette variable.
Pour illustrer ce comportement, vous pouvez essayer ceci :
Code : Perl
use strict;
use warnings;
print;
tant donn que la seule instruction de ce programme est un print sans argument (sous-entendu, qu'aucune instruction n'a
t value avant), perl va vous donner le warning suivant :
Code : Console
Use of uninitialized value $_ in print at test.pl line 4.
56/61
Comme vous le voyez, c'est bien cette variable $_ qui a t passe par dfaut print.
En dehors de cela, cette variable se comporte exactement comme toutes les autres. Vous pouvez donc lui assigner la valeur de
votre choix, par exemple. Ce comportement permet simplement d'crire beaucoup moins de code pour raliser une mme opration.
La vrit sur l'oprateur <>

Depuis le dbut de ce cours, et jusqu' ce que nous voyions ensemble que cet oprateur pouvait tre utilis avec des variables,
on vous a dit que l'instruction <>; servait lire sur l'entre standard du programme. En ralit, ce n'est pas tout fait exact. En
effet, il est aussi possible de lire dans des fichiers au moyen de cette instruction, sans mme s'embter ouvrir ceux-ci nousmmes.
Pour cela, il suffit de passer le chemin d'un fichier en argument de votre script.
Dmonstration avec le code suivant, qui reproduit, du coup, exactement le comportement de l'utilitaire cat sous unix :
Code : Perl
use strict;
use warnings;
while (<>)
{
print;
}
# Ajoutez cette ligne sous Windows, au lieu de <>;
<STDIN>;
Pour passer un fichier texte ce programme, il suffit de l'appeler comme ceci en ligne de commande :
Code : Console
arnaud@laptop(perl)% perl cat.pl lorem_ipsum.txt
Vous pouvez bien entendu lui en passer plusieurs : le programme affichera tous ces fichiers dans la console.
Si vous tes sous Windows, alternativement, il vous suffit de glisser-dposer un fichier texte sur l'icne du programme.
Nous apprendrons grer plus finement ces arguments dans le prochain chapitre.
Pour l'heure, vous remarquerez que sous Windows, nous avons utilis l'instruction <STDIN>; au lieu de <>; afin de marquer la
traditionnelle pause en fin de programme. Ceci permet de spcifier explicitement, au moyen du filehandle spcial STDIN, que
vous voulez attendre une entre utilisateur sur l'entre standard du programme (plutt que d'ventuellement lire dans un fichier).
De mme, nous aurons l'occasion de manipuler d'autres filehandles spciaux de ce type en temps voulu.
D'autres types de boucles

Maintenant que vous vous tes familiaris avec la boucle while tout au long de ce chapitre, il ne nous reste plus qu' passer
rapidement en revue les autres constructions permettant de crer des boucles, qui ne sont rien de plus que d'autres faons
d'exprimer la mme chose. There Is More Than One Way to Do It !
La boucle until
57/61
La boucle until n'est rien d'autre que le contraire du while. En effet, au lieu d'excuter une action en boucle tant que le prdicat
est vrifi, celle-ci sera effectue jusqu' ce qu'il le soit. Voici le jeu du plus ou moins implment avec une boucle until :
Code : Perl
use strict;
use warnings;
my $essai = -1;
# Rpter JUSQU' CE QUE le joueur ait trouv le nombre
until ($essai == $nb_mystere)
{
print '> ';
$essai = <>;

{
}
{
}
print "Gagn !";
La boucle do while
Une autre boucle qui dcoule directement de while est la boucle do while. Celle-ci permet d'excuter le code de la boucle
une premire fois d'office, et de le rpter si le prdicat est vrifi. En somme, cela permet d'valuer le prdicat la fin du bloc,
plutt qu'au dbut, et donc de s'affranchir de certaines initialisations qui ne sont pas trs naturelles :
Code : Perl
use strict;
use warnings;
my $essai; # Pas besoin d'initialiser cette variable
# avec une valeur arbitraire.
do
{
print '> ';

$essai = <>;

{
}
{
}
} while ($essai != $nb_mystere);
print "Gagn !";
58/61
La boucle for
Cette boucle est un petit peu plus complique que les prcdentes. En effet, au lieu de reposer sur un prdicat, celle-ci
fonctionne avec trois instructions et permet de grer facilement un compteur.
for (INITIALISATION; PRDICAT; MISE__JOUR)
O :
INITIALISATION est une instruction permettant d'initialiser son compteur,
PRDICAT est le prdicat vrifier, exactement comme dans une boucle while,
MISE__JOUR est une instruction excute la fin de chaque passage en boucle, et que l'on utilise classiquement pour
incrmenter son compteur.
Voici par exemple un programme tout simple qui compte de 0 jusqu' 30 au moyen d'une boucle for :
Code : Perl
use strict;
use warnings;
# Le compteur est initialis 0
# On compte jusqu' ce qu'il soit gal 30
# Pour le mettre jour, on incrmente sa valeur de 1
for (my $compteur = 0; $compteur <= 30; $compteur++)
{
print "$compteur\n";
}
Cette boucle for peut vous sembler droutante au premier abord. Pour vous y retrouver, gardez en tte que ce n'est qu'un
while dguis, et remarquez que ces deux constructions sont quivalentes tant que l'initialisation et la mise jour tiennent en
une seule instruction chacune :
Code : Perl
# Ceci :
INITIALISATION;
while (PREDICAT)
{
MISE_A_JOUR;
# Corps de la boucle
}
# ... est quivalent cela :
for (INITIALISATION; PREDICAT; MISE_A_JOUR)
{
# Corps de la boucle
}
La syntaxe en ligne
59/61
Enfin, concluons ce chapitre en abordant rapidement la boucle while en ligne. l'image de if et unless, il est possible de
placer un while derrire une instruction afin de rpter celle-ci.
L'exemple qui vous parlera le plus sera peut-tre ce programme qui tient en une seule ligne, et qui reproduit l'identique le
comportement de l'utilitaire cat :
Code : Perl
print while (<>);
Il est vident qu'autant de magie noire dans un seul programme est un petit peu hors de votre porte pour le moment, mais il est
tout de mme utile de vous montrer que ce genre de choses existe, afin que vous vous y habituiez, et que ces raccourcis
finissent par vous venir naturellement l'esprit lorsque vous aurez progress.
Exercice
titre d'exercice, pour conclure ce chapitre, crivez un programme qui crit la table de multiplication du nombre entr par
l'utilisateur, de 0 100, dans un fichier.
Par exemple, si l'utilisateur entre "7", votre programme devra crire dans le fichier :
Code : autre
0 x 7 = 0
1 x 7 = 7
2 x 7 = 14
[...]
99 x 7 = 693
100 x 7 = 700
crivez ce code quatre fois en utilisant respectivement une boucle while, une boucle do while, une boucle until et
une boucle for.
Selon vous, quel type de boucle est le plus adapt ce programme ? Pourquoi ?
Et la correction, o est-elle ?
Vous ne l'aurez pas cette fois ! Si votre fichier final contient la bonne sortie, c'est que votre programme fonctionne et que vous
avez compris ce chapitre. Sinon, cherchez ce qui ne fonctionne pas et corrigez-le vous-mme. Vous avez toutes les donnes et les
explications ncessaires pour russir cet exercice dans ce chapitre, et il est trs important que vous soyez capables, ds
prsent, de russir un tel exercice sans reposer sur une correction qui ne sera plus l dans la vraie vie. Allez, au boulot !
Voil un beau chapitre d'abattu !
Vous avez dcouvert beaucoup de notions nouvelles dans ce chapitre. Celles-ci vous permettront de crer des programmes de
plus en plus complexes, et de commencer interagir le contenu de votre disque dur. Prenez bien le temps de lire, voire relire ce
chapitre, afin de bien digrer ce que nous venons de voir, car nous en aurons besoin dans toute la suite du cours !
Vous avez maintenant une ide ce qu'est la programmation en Perl. Vous avez aussi assez de connaissances pour crire quelques
scripts de base. Avant de passer la suite, assurez-vous de bien avoir assimil les chapitres prcdents et, surtout, pratiquez
sans relche !
Ce tutoriel est encore en cours d'criture. N'hsitez pas laisser des commentaires sur le topic ddi, afin de nous aider le
perfectionner.
60/61
Remerciements
Merci Talus pour ses screenshots sous Windows, ainsi qu' toute l'quipe de validation du Site du Zro pour leur relecture
attentive.

Apprenez A Programmer en Perl PDF

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Apprenez A Programmer en Perl PDF

Încărcat de

Drepturi de autor:

Formate disponibile

Apprenez

Licence Creative Commons 7 2.0

Qu'est-ce que Perl ? .......................................................................................................................................................... 5

Premiers pas ................................................................................................................................................................... 11

Les branchements conditionnels .................................................................................................................................... 26

Processus itratifs et boucles ......................................................................................................................................... 45

Apprenez programmer en Perl !

Mise jour : 02/08/2012

Apprenez programmer en Perl !

En lisant ce tutoriel, qui dmarre depuis zro, vous apprendrez :

Apprenez programmer en Perl !

Partie 1 : Introduction Perl

Qu'est-ce que Perl ?

Larry Wall, crateur de Perl

Crdit photo : Randal Schwartz

Partie 1 : Introduction Perl

Que peut-on programmer en Perl ?

Partie 1 : Introduction Perl

Logo de Perl 5 ( gauche) et de Perl 6 ( droite)

Quels outils faut-il pour programmer en Perl ?

Partie 1 : Introduction Perl

Vous le trouverez cette adresse : http://notepad-plus-plus.org/fr.

Sous GNU/Linux, Mac OS X, et autres UNIX

Partie 1 : Introduction Perl

Choix d'un diteur de texte

Vim sous Ubuntu

Partie 1 : Introduction Perl

print "Hello, world!";

Lancer le programme en ligne de commande

Sous Linux et UNIX uniquement : le shebang

Partie 1 : Introduction Perl

# Active les droits d'excution

Pouah, mais c'est moche !

Partie 1 : Introduction Perl

Sauvegardez ce fichier en lui donnant le nom helloworld.pl.

Premiers lments de langage

Une instruction est un ordre

Partie 1 : Introduction Perl

Mettre le programme en pause

Partie 1 : Introduction Perl

la dcouverte des variables

Voici ce que cela va donner dans la console :

Nous allons analyser ces deux lignes en dtail.

Partie 1 : Introduction Perl

Affecter une valeur une variable

Partie 1 : Introduction Perl

Voici ce qu'il nous rpond :

Partie 1 : Introduction Perl

Partie 1 : Introduction Perl

Les chanes de caractres

Plusieurs faons d'crire une chane

Ce qui donne en console :

Les caractres chapps et les caractres spciaux

Partie 1 : Introduction Perl

print "Ceci est un passage a la ligne : \nTadaaa!\n\n";

Jugez par vous-mmes :

Interpolation et guillemets simples

Partie 1 : Introduction Perl

Oprations sur les chanes de caractres

Longueur d'une chane

Partie 1 : Introduction Perl

'$quatre_et_deux = ' . "$quatre_et_deux\n";

Partie 1 : Introduction Perl