P. 1
intro_perl

intro_perl

|Views: 8|Likes:
Published by Actu Bio

More info:

Published by: Actu Bio on Feb 16, 2011
Copyright:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as PDF, TXT or read online from Scribd
See more
See less

11/15/2011

pdf

text

original

Sections

  • Licence
  • Introduction
  • Premiers pas
  • 1.1 Ex´ecuter un programme en Perl
  • 1.2 Les types de donn´ees
  • 1.3 La notion de contexte
  • Les scalaires
  • 2.1 Les d´elimiteurs de chaˆınes de caract`eres
  • 2.2 D´eclaration et utilisation des variables
  • 2.3 La valeur undef
  • 2.4 Op´erateurs, fonctions et contexte num´eriques
  • 2.5 Op´erateurs, fonctions et contexte de chaˆınes
  • 2.6 Les op´erateurs de test
  • Structures de contrˆole
  • 3.1 Les instructions de test
  • 3.2 Les boucles
  • 3.3 Un exemple
  • Listes et tableaux
  • 4.1 Valeurs de listes
  • 4.2 Manipulation de tableaux
  • 4.3 Affectations
  • 4.4 Multi-d´eclaration
  • 4.5 Retour sur l’aplatissement des listes
  • 4.6 Absorption d’une liste par un tableau
  • 4.7 La structure de boucle foreach
  • 4.8 Fonctions de manipulation de tableaux
  • 4.9 L’op´erateur qw
  • ´Ecrire une fonction
  • 5.1 D´eclaration
  • 5.2 Appel
  • 5.3 Visibilit´e des variables
  • 5.4 Une liste pour valeur de retour
  • 5.5 Premier exemple de fonction
  • 5.6 Autre exemple : une fonction r´ecursive
  • Autres fonctions sur les listes
  • 6.1 Joindre les ´el´ements dans une chaˆıne avec join
  • 6.2 D´ecouper une chaˆıne de caract`eres en liste avec
  • 6.3 Trier une liste avec sort
  • 6.4 S´electionner des ´el´ements avec grep
  • 6.5 Appliquer un traitement `a tous les ´el´ements
  • 6.6 Un exemple : le crible d’´Eratosth`ene
  • Tables de hachage
  • 7.1 D´eclaration et initialisation
  • 7.2 Acc´eder `a un ´el´ement
  • 7.3 Parcours
  • 7.4 Autovivification
  • 7.5 Existence et suppression d’une clef
  • 7.6 Tables de hachage et listes
  • 7.7 Exemples
  • Tranches
  • 8.1 Tranches de tableau
  • 8.2 Tranches de table de hachage
  • Manipulation des fichiers
  • 9.1 Op´erateurs sur les noms de fichier
  • 9.2 La fonction glob
  • 9.3 Premiers exemples
  • 9.4 Ouverture de fichier
  • 9.5 Lecture, ´ecriture et fermeture de fichier
  • 9.6 Deuxi`eme exemple
  • 9.7 Ex´ecution de commandes avec open
  • Expressions r´eguli`eres
  • 10.1 Fonctionnalit´es
  • 10.2 Bind
  • 10.3 Caract`eres
  • 10.4 Ensembles
  • 10.5 Quantificateurs
  • 10.6 Ensembles (suite)
  • 10.7 Regroupement
  • 10.8 Alternatives
  • 10.9 Assertions
  • 10.10 R´ef´erences arri`eres
  • 10.11 Variables d´efinies
  • 10.12 Valeurs de retour de m//
  • 10.13 Exemples de probl`emes
  • 10.14 Solutions des probl`emes
  • 10.15 Choisir son s´eparateur
  • 10.16 Options
  • 10.17 Quantificateurs non-gourmands
  • 10.18 Substitution de variables dans les motifs
  • 10.19 Op´erateur tr
  • 10.20 Un dernier mot sur les expression r´eguli`eres
  • 11.1 R´ef´erences sur scalaire
  • 11.2 Utilisation des r´ef´erences sur scalaire
  • 11.3 R´ef´erences sur tableau
  • 11.4 R´ef´erences sur table de hachage
  • 11.5 R´eflexions `a propos des r´ef´erences
  • 11.6 R´ef´erences anonymes vers scalaire
  • 11.7 R´ef´erences anonymes vers tableau
  • 11.8 R´ef´erences anonymes vers table de hachage
  • 11.9 R´ef´erences anonymes diverses
  • 11.10 L’op´erateur ref
  • 11.11 R´ef´erences circulaires
  • 11.12 R´ef´erences sur fichiers
  • 11.13 R´ef´erences sur fonctions
  • 11.14 Un dernier mot sur les r´ef´erences
  • Utilisation de modules
  • 12.1 Utilisation d’un premier module
  • 12.2 D’autres modules
  • 12.3 O`u trouver les modules?
  • ´Ecrire un module
  • 13.1 Premier exemple
  • 13.2 Et les variables?
  • 13.3 De la derni`ere ligne d’un module
  • 13.4 R´epertoires
  • 13.5 Blocs BEGIN et END
  • 13.6 Introduction `a l’export de symboles
  • 13.7 Export par d´efaut de symboles
  • 13.8 Export individuel de symboles
  • 13.9 Export par tags de symboles
  • 13.10 Exemple complet d’exports
  • 13.11 Fonctions inaccessibles
  • 13.12 Documentation des modules
  • 13.13 Un dernier mot sur les modules
  • Programmation objet
  • 14.1 Vous avez dit objet?
  • 14.2 Pr´eparatifs
  • 14.3 ´Ecrire un constructeur
  • 14.4 Appeler le constructeur
  • 14.5 Manipulations de l’objet
  • 14.6 Plusieurs constructeurs
  • 14.7 ´Ecrire une m´ethode
  • 14.8 Reparlons des champs
  • 14.9 Composition
  • 14.10 Destruction d’un objet
  • 14.11 H´eritage
  • 14.12 Classes d’un objet
  • 14.13 Champs et m´ethodes statiques
  • 14.14 Exemple complet
  • Conclusion
  • L’auteur

Introduction ` a la programmation en Perl

— ou comment d´buter en Perl — e

Sylvain Lhullier Version 1.0.5 21 novembre 2004

Introduction a la programmation en Perl `

c sylvain@lhullier.org

2

Table des mati`res e
Licence Introduction 7 9

1 Premiers pas 11 1.1 Ex´cuter un programme en Perl . . . . . . . . . . . . . . . . . 11 e 1.2 Les types de donn´es . . . . . . . . . . . . . . . . . . . . . . . 13 e 1.3 La notion de contexte . . . . . . . . . . . . . . . . . . . . . . 14 2 Les 2.1 2.2 2.3 2.4 2.5 2.6 scalaires Les d´limiteurs de chaˆ e ınes de caract`res . . . e D´claration et utilisation des variables . . . . e La valeur undef . . . . . . . . . . . . . . . . . Op´rateurs, fonctions et contexte num´riques e e Op´rateurs, fonctions et contexte de chaˆ e ınes . Les op´rateurs de test . . . . . . . . . . . . . e 17 17 18 19 19 20 22

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

3 Structures de contrˆle o 25 3.1 Les instructions de test . . . . . . . . . . . . . . . . . . . . . 25 3.2 Les boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 3.3 Un exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 4 Listes et tableaux 4.1 Valeurs de listes . . . . . . . . . . . . . 4.2 Manipulation de tableaux . . . . . . . 4.3 Affectations . . . . . . . . . . . . . . . 4.4 Multi-d´claration . . . . . . . . . . . . e 4.5 Retour sur l’aplatissement des listes . 4.6 Absorption d’une liste par un tableau 4.7 La structure de boucle foreach . . . . 3 33 33 34 36 37 37 38 38

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . . .5 Existence et suppression d’une clef 7. . . 6 Autres fonctions sur les listes 6. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2 Appel . . . . . L’op´rateur qw . . .2 La fonction glob . .3 Visibilit´ des variables . . . . . . . . . . . . . . . . . . . . . . . . .6 Autre exemple : une fonction r´cursive e . . . . . . . . . . . . . . . . . . .4 Une liste pour valeur de retour . . . . . . . . . . . .1 D´claration . . . . . . .2 Acc´der a un ´l´ment .7 Ex´cution de commandes avec open . . 9. . . . . . . . .7 Exemples . . . . . . . . . . . . . . . . . . . . .6 Tables de hachage et listes . . . . . . e 40 41 43 43 44 45 46 46 47 49 49 49 50 51 52 52 55 56 56 57 58 60 61 63 ´ 5 Ecrire une fonction 5.1 D´claration et initialisation . . . . . . .6 Deuxi`me exemple . . . . . . . . . . .3 Premiers exemples . . . . . . . . . . . . . ee ıne 6. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .1 Tranches de tableau .9 c sylvain@lhullier. . . .4 Autovivification . . 5. . . . . . . . . . . . . . . . . . . .4 Ouverture de fichier . . . . . . . . . . . . . . . . . . . . . . . . . e 5. 5. . . . . . . . . 7. . . . . . . . . . . . . ´criture et fermeture de fichier e 9. . . . . . . . . 68 9 Manipulation des fichiers 9. . . . e 9. . .5 Lecture.2 D´couper une chaˆ de caract`res en liste avec split e ıne e 6. . . . . . . . .5 Premier exemple de fonction . . 8 Tranches 67 8. . . . . . . . . . . . .3 Trier une liste avec sort . . . . . e 9. . . . . . .3 Parcours . e ` ee 7. . . . . . . . . . . . . . . . . . .Introduction a la programmation en Perl ` 4. .4 S´lectionner des ´l´ments avec grep . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5. . . . . . . . . . .8 4. . . . . . . . . . .2 Tranches de table de hachage .1 Joindre les ´l´ments dans une chaˆ avec join . . . . . . . . . . . . . . . . . . . . . . . . . 7. . . . . . . . 7. . . 9. . . . . . . . e 5. . . e 7 Tables de hachage 7. . . .org Fonctions de manipulation de tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6. . . . . e 7. . . .6 Un exemple : le crible d’Eratosth`ne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .5 Appliquer un traitement a tous les ´l´ments avec map . . . . . . . . e ee 6. . . . . e 4 71 71 72 73 73 75 77 78 . . . . . . . . . . . . .1 Op´rateurs sur les noms de fichier . . . . . 9. . 67 8. . . . . ` ee ´ 6. . . . . . . . . . . . . . . . .

.14Solutions des probl`mes . . . . . . . . . . 10. . .4 R´f´rences sur table de hachage . . . e 10. . .8 ´ Ecrire une table de hachage sur disque avec les fichiers DBM 10 Expressions r´guli`res e e 10. . . . . . . . 10. . . . . . . . . ee 11. . . . . . . . . . . . . ee 11. . . . . . . . . . . . . . . . . . . . . . . . . .20Un dernier mot sur les expression r´guli`res e e 11 R´f´rences ee 11. . . . . . . . .13R´f´rences sur fonctions . . . . . . .1 R´f´rences sur scalaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .7 Regroupement . . . . . . . . . . . e 10. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2 Utilisation des r´f´rences sur scalaire . . . 10. . . .5 R´flexions a propos des r´f´rences . . . . . . . 10. . . . .18Substitution de variables dans les motifs . . .5 Quantificateurs . . . . . . . . ee 11. . . . . . . . . . . . . . .6 Ensembles (suite) . . . .15Choisir son s´parateur . . . .8 R´f´rences anonymes vers table de hachage ee 11. . . . .7 R´f´rences anonymes vers tableau . . . . . . . . . . . . . . . . . . . . . . . . ee e 10. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .12R´f´rences sur fichiers . . .12Valeurs de retour de m// . . . 10.14Un dernier mot sur les r´f´rences . . . . . . . . . . . . ee 11. . . . . . . e 10. . . . . . . . . . .11R´f´rences circulaires . . . .1 Fonctionnalit´s . . . . . ee 11. . .6 R´f´rences anonymes vers scalaire . . . . . . . . ee 11. .10R´f´rences arri`res . . . . . . . . . 10. . . . . . . . . . . . ee 11. . . . 10. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .10L’op´rateur ref . . . . . . . . 10. . . . . . . . . . e 10. .11Variables d´finies . . . . . . . . . . . . . . . . . . . . . . . . . .16Options . . e 11. .8 Alternatives . .19Op´rateur tr . . . . . . . . . . . . e 10. . . . . . . . . . . .17Quantificateurs non-gourmands . . . . . . . . . . .9 Assertions . . . . 10. . . . .4 Ensembles . . . . . . . 10. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2 Bind . . .c sylvain@lhullier. . . . . . . . . . . . . . . . . . .3 R´f´rences sur tableau . .9 R´f´rences anonymes diverses . . . . ee 5 . . . . . . . ee 11. .3 Caract`res . . . e 10. . . . . . . . . . . . . . . . . . . . . ee 11. . . . . . . . . . . . . .13Exemples de probl`mes . . . . . . e ` ee 11. . . . . e 10. . . . . . .org Introduction a la programmation en Perl ` 79 81 81 82 83 84 85 86 86 87 87 87 89 89 90 91 94 94 96 97 98 98 101 101 103 104 106 107 109 110 113 115 117 119 122 122 123 9. . . . . . . . . . . . . . . . . . . . . . . . 10. . . . . . . . . . . . . . . . . . . . . . . . . . ee 11. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14. . . . . . . . . . 14. . . . . . 127 u ´ 13 Ecrire un module 13. . . .9 Composition . . . . .org 12 Utilisation de modules 125 12. .8 Export individuel de symboles . . . . . . . . . . . . . . . 125 12. . . . . . . . . . . . .4 Appeler le constructeur . . .1 Vous avez dit objet ? . . . . . .Introduction a la programmation en Perl ` c sylvain@lhullier. . . . . . . Conclusion L’auteur . .13Champs et m´thodes statiques e 14. . . . . . . . . . . . . . . . . 129 129 130 131 132 133 134 135 135 136 137 138 139 142 143 143 144 144 146 147 149 150 152 153 156 157 160 161 163 169 171 6 . 14. . . . . .8 Reparlons des champs . . . . . . . . .13Un dernier mot sur les modules . . . . . . . . . . . . .7 Export par d´faut de symboles . . . . . . . . . . . . . . . .10Destruction d’un objet . . . . . . . . . ` 13. . . . . .11Fonctions inaccessibles . . . . .3 De la derni`re ligne d’un module . . . . . . . . . . . . . . . . . . e 14. . . . . . . 14. . . . . . . . . .5 Blocs BEGIN et END . . . . . 14. . e 14. . . . .7 Ecrire une m´thode . . . . . . . . . . . . . . . . . . . . . . . . . . 127 12. . . . . . e 13. . . . . . . . . . . . . . . . . . . . . . . . . 13. . . . . . . . . . .2 Et les variables ? . .6 Plusieurs constructeurs . . . . . 14. . . . 14. . . . . . . . . . . .11H´ritage . . . . . . . . . .1 Premier exemple . . . . . . . . . . . . . . . . 13. . . . . . . . . . e 13. . . . . 13. . 14. . .9 Export par tags de symboles . . . . . .2 D’autres modules . . . . . . . . .5 Manipulations de l’objet . . ´ 14. . . . .12Documentation des modules . . . . .1 Utilisation d’un premier module . . . . . . . . . . . . .4 R´pertoires . . . . . . . . . . . . . .12Classes d’un objet . . . . . . . . . . . . 13. . . . . . . . . . .6 Introduction a l’export de symboles . . . . . . . . . . e 13. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . e ´ 14. . . . . . . . . . . . . . . . . . . . . .14Exemple complet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13. . . . . . . . . . . . . . . . . . . . 13. . . . . . . . . . . . . . . . . 13. . . . . . . . . . . . . . . . . . .3 Ecrire un constructeur . . . . . . . . . .10Exemple complet d’exports . . . 14 Programmation objet 14. . . . . . . .3 O` trouver les modules ? . . . . . . . . . . . . . . . 13. . . . .2 Pr´paratifs . . . . . . . . . . .

lhullier.free. Permission est accord´e de copier.gnu.org/publications/perl. Pas de section inalt´rable. version 1.Licence c 2002-2003 Sylvain Lhullier Version 1. e e Vous trouverez le texte officiel de la FDL a l’adresse : ` http://www.html Ce document est y disponible en version HTML. PDF et sources DocBook. Pas de texte de derni`re page de couverture. Pas de texte de e premi`re page de couverture.1 ou toute version ult´rieure publi´e par e e la Free Software Foundation.fr/gfdlf.html Une traduction non-officielle en fran¸ais peut ˆtre lue a l’adresse : c e ` http://cesarx. distribuer et/ou modifier ce document e selon les termes de la Licence de Documentation Libre GNU (GNU Free Documentation License).5 21 novembre 2004 Vous trouverez le derni`re version de ce document a cette adresse : e ` http://sylvain.0.org/licenses/fdl.html 7 .

org 8 .Introduction a la programmation en Perl ` c sylvain@lhullier.

map { tr/A-Z/a-z/. les choses se corseront au fur et a mesure de la lecture . le shell ou awk. e Pour vous mettre en app´tit. linguistique. bases de donn´es. Sa conformit´ POSIX en fait e un alli´ indispensable a l’administrateur syst`me. manipulation de textes e (mail. s/\d//g.Introduction Voici un cours introductif a la programmation en Perl. e Ce langage tr`s riche et puissant est une boˆ a outils fort utile dans e ıte ` de nombreuses situations : administration syst`me. Ses nombreuses biblioth`e e ques le rendent vite irrempla¸able aux yeux de ceux qui en acqui`rent la c e maˆ ıtrise. } @r. foreach (sort grep !/^$/. La prise en main du langage est facilit´e par de nombreux rapproe chements possibles avec le C. Que le second m’excuse e e de passer a son goˆ t trop de temps a expliquer des notions qui lui semblent ` u ` simples . logs. @r) { print "$_\n". g´n´tique). e e e etc). mais e e patience : qui veut aller loin m´nage sa monture. mod_perl. interfaces graphiques etc. } Ce programme cr´´ une liste de mots (la phrase de la premi`re ligne). Il est issu de la ` s´rie d’articles que j’ai ´crits pour GNU/Linux & Hurd Magazine France e e entre juillet 2002 et f´vrier 2003. Vous serez sans doute un peu d´cu e¸ de ne pas faire des choses extrˆmement puissantes imm´diatement. Que le premier me pardonne de faire des comparaisons avec d’autres langages et de taire peut-ˆtre certains points qui me semblent ´vidents. ee e transforme les majuscules de ces mots en minuscules. e ` e Ce document a la d´licate ambition de s’adresser a la fois au programe ` meur d´butant et a celui qui connaˆ e ` ıtrait bien le C ou le shell... supprime les chiffres 9 . voici un petit exemple de la concision de e Perl et de sa puissance : my @r = qw(Un programme Perl est 5 fois plus rapide a ecrire). ` Le d´but du document aborde des notions importantes en Perl et n´e e cessaires pour bien comprendre la suite. programmation r´seau (CGI.

qui a la pr´tention de combiner les e avantages de plusieurs autres langages. pas de limite de buffers. modularit´.org appartenant aux mots.. avec Apache sont aussi au menu. pas d’allocation a faire e ` etc).. les tableaux. Premi`re facilit´. De plus. e Perl est un langage de haut niveau. ils sont int´gr´s a la grammaire mˆme du langage. les listes et les tables de hachage sont natifs. interface avec le C.Introduction a la programmation en Perl ` c sylvain@lhullier. acc`s au syst`me et au r´seau. e e e avec (g)Tk. c 10 . Et souvenez-vous que l’une des devises de Perl est : there is more than one way to do it (il y a plus d’une fa¸on de le faire). il g`re lui mˆme la e e e e m´moire (ramasse-miettes. e e ` e e e e programmation objet. R´cursivit´. Et dites-vous que vous aurez en main e toutes les notions n´cessaires avant la fin de la lecture du document . supprime les mots vides et affiche la liste des mots ainsi transform´s dans l’ordre lexical.

Salut Larry Ce n’est pas la fa¸on la plus courante d’´crire du Perl.Chapitre 1 Premiers pas 1. Perl est un langage a la fois interpr´t´ et compil´. un interpr´teur va lire le e code et directement agir en fonction de celui-ci.’ Le programme perl est lanc´ avec du code Perl comme argument. e directement sur la ligne de commande (option -e). En anglais. puis l’ex´cute. mais c’est une c e mani`re facile et rapide de faire un petit calcul ou de faire appel a une e ` 11 . Il n’y a pas de phase ` ee e interm´diaire de compilation car l’interpr´teur (qui se nomme perl en mie e nuscules. L’interpr´teur se e e charge donc a la fois de la compilation et de l’ex´cution. Le code sera alors ex´cut´ : la e e e fonction print affiche son argument. soliligne . uniligne. peute c ˆtre monoligne. il n’y a pas de phase de compilation. alors que le langage prend une majuscule) compile le code sans que le programmeur ne s’en rende compte. ` e Il existe trois fa¸ons distinctes de faire tourner un programme Perl : c • Mettre du code en ligne de commande. on appelle cela un one-liner (pas de traduction ´tablie en fran¸ais. Pour les seconds (les shells par e exemple)..1 Ex´cuter un programme en Perl e Il existe principalement deux types de langages : les langages compil´s e et les langages interpr´t´s.. On peut ´crire ceci dans un e shell : perl -w -e ’print("Salut Larry\n"). Pour les premiers (on retrouve par exemple dans ee cette cat´gorie le C et le C++). il existe deux phases distinctes : la come pilation des sources par un compilateur (gcc par exemple) puis l’ex´cution e du programme ainsi obtenu par le syst`me.).

Puis de lancer la commande suivante depuis un shell : perl -w salut. Enfin les options que l’on e souhaite passer a l’interpr´teur. Cette ligne (qui doit toujours ˆtre la premi`re du fichier) e e indique au syst`me d’exploitation le chemin de l’ex´cutable a lancer e e ` pour interpr´ter ce fichier. • La troisi`me fa¸on de faire est de cr´er un fichier salut2. L’option -w. Cette derni`re fa¸on de faire est sans doute la plus courante d`s que e c e l’on ´crit un programme qui sera utilis´ plusieurs fois. • La seconde mani`re de faire est de cr´er un fichier salut. Le premier caract`re doit ˆtre un di`se. Cet ine e e e e terpr´teur est lanc´ avec pour param`tres les options fournies dans le e e e shebang ainsi que le nom du fichier.pl contee e nant : print("Salut Larry\n"). etc.pl . quelques commentaires sur la syntaxe Perl. La premi`re ligne est le shebang.pl contee c e nant : #!/usr/bin/perl -w print("Salut Larry\n"). on pourrait faire un parall`le e avec l’option -Wall de gcc pour ceux qui connaissent.Introduction a la programmation en Perl ` c sylvain@lhullier./salut2. Je vous conseille donc de toujours utiliser cette option.org fonction Perl. Pour marquer les esprits.pl Le programme perl est lanc´ avec le nom du fichier en argument. Il e va alors lire le contenu de ce fichier et l’interpr´ter comme du code e Perl. Ensuite un point d’exclamation. que l’on retrouvera tout le temps. voir e a ce que r´pond type perl ou which perl). la pr´sence ou l’absence d’espaces. il signale les red´finitions de e e e e fonctions. e e Avant de continuer. le syst`me le reconnaˆ donc comme a ` e ıt un programme n´cessitant un interpr´teur pour ˆtre ex´cut´. Except´ e dans les chaˆ ınes de caract`res. ` e Il faut maintenant rendre ce fichier ex´cutable et le lancer : e chmod +x salut2. Puis le chemin e absolu vers l’ex´cutable perl (` adapter selon votre installation. ce e e e e qui a pour effet que cette ligne est consid´r´e comme un commentaire ee Perl par l’interpr´teur. de sauts e e 12 . est positionn´e dans e le but que l’interpr´teur affiche des messages d’avertissement (ware nings) a diff´rents propos : il indique les variables utilis´es une seule ` e e fois ou utilis´es avant d’ˆtre initialis´es.pl Grˆce a la ligne de shebang. bien connu des habitu´s des scripts e e en shell.

Dans les cas simples (ap` pel d’une fonction avec un ou deux param`tres).2 Les types de donn´es e Perl est un langage faiblement typ´. 1.. e e e Les tableaux permettent de stocker plusieurs scalaires en les indi¸ant.. listes en argument. Des exemples suivront. Les deux syntaxes sont tout a fait valides. Par exemple. on pourra omettre les e parenth`ses. ce qui signifie qu’une donn´e n’aura e e pas sp´cialement de type : les nombres. Les fonctions peuvent prendre leurs argue ments entre parenth`ses (comme en C) . Comme on vient de le voir. si nous e e voulons parler du i`me ´l´ment. ıt´ Un commentaire commence par un di`se (#) et se termine en fin de ligne e (comme en shell). On constitue un bloc d’instructions en les regroupant dans des accolades {} comme en C. Dans le cas de combinaisons plus complexes (plusieurs fonce tions appel´es en param`tre d’autres fonctions. il ne e e ` ee d´pendra pas de son indice dans le tableau.). les bool´ens e e etc seront tous des scalaires et ne seront diff´renci´s que par leur valeur et e e par le contexte de leur utilisation. mˆme s’ils sont un peu sp´ciaux. les chaˆ e ınes de caract`res. une instruction Perl est termin´e par un point-virgule. ıne e e On verra plus tard que les r´f´rences (c’est-`-dire les pointeurs de Perl) sont ee a des scalaires. je e e vous conseille de les mettre pour lever toute ambigu¨ e possible. l’indentation est libre.org Introduction a la programmation en Perl ` de ligne ou de tabulations ne change pas le comportement du programme. il faut aussi savoir que l’on peut se e passer de ces parenth`ses. il faudra e ee donc pr´fixer par un dollar : $t[4] est l’´l´ment d’indice 4 dans le tableau e ee 13 .c sylvain@lhullier. Il existe principalement trois structures de donn´es : les scalaires. les e tableaux et les tables de hachage. nous allons manipuler un scalaire. on pourra demander le i`me ´l´ment d’un tae c e ee bleau. Les variables de type tableau e sont pr´c´d´es d’un arobase (@) : @t est donc une variable de type tableau. i ´tant un entier. L’acc`s a un ´l´ment sera en temps constant. On aurait pu ´crire : e e print "Salut Larry\n". e e e Lorsque l’on utilise la syntaxe @t. Chaque structure de donn´es est li´e a un e e ` caract`re sp´cial (lire la suite). on d´signe la totalit´ du tableau . e e Un scalaire est une donn´e atomique. Les variables scalaires sont e e pr´c´d´es d’un dollar ($) : $x est donc une variable scalaire. c De la mˆme fa¸on qu’en C. ce pourrait ˆtre une e e chaˆ de caract`res (suite de caract`res) ou un nombre (entier ou flottant).

on parle de clefs et de ıne e ` valeurs : une valeur est associ´e a une clef. %h repr´sente la e c e totalit´ de la table de hachage . Fonctionnellement. e e Nous reviendrons sur ces types de donn´es tout au long du document. une affectation a une variable de type liste ´valuera le membre droit c ` e en contexte de liste. De la mˆme fa¸on que pour les tableaux. peuvent ˆtre tout a fait quelconques. Le contexte de chaˆ ıne ınes est un contexte o` . les e op´rateurs de test imposent un contexte pr´cis a leurs op´randes. une affectation d’une expression a une variable de type ` scalaire ´valuera cette expression dans un contexte scalaire . e e ` e Certains op´rateurs et fonctions savent dans quel contexte ils sont ape pel´s et renvoient un scalaire ou une liste selon ce contexte d’appel.org @t. a ee Une table de hachage en Perl est une structure de donn´es permettant e d’associer une chaˆ de caract`res a un scalaire . Il existe deux contextes principaux : le contexte scalaire et le contexte de liste. dans une mˆme e ` e table de hachage les clefs sont uniques . le contexte num´rique et le contexte tol´rant.Introduction a la programmation en Perl ` c sylvain@lhullier. La e fonction grep en est un bon exemple (nous verrons cela lorsque nous parlerons des listes). On peut forcer le contexte d’une expression au contexte scalaire en utilisant l’op´rateur scalar(). Par exemple. les ee accolades {} d´limitant la clef. par contre. de la mˆme e e fa¸on. e Il existe plusieurs contextes scalaires : le contexte de chaˆ ınes de caract`res. les scalaires seront consid´r´s u ee 14 . cela signifie e ` e que les op´randes sont transform´s en nombres quels que soient leur type e e et leur valeur (reste ensuite au programmeur a savoir ce que vaut une liste ` ou une chaˆ quelconque en contexte scalaire. comme son nom l’indique... Perl e sait grˆce aux crochets qu’il s’agit d’un ´l´ment de tableau). les crochets [] d´limitant l’indice (nul besoin de mettre l’arobase. les valeurs. Par exemple une e e e addition impose un contexte num´rique a ses deux op´randes .). acc´der a un ´l´ment se fera avec un dollar : e e ` ee $h{uneclef} est l’´l´ment de clef uneclef de la table de hachage %h.3 La notion de contexte Chaque op´ration en Perl est ´valu´e dans un contexte sp´cifique. Autre exemple que je d´taillerai un peu plus loin. La e e e e fa¸on dont l’op´ration se comportera peut d´pendre de ce contexte. e 1. Naturellement. Il peut c e e jouer un rˆle important sur le type des op´randes d’une expression et/ou o e sur le type de sa valeur. on pourrait voir une table e de hachage comme un tableau dont les indices peuvent ˆtre non-num´riques. Les variables de type table de hachage sont e ` pr´c´d´es d’un caract`re pourcent (%) : %h est donc une variable de type e e e e table de hachage.

C’est par exemple le contexte e utilis´ lorsque l’on appelle une fonction sans r´cup´rer sa valeur de retour. Le contexte tol´rant n’est ni de chaˆ e e ınes ni num´rique.pl line 5. Par exemple. Vous aurez l’occasion de manipuler les contextes tout au long de cette introduction au langage. la ligne d’instructions suivante : "Bonjour". le contexte est souvent important. provoque le message suivant : Useless use of a constant in void context at prog. il est simplement scalaire. mais permet a l’interpr´teur ` e Perl appel´ avec l’option -w de pr´venir en cas d’usage d’une expression e e sans effet de bord en contexte vide (c’est-`-dire une expression qui ne fait a rien et dont on ne se sert pas). Mˆme si cela n’est pas forc´ment explicite a chaque e e ` instant. e Il existe aussi un contexte vide (void context in english) qui correspond au fait que la valeur d’une expression est ignor´e. Ce contexte ` e e n’apporte pas grand chose au programmeur.c sylvain@lhullier.org Introduction a la programmation en Perl ` comme des chaˆ ınes de caract`res. e e e comme l’appel a la fonction print dans la section pr´c´dente. 15 .

Introduction a la programmation en Perl ` c sylvain@lhullier.org 16 .

Chapitre 2 Les scalaires Les scalaires sont le type de donn´es atomique de Perl. a ıne suivie d’une espace. De la mˆme ıne e mani`re "\t" est une tabulation (il existe d’autres caract`res sp´ciaux). dit autrement un e scalaire est une donn´e atome.1 Les d´limiteurs de chaˆ e ınes de caract`res e Les chaˆ ınes de caract`res ont. a Comme dit pr´c´demment. suivie du contenu de la variable $prenom. Elles e n’ont pas le mˆme rˆle : e o • Dans une chaˆ d´limit´e par des doubles quotes. c’est-`-dire que ce scalaire contiendra la chaˆ Bonjour. C++ etc) . e ıne e On aura donc aucun mal a traiter des fichiers binaires en Perl. une variable scalaire peut contenir une chaˆ e e ıne de caract`res (String en Java et autres) ou un nombre (entier ou nome bre a virgule flottante : int ou float en C.14 3e9 Contrairement au C o` le caract`re \0 de code ASCII 0 (z´ro) est le u e e marqueur de fin de chaˆ ıne. e e e Dans "Bonjour $prenom" la variable $prenom est substitu´e par son e contenu . on utilie e 17 . Cela signifie que la granularit´ de donn´es e e e ne va pas au del`. comme en shell. en Perl les chaˆ ınes de caract`res peuvent sans e souci contenir ce caract`re : "a\0f" est une chaˆ comportant 3 caract`res. le contenu est inıne e e terpr´t´ : ee "Bonjour\n" est une chaˆ suivie d’une fin de ligne. Voici des exemples de scalaires corrects : 12 "texte" ’texte’ -3. ` 2. S’il faut accoler un texte imm´diatement apr`s une variable. principalement deux e d´limiteurs possibles : les doubles quotes (") et les simples quotes (’). je ne rentrerai ` pas dans l’explication de ce ”ou”.

Puisque les variables ne sont pas substitu´es. my $y = 10. s’il s’agit d’une liste ou une table de hachage. il nous faut utiliser my : my $x. my $z = "hello". ce sont ıtre ıne e les quatre suivants : " $ @ \. aucune interpr´tation ıne e e e du contenu n’a lieu : ’Bonjour\n’ est une chaˆ comportant les caract`res B o n j o u r \ ıne e et n. e ` 2. e • Dans une chaˆ d´limit´e par des simples quotes. si c’est un scalaire. Les nombres n’ont quant a eux pas besoin de d´limiteurs pour ˆtre ma` e e nipul´s : $x = 10.2 D´claration et utilisation des variables e En Perl. La chaˆ "\$v" ne contient donc pas ıne la valeur d’une suppos´e variable $v mais contient le caract`re dollar e e et le caract`re v. les caract`res a prot´ger e e ` e sont moins nombreux . Certains caract`res doivent ˆtre ”prot´g´s” avec un anti-slash (\) si on e e e e veut les faire apparaˆ telsquels dans la chaˆ de caract`res . Par d´faut. a e e La chaˆ ’Bonjour $prenom’ ne comporte pas le contenu d’une hyıne poth´tique variable $prenom mais le caract`re dollar suivi de la chaˆ e e ıne prenom.Introduction a la programmation en Perl ` c sylvain@lhullier. e e l’usage d’une variable la cr´e .2 a la variable $x. seuls ’ et \ ont besoin d’ˆtre pr´c´d´s d’un e e e e anti-slash pour apparaˆ tels-quels dans une chaˆ d´limit´e par de ıtre ıne e e simples quotes. elle sera vide. c’est bien la variable $prefixe qui sera utilis´e. puis la chaˆ donn et enfin la variable $suffixe.org sera les accolades pour d´limiter le nom de la variable . Ces variables seront e visibles (accessibles) dans toute la suite du bloc ainsi que dans les sous-blocs 18 . je e e e vous conseille de toujours d´clarer vos variables avant de les utiliser (sauf e peut-ˆtre dans le cas de scripts de quelques lignes). par exemple e dans "il ${prefixe}donn$suffixe". Pour d’´videntes raisons de relecture et pour ´viter des erreurs bˆtes. elle aura la valeur undef e (lire plus loin) . Nous venons ici de d´clarer trois variables scalaires. Pour d´clarer une vae e riable. e ıne On notera que ces accolades n’ont rien a voir avec celles des tables de ` hachage. il n’est pas obligatoire de d´clarer les variables.2 affecte le nombre 10. c’est-`-dire 9 caract`res (notez que ’\n’ comporte 2 caract`res).

3 La valeur undef C’est une valeur particuli`re signifiant «non-d´fini». cela mˆme si e e e 19 . e c 2. il n’est pas n´cessaire de les mettre en e d´but de bloc.. On peut affecter cette valeur a une variable apr`s son initia` e lisation : $x=undef. ou undef($x). print("$phrase\n"). Le test if( $x ) . c’est-`-dire le reste de la division enti`re e a e du premier op´rande par le second.org Introduction a la programmation en Perl ` (comme en C) . Cette derni`re ligne affichera a l’´cran Bonjour Jules suivi d’un cae ` e ract`re de nouvelle ligne. comme on s’y attend. est ´quivalent a e e e ` my $x=undef. est faux si $x est non-d´finie. e Voici quelques exemples d’utilisation de variables (on suppose qu’elles sont d´j` d´clar´es) : ea e e $x = $y + 3. car cela ne fait pas ce qu’on attend. est potentiellement dangereux.. Ce test est vrai si $x est d´finie. Donc un test e e ıne if( $x ) . Si l’on veut tester qu’une variable scalaire vaut ou non undef...4 Op´rateurs. C’est aussi la valeur e e par d´faut des variables scalaires non initialis´es : my $x. il est e ´galement faux si $x vaut 0 (z´ro) ou bien la chaˆ vide. ` La valeur undef est une valeur fausse pour les tests. il faut utiliser la fonction defined : if(defined($x)). une seule bonne fa¸on : if(defined($x))../ * % . Mais comme on le verra plus tard. elles ne le seront par contre pas dans les fonctions appel´es depuis ces blocs. les op´rateurs classiques sont disponibles : + . Les habitu´s du shell noterons bien qu’une vae e riable est toujours pr´c´d´e de son dollar mˆme si elle est a gauche d’un ´gal e e e e ` e d’affectation. $phrase = "Bonjour $prenom". fonctions et contexte num´riques e e Sur les nombres... e ce dernier op´rateur % est le modulo. Une erreur classique est e a d’´crire : *incorrect* if($x!=undef) *incorrect* Ne surtout pas tenter e de comparer une variable a undef. $prenom = "Jules". Le placement des d´clarations est e e libre dans le bloc (comme en C++). c’est-`-dire si elle ne vaut pas undef. 2.c sylvain@lhullier. Notez que la division effectu´e par l’op´e e e rateur / n’est pas une division enti`re mais une division r´elle.. Pour tester si une variable est d´finie.

fonctions et contexte de chaˆ e ınes Les chaˆ ınes de caract`res ont aussi leurs op´rateurs. • sqrt($x) renvoie la racine carr´e de $x. • exp($x) log($x) renvoient e puissance $x et le logarithme en base e de $x.2blabla" vaudra 34. Dans tous les autres cas (´num´r´s dans ce qui suit)..$y et concat`ne donc $y a la fin de $x.) permet e e de concat´ner deux chaˆ e ınes : l’instruction $x="bon". il vous faut tronquer le r´sultat de la division pr´c´dente e e e e avec int() : l’expression int($x/$y) vaut le quotient de la division enti`re e de $x par $y."jour" a pour effet d’affecter la chaˆ ”bonjour” a $x (pas de gestion de la m´moire a effectuer).) .2.=$y e e est ´quivalente a $x=$x. si vous voulez effectuer une e division enti`re. Des raccourcis existent : += -= *= /= %=. Les autres valeurs scalaires (y compris undef) sont converties en 0. e Voici quelques r`gles de conversion en contexte num´rique. e ` e ` 20 . L’op´rateur x est la multiplication pour les chaˆ e ınes de caract`res : "bon"x3 e vaut "bonbonbon". e ` Les fonctions suivantes manipulent les nombres : • sin($x) cos($x) renvoient le sinus et le cosinus de $x. il suffit souvent d’utiıne liser les substitutions effectu´es dans les chaˆ e ınes d´limit´es par des doubles e e quotes pour concat´ner deux chaˆ e ınes. e ` ` e L’op´rateur ** correspond a la puissance : 2**10 vaut 1024. Il existe aussi des auto-incr´menteurs et des auto-d´cr´menteurs : ++ e e e et -. Conclusion : utilisez toujours l’option -w ! 2. Les chaˆ e e ınes de caract`res repr´sentant exactement un nombre sont converties sans probl`me . Fort sympathique . Le point (. $x++ a le mˆme effet que $x+=1 ou que $x=$x+1.6666.= x= L’expression $x. entre autres cas. Les scalaires commen¸ant c par un nombre sont converties en ce nombre : "34. en effet. Ces op´rateurs sont a la e ` fois une op´ration arithm´tique et une affectation : $x+=3 est ´quivalent e e e a $x=$x+3 mais en plus synth´tique : on ajoute 3 a $x.5 Op´rateurs. Les raccourcis suivant peuvent ˆtre utilis´s : . L’instruction $y*=5 ` e ` multiplie $y par 5. e ee l’option -w provoquera un message d’avertissement. • abs($x) renvoie la valeur absolue de $x.qui peuvent ˆtre plac´s avant ou apr`s une variable : ils ajoutent ou e e e d´duisent 1 a cette variable. utile lorsque certaines parties de la e chaˆ sont les valeurs de retour de fonctions .Introduction a la programmation en Perl ` c sylvain@lhullier. e e e "30" + "12" vaut 42.org ses op´randes sont entiers (2/3 vaut 0... ıne ` e ` Cet op´rateur est..

` • reverse($x) en contexte scalaire. ` $v vaut alors "salutation a toi". indique la position du d´but de la recherche . substr($v. l’option ıne e ıne -w provoquera un message d’avertissement. e ` En contexte de chaˆ de caract`res. un nombre vaut la chaˆ de sa repr´sentation d´cimale. dans e ce cas toute la partie droite de la chaˆ est s´lectionn´e. Dans ce contexte.$sousCha^ne.1. Par exemple ıne length("bonjour\n") vaut 8 et length(’bonjour\n’) vaut 9.$position) effectue la mˆme recherı ı e che que la fonction index mais en partant de la fin de la chaˆ (la ıne recherche est effectu´e de droite a gauche). Ce caract`re est renvoy´ par la fonction : $c = chop($l). e ıne • rindex($cha^ne. • substr($x. Les positions commencent a 0 : ` substr("bonjour".length) vaut la sous-chaˆ de position offset et de ıne longueur length.$sousCha^ne. s’il est fourni. chacun subira un sort similaire.2) vaut on. c’est-`-dire qu’on peut lui affece a ter une valeur (lvalue pour left-value : a la gauche du signe ´gal de ` e l’affectation) : my $v = "salut toi". • chop($x) supprime le dernier caract`re de la chaˆ $x (la variable $x e ıne est modifi´e). ıne e e 21 . Par exemple e $v = reverse("bonjour\n") affecte "\nruojnob" a $v. C’est l` que l’on se rend compte ` a que Perl g`re vraiment la m´moire tout seul ! e e • index($cha^ne. Cette fonction peut prendre e plusieurs arguments. renvoie la chaˆ compos´e des caıne e ract`res de $x dans l’ordre inverse. Cette fonction nous sera tr`s utile lorsque e e e nous lirons des fichiers ligne a ligne.5. On rencon` trera aussi cette fonction chez les listes (son comportement d´pend du e contexte).$position) renvoie la position de la ı ı premi`re occurrence de $sousCha^ne dans $cha^ne.org Introduction a la programmation en Perl ` Voici un certain nombre de fonctions utiles qui manipulent les chaˆ ınes de caract`res : e • length($x) renvoie la longueur de la chaˆ $x. Ne pas ´crire e *incorrect* $x=chomp($x) *incorrect* car chomp renvoie le nombre de caract`res supprim´s. La longueur peut ˆtre omise.offset.c sylvain@lhullier. e e e • chomp($x) supprime le dernier caract`re de $x s’il s’agit d’une fin e de ligne (la variable $x est modifi´e). e e sinon la recherche part du d´but de la chaˆ (position 0). undef vaut la chaˆ vide . Le troisi`me pae ı ı e ram`tre. ıne e e Cette fonction peut ˆtre une lvalue.1) = "ation a ".

La diff´rence est encore plus flagrante pour les op´rateurs d’inf´riorit´ e e e e et de sup´riorit´ .org 2. c’est-`-dire la chaˆ de caract`res ne comportant que le a ıne e caract`re z´ro (pas le caract`re \0 de code ASCII z´ro. La plus originale est "00" qui vaut l’entier 0 dans les op´rations num´e e riques.. on utilise les scalaires pour effectuer les test (comme C le fait avec les entiers).6 Les op´rateurs de test e Les bool´ens (type de donn´es ayant pour seules valeurs vrai et faux) e e n’existent pas en tant que tels en Perl. ainsi que les initi´s qui e e e ne font pas attention . Les valeurs fausses sont : • 0. Voici un tableau d´crivant les op´rateurs de tests : e e contexte impos´ e ´galit´ e e diff´rence e inf´riorit´ e e sup´riorit´ e e inf ou ´gal e sup ou ´gal e comparaison num´rique e == != < > <= >= <=> de chaˆ ınes eq ne lt gt le ge cmp Les op´rateurs bool´ens classiques sont pr´sents : e e e 22 . "blabla" etc. Confondre ou m´langer ces deux types d’op´rateurs e e est une erreur tr`s courante que font les d´butants. mais 0 de code e e e e 48). a e • "0" ou ’0’. Il me faut donc pr´ciser quelles e sont les valeurs scalaires vraies et quelles sont les fausses.Introduction a la programmation en Perl ` c sylvain@lhullier. ("02"=="2") est vrai alors que ("02" eq "2") est faux. Il existe deux cat´gories d’op´rateurs de test : ceux pour lesquels on e e impose un contexte num´rique aux op´randes et ceux pour lesquels on ime e pose un contexte de chaˆ de caract`res. mais qui est vraie . donc (9<12) est vrai alors que (9 lt 12) est faux car 9 est apr`s ınes e 1 dans la table ASCII.2.. c’est-`-dire l’entier valant z´ro. Sachez que l’option -w permet souvent de rep´rer e ces situations. • la chaˆ vide :"" ou ’’ (ce qui est la mˆme chose). lt teste l’ordre ASCII entre e e chaˆ . -4. Par exemple == teste l’´galit´ de ıne e e e deux nombres (contexte num´rique) et eq teste l’´galit´ de deux chaˆ e e e ınes (contexte de chaˆ ıne).. < teste l’ordre entre nombres.. par exemple : 1. ıne e • undef Toutes les autres valeurs sont vraies.

ils sont pr´sents e e e dans ce tableau en raison des similitudes qu’ils ont avec les op´rateurs de e test en ce qui concerne le contexte impos´ aux op´randes. Ces op´rateurs seront fort utiles e lorsque nous parlerons de la fonction sort qui effectue le tri des listes. e Cet op´rateur <=> est surnomm´ spaceship (vaisseau spatial en fran¸ais) e e c en raison de sa forme .. e e • !expr est vrai si expr est fausse. Pour l’op´rateur cmp.-) . e e e e e Les deux op´rateurs cit´s a la derni`re ligne du tableau ne sont pas des e e ` e op´rateurs de test mais des op´rateurs de comparaison . e e L’expression ($x<=>$y) est : • positive si $x est un nombre plus petit que $y. la comparaison se fait e sur l’ordre des chaˆ ınes selon la table ASCII..org Introduction a la programmation en Perl ` • expr1&&expr2 est vrai si expr1 et expr2 sont vraies (si expr1 est faux expr2 n’est pas ´valu´e). Ceux-ci ont la mˆme table e e de v´rit´ que les pr´c´dents. e • nulle si $x et $y sont des nombres ´gaux. mais sont d’une priorit´ plus faible. • n´gative si $x est un nombre plus grand que $y. Ces op´rateurs e e e renvoient un nombre qui d´pend de l’ordre entre leurs deux param`tres.c sylvain@lhullier. Il existe aussi les op´rateurs and or et not. 23 . e e • expr1||expr2 est vrai si expr1 ou expr2 est vraie (si expr1 est vrai expr2 n’est pas ´valu´e).

Introduction a la programmation en Perl ` c sylvain@lhullier.org 24 .

e Il est possible d’ex´cuter d’autres instructions dans le cas o` la condition e u est fausse. Notez que les accolades ({}) sont e e obligatoires pour d´limiter le bloc (contrairement au C).1 Les instructions de test Ces instructions permettent de conditionner l’ex´cution d’instructions a e ` la valeur de v´rit´ d’une expression. e Il faut savoir que Perl (tout comme le C) permet d’indenter notre code comme bon nous semble. } Ce code Perl a pour effet d’afficher la variable $x si elle ne vaut pas 1. En ` o effet un programme n’est pas qu’une simple suite d’instructions se d´roulant e lin´airement une fois et une seule. les exemples qui suivent comportent donc des choix personnels d’indentation qui peuvent diverger des vˆtres. lui e c aussi. elles seront alors e e toutes ex´cut´es si la condition est vraie. Plusieurs instructions peuvent ˆtre plac´es dans le bloc. est suivi d’un bloc d’instructions : 25 . o 3. Cette c expression sera ´valu´e en contexte scalaire et servira de condition . e e e e if( $x != 1 ) { print "$x\n". le bloc d’instructions sera ex´cut´. L’instruction la plus usit´e est le if (si e e e en fran¸ais) qui a besoin d’une expression et d’un bloc d’instructions. si elle e e est v´rifi´e. On utilise pour cela l’op´rateur else (sinon en fran¸ais) qui.Chapitre 3 Structures de contrˆle o Ici nous allons apprendre a contrˆler le flux des instructions en Perl.

Introduction a la programmation en Perl ` if( $x == $y ) { print "\$x et \$y sont egaux\n"; ´ } else { print "\$x et \$y sont diff´rents\n"; e }

c sylvain@lhullier.org

Le fait que les accolades sont obligatoires a pour cons´quence que le e programme suivant est incorrect : if( condition1 ) { instructions1 } else # Attention ce code est incorrect if { instructions2 } Il faut en effet entourer le second if par des accolades comme ceci : if( condition1 ) { instructions1 } else { if( condition2 ) { instructions2 } } Si le programmeur se sent des envies de devenir sylviculteur en plantant des forˆts d’ifs, il faudrait donc qu’il utilise de multiples couples d’accolades. e Pour ne pas rencontrer les mˆmes probl`mes que le Lisp en rencontre pour e e les parenth`ses ;-), Perl met a notre disposition l’instruction elsif qui e ` permet de cumuler le comportement d’un else et d’un if tout en faisant l’´conomie d’un couple d’accolades : e 26

c sylvain@lhullier.org

Introduction a la programmation en Perl `

if( condition1 ) { instructions1 } elsif( condition2 ) { instructions2 } else { instructions3 } L’instruction switch de C n’a pas d’´quivalent direct en Perl ; il faut e pour cela planter une forˆt d’ifs, comme dans l’exemple pr´c´dent. e e e Mais Perl n’en reste pas l`. Il existe une syntaxe tr`s utilis´e pour effeca e e tuer une unique instruction si une condition est v´rifi´e : e e instruction if( condition ); On parle ici de modificateur d’instruction. Pour cette syntaxe, les parenth`ses sont optionnelles autour de la condition, mais je vous conseille de e les mettre syst´matiquement pour une meilleure lisibilit´. Le code suivant e e affiche la variable $s si elle est d´finie : e print "$s\n" if( defined($s) ); On notera que cette syntaxe ne permet pas l’usage d’un else. L’instruction unless a exactement le mˆme rˆle que le if, a la diff´rence e o ` e que les instructions seront effectu´es si la condition est fausse (il est aussi e moins d´paysant d’en faire des forˆts). unless( expression ) est ´quivalent e e e a if( !(expression) ) dans toutes les constructions pr´c´demment cit´es. ` e e e

3.2

Les boucles

Les boucles permettent d’ex´cuter plusieurs fois les mˆmes instructions e e sans avoir a ´crire plusieurs fois les mˆmes lignes de code. Bien souvent ` e e nous avons besoin de modifier une variable a chaque ´tape ; dans ce cas ` e nous utiliserons l’instruction for (pour en fran¸ais) dont voici la syntaxe : c 27

Introduction a la programmation en Perl ` for( initialisation; condition; incr´ment ) e { instructions; }

c sylvain@lhullier.org

La boucle for prend trois expressions entre parenth`ses : la premi`re e e expression permet d’initialiser la variable de boucle, la deuxi`me est une e condition de continuation et la derni`re permet de modifier la valeur de la e variable de boucle. Quand la boucle d´marre, la variable est initialis´e (expression 1) et e e le test est effectu´ (expression 2). Si cette condition est v´rifi´e, le bloc e e e d’instructions est ex´cut´. Quand le bloc se termine, la variable est modifi´e e e e (expression 3) et le test est de nouveau effectu´ (expression 2). Si la condition e est v´rifi´e, le bloc d’instructions est r´-ex´cut´ avec la nouvelle valeur pour e e e e e la variable de boucle. Tant que le test reste vrai, le bloc d’instructions et l’expression de modification de la variable sont ex´cut´s. A l’arrˆt de la boucle, les instructions e e ` e qui suivent la boucle sont ex´cut´es. e e L’exemple suivant affiche tous les entiers pairs de 0 a 20 inclus : ` for( my $i=0; $i<=20; $i+=2 ) { print "$i\n"; } La boucle s’arrˆte lorsque $i vaut 22. Cette variable est d´clar´e dans e e e le bloc d’initialisation et n’existe donc que dans la boucle. Notez qu’il est tout a fait possible d’utiliser une variable pr´-existante comme variable de ` e boucle (et donc de ne pas faire de my dans la partie initialisation) ; dans ce cas, apr`s ex´cution de la boucle, la variable vaut la derni`re valeur qui lui e e e a ´t´ affect´e au cours de la boucle. ee e Une autre boucle existe : la boucle while (tant que en fran¸ais) dont c voici la syntaxe : while( condition ) { instructions; } Les instructions sont effectu´es tant que la condition est vraie. La partie e initialisation doit avoir ´t´ effectu´e avant la boucle ; la partie modification ee e de la variable doit avoir lieu dans le bloc d’instructions. 28

e e Ensuite. last if( $i > 20 ). while( $i <= 20 ) { print "$i\n". ni c l’incr´ment ni le test ne sont effectu´s. il existe une instruction until (jusqu’` en fran¸ais) qui a la a c mˆme syntaxe que le while mais qui demande une condition d’arrˆt (comme e e unless pour if) : until(condition) est ´quivalent a while(!(condition)) e ` Lors de l’ex´cution d’une boucle. e e L’exemple suivant est une autre fa¸on d’imprimer a l’´cran les entiers c ` e pairs de 0 a 20 : ` my $i = -1. certaines facilit´s sont offertes pour le while. $i+=2.org Introduction a la programmation en Perl ` L’exemple suivant affiche lui aussi les entiers pairs de 0 a 20 : ` my $i = 0. 29 . la variable $i existe apr`s la boucle. last et redo vont nous servir a cela ` ` dans les boucles for. } La seule diff´rence entre les deux exemples est le fait que. dans le cas du e while. next if( $i%2 != 0 ). e Comme pour le if. il est fr´quent de rencontrer des cas e e particuliers que l’on souhaiterait sauter ou pour lesquels on aimerait mettre fin a la boucle. Les instructions next. Elle permet d’ex´cuter plusieurs fois une instruction et une seule tant e qu’une condition est v´rifi´e. while( 1 ) # 1 est vrai { $i++. while ou until. e L’instructions last (dernier en fran¸ais) provoque la fin de la boucle. le programme ´value directement l’incr´ment (dans le cas d’une e e boucle for) puis le test est effectu´. Tout e d’abord.c sylvain@lhullier. la syntaxe suivante est correcte : instruction while( condition ). L’instructions next (suivant en fran¸ais) provoque la fin de l’ex´cution c e du bloc. e e L’instructions redo (refaire en fran¸ais) provoque le red´marrage du bloc c e d’instructions sans que la condition ni l’incr´mentation ne soient effectu´es.

org Dans le cas o` l’on souhaite ex´cuter le bloc d’instruction une fois avant u e d’effectuer le test. e Si vous parvenez a comprendre tout ce qu’il fait.). Vous verrez alors qu’en Perl on utilise beau` coup le foreach et assez peu le for(. last et redo dans le cas de la boucle do while. 3. substr( $v. $i-. 0 ) = $i.3 Un exemple Voici un petit exemple de programme Perl . on peut utiliser la syntaxe suivante : do { instruction. Elle permet d’it´rer sur les ´l´ments d’une liste (notion que nous e ee aborderons a cette occasion). il n’est pas tr`s utile dans la e vie de tous les jours. "\n") unless( $i % 3 ).. Nous verrons dans la suite qu’il existe une autre structure de boucle : foreach. } c sylvain@lhullier.Introduction a la programmation en Perl ` print "$i\n". mais il utilise beaucoup des notions abord´es jusqu’ici. } while( condition ). $i>0. } print("$v\n"). Voici le d´tail du rˆle des lignes : e o • 1 : Le shebang Perl avec l’option -w (affichage de messages d’avertissement) 30 . il ne faut pas utiliser les ` instructions next.) { print("$i impair\n") if( $i % 2 ). $i. my $v ="##########". Pour des raisons trop longues a exposer ici. for( my $i=9. vous n’aurez pas perdu ` votre temps a le lire ! ` 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: #!/usr/bin/perl -w use strict. print( "-"x$i .

e • 4 : Une boucle for. a ` chaque ´tape nous la d´cr´menterons : elle variera donc de 9 a 1.c sylvain@lhullier. je vous conseille de toujours la placer au d´but de vos programmes. e e e ` • 5 et 11 : accolades d´limitant le bloc de la boucle. ıne u • 8 et 9 : affichage d’une chaˆ dans le cas o` $i est multiple de 3. D´claration et initialisation a 9 de la variable de e ` boucle $i. e • 6 et 7 : affichage d’une chaˆ dans le cas o` $i est impair.org Introduction a la programmation en Perl ` • 2 : Cette instruction rend le langage moins permissif. e • 3 : Nous d´clarons et initialisons une variable scalaire. • 12 : Affichage de la variable $v L’affichage suivant est donc effectu´ : e 9 impair --------7 impair -----5 impair 3 impair --1 impair #1#2#3#4#5#6#7#8#9# Avez-vous tous compris ? 31 . Nous continuerons tant qu’elle est strictement positive . ıne u Cette chaˆ comporte $i caract`res moins (-). ıne e • 10 : insertion de $i dans la chaˆ $v en position $i (une longueur de ıne 0 provoque une insertion et non un remplacement).

org 32 .Introduction a la programmation en Perl ` c sylvain@lhullier.

"Bonjour $prenom") est aussi une liste . 5 et -3. La liste vide se repr´sente sous la forme suivante : () e ee e 33 . Par exemple (2. Une liste est une suite (donc ordonn´e) de valeurs scalaires.Chapitre 4 Listes et tableaux Les scalaires et les expressions de base n’ont maintenant plus aucun secret pour vous.-3) est une e e liste de 3 scalaires : 2. vous verrez tout ce qu’il est possible de faire en Perl avec ces deux concepts a priori anodins. rien ne nous empˆche d’en constituer une comportant des nombres et des chaˆ e ınes de caract`res mˆl´s. e ` Les passerelles entre listes et tableaux sont nombreuses et tr`s intuitives e en Perl. e e 4. la parcourir etc. une liste peut ˆtre repr´sent´e par les valeurs qu’elle doit contee e e nir encadr´es par un couple de parenth`ses. la manipuler. C’est pour cela que nous n’entrerons pas ici dans les d´tails de la dise tinction entre liste et tableau. en effet les listes contenant des scalaires. Des notions plus complexes et des fonctions plus puissantes sont alors a notre port´e. des tableaux et de l’impres` e sionnant arsenal de fonctions Perl permettant de les manipuler . Autre exemple (2.1 Valeurs de listes En Perl. e Une variable de type tableau peut contenir plusieurs valeurs scalaires. Nous verrons e comment cr´er une liste. j’utiliserai chacun des deux termes a bon escient sans forcement indiquer explicitement pourquoi j’utilise ` l’un plutˆt que l’autre. C’est le cas des listes. mais les notions pourront apparaˆ o ıtre naturelles au lecteur sans qu’il ne soit n´cessaire de pr´ciser les choses formellement.5. Dans ce document.’age’. Cette notion est pr´sente dans de nombreux langages de programmation et e ne posera sans doute probl`me a personne.

la liste (1.. De mani`re plus explicite.10).8.10) comporte tous les entiers de 1 a 10 . ee e e ` cette derni`re expression ´tant bien une variable de type scalaire (le dollar e e est r´serv´ aux scalaires en Perl). s’applique aussi aux listes : (2."z") comporte 37 ´l´ments (10+1+26).10. On a alors e un tableau vide. Dernier exemple.. Une telle variable se d´clare de la sorte : my @t. Notez e ee bien que la globalit´ du tableau se repr´sente au moyen d’une arobase @t e e alors qu’un ´l´ment particulier est d´sign´ a l’aide d’un dollar $t[indice].4. ` ee 4. il faut faire ainsi : e my @t = (3.10). mais ` e cette derni`re notation est bien plus lourde. On appelle cela l’aplatissement (ou la lin´arisation) des listes. c’est en fait une liste a 6 ´l´ments.10. e e On peut acc´der directement a un ´l´ment d’un tableau grˆce a son e ` ee a ` indice : $t[indice] repr´sente l’´l´ment d’indice indice du tableau @t.Introduction a la programmation en Perl ` c sylvain@lhullier. dans ce cas la liste est vide. permet de cr´er une liste comportant des e e valeurs successives entre deux bornes. On a alors d´clar´ ce tableau en l’initialisant au moyen d’une liste.2..9. Il faut savoir que les valeurs e des bornes ne doivent pas obligatoirement ˆtre des nombres : par exemple.’z’) comporte toutes les lettres de l’alphabet. en minuscule et dans l’ordre. e ` ee On aurait pu ´crire (1.12)."nom". "age"..3.2."aaa"...12. e e 34 . Pour lui donner une valeur lors de sa d´claration. La liste (1."bonjour $prenom"). que l’on a d´j` appliqu´ aux chaˆ e e e ea e ınes de caract`res pr´c´demment.-1) n’est pas une liste a 5 ´l´ments ` ee dont le troisi`me serait une autre liste.2 Manipulation de tableaux Pour simplifier les choses.’chaine’.2.("nom".-1) et on aurait obtenu la mˆme e e liste.2. Pour e constituer une liste de listes."aaa". il faudra faire usage de r´f´rences (notion que ee nous aborderons plus tard).6.10) x 3 est une e e e liste a 6 ´l´ments valant (2.2. "a". e la liste (’a’.10. on aurait pu aussi ´crire (1. Il est aussi possible de sp´cifier les bornes a l’aide de vae ` riables : ($debut.org L’op´rateur d’intervalle . c’est-`-dire sans ´l´ment.7. voici a ee e comment d´clarer un tableau vide : e my @t = ().$fin) On comprendra qu’il n’est pas toujours possible de r´soudre ce type de liste (par exemple si $debut vaut 1 et $fin vaut e ’a’). un tableau est une variable qui peut avoir une liste pour valeur. L’op´rateur de r´p´tition (x). ee La liste (1.5.

ce qui peut ˆtre vrai dans deux cas : soit l’´l´ment existe et vaut undef. e Il faut savoir que vous ne g´n´rerez pas d’erreur (d´bordement ou autre) e e e si vous tentez d’acc´der a un ´l´ment au-del` du dernier. ce qui ` signifie que le premier ´l´ment du tableau @t est $t[0] et le deuxi`me $t[1] ee e etc. ee De la mˆme fa¸on. $t[1000] = 8. e c Il est possible de connaˆ ıtre l’indice du dernier ´l´ment d’un tableau ee @t grˆce a la variable $#t On a donc $t[$#t] ´quivalent a $t[-1] (ce a ` e ` dernier ´tant bien plus lisible). $t[-2] est l’avant-dernier. etc..org Introduction a la programmation en Perl ` Les indices des tableaux en Perl commencent a 0 (comme en C)..4.23. Voici une autre illustration du fait que vous n’avez pas a vous soucier de ` probl`mes d’allocation m´moire : e e my @t = (3. 35 . # affichage d’un el´ment ´ e Il est int´ressant de savoir qu’il est possible d’acc´der au dernier ´l´ment e e ee d’un tableau en utilisant l’indice -1 : $t[-1] est le dernier ´l´ment de @t..c sylvain@lhullier..6 de Perl. l’instruction exists (que l’on retrouvera pour les tables de hachage) permet de tester l’existence d’un ´l´ment d’un tableau : ee if( exists( $t[100] ) ) { . # affectation d’un el´ment ´ e print "$t[0]\n". } Ce test sera vrai si l’´l´ment d’indice 100 du tableau @t existe. Voici un petit exemple d’utilisation de tableau : my @t = (3. La valeur de cet e ` ee a ´l´ment sera simplement undef et le programme continuera. Ce qui ee est diff´rent du test suivant : e if( defined( $t[100] ) ) { .. # d´claration et initialisation e $t[1] = 4. } Car on teste ici si l’expression $t[100] vaut undef ou non."as"). ee $x=@t donnerait la mˆme chose. Depuis la veree sion 5.. soit l’´l´ment e ee ee n’existe pas .5). Il peut ˆtre utile de savoir que l’exprese e sion scalar(@t) (c’est-`-dire l’utilisation d’un tableau en contexte scalaire) a donne le nombre d’´l´ments du tableau @t (ce qui vaut 1 de plus que $#t) .

code perl . prend celle de @s et sa taille devient celle de @s : on obtient bien deux tableaux tout a fait identiques (et distincts.2).$b) = (1. Les mˆmes affectations sont effectu´es ici. Sachez e e que. $b re¸oit le deuxi`me ´l´ment ou undef si @t il ne contient c e ee qu’un ´l´ment. Elle contient les arguments de la ligne de commande du programme.org Ce programme est correct et fonctionne parfaitement : l’affectation a l’in` dice 1000 agrandit le tableau d’autant . contrairement au langage C. La variable sp´ciale $0 (comme en shell) contient le nom du programme (nul e besoin de d´clarer cette variable pour l’utiliser). Les trois fa¸ons de lancer un programme en Perl sont susceptibles d’utiliser c @ARGV : perl -w -e ’.2.. la e e valeur 3 n’´tant d’aucune utilit´. Les ´l´ments d’indice compris entre ee 3 et 999 valent undef et scalar(@t) vaut 1001.pl arg1 arg2 arg3 .$b) = @t.$b) = (1.. ` • ($a.Introduction a la programmation en Perl ` c sylvain@lhullier.. Cette instruction affecte une valeur a chacune des ` variables de la liste de gauche : $a re¸oit 1 et $b re¸oit 2.. Le tableau @t perd ses anciennes valeurs. la ` modification de l’un n’entraˆ ınant nullement la modification de l’autre)./script. L’affectation a $a de la valeur 1 est effectu´e et $b ` e est mis a undef (son ancienne valeur est perdue). e e • ($a. c c • ($a.3). C’est si facile finalement ! Un tableau qu’il est utile de connaˆ est @ARGV. Cette instruction copie le tableau @s dans le tableau @t. Cette variable sp´ciale ıtre e est toujours d´finie (mˆme dans les fonctions) et ne n´cessite pas de d´clae e e e ration.. Voici d’autres instructions d’affectation mˆlant tableaux et listes : e • ($a.pl arg1 arg2 arg3 Ces trois programmes sont lanc´s avec les trois mˆmes arguments.3 Affectations Il est possible d’affecter un tableau a un autre tableau en une seule ` instruction : @t = @s.’ arg1 arg2 arg3 perl -w script.. e 4. Les variables cit´es a gauche re¸oivent les premi`res e ` c e valeurs du tableau @t : $a en re¸oit le premier ´l´ment ou undef si @t c ee est vide .$b) = (1). ee 36 . le nom du programme n’est pas contenu dans @ARGV qui ne comporte donc que les arguments au sens strict.

Cette affectation a eu le mˆme r´sultat qu’aurait eu la suivante : e e @t2 = (10. y compris celles d’indice diff´rent e de 0 et 1) en lui affectant les valeurs de droite : on obtient donc un tableau a deux ´l´ments.$d) = @t.$a).2). Cette instruction r´initialise le tableau @t (dont les ane ciennes valeurs sont toutes perdues. Les variables $a et $b sont cr´´es et valent undef.1.$b) = ($b.2).$b. @t2 = (10. le d´butant aurait e e tendance a ´crire la chose suivante (il n’y a pas de honte !) : `e my $a. il faut l` aussi utiliser une liste (ou un tableau) : a my ($a. Cette instruction est la plus savoureuse : on peut ´changer deux variables Perl sans avoir a en utiliser une troisi`me .c sylvain@lhullier.$b). e • ($a. # Incorrect ! Ceci est incorrect. e e 4."age". my ($c. r´sultat de l’aplatissee ee e ment du tableau @t dans la liste de droite lors de l’affectation de @t2.2. ` ee • ($a.2. mais contient les cinq ´l´ments.. Les mˆmes r`gles que pour l’affectation de listes s’appliquent ici. Nous verrons un peu plus loin comment ´crire e une fonction..5 Retour sur l’aplatissement des listes On retrouve la notion d’aplatissement des listes avec les tableaux : @t = (1. Pour leur affecter des ee valeurs."age").20).$b) = Fonction(). Pour pouvoir faire cela. 37 .$b) = (1.@t. et comment lui faire renvoyer une liste : ici l’affectation se fait dans les mˆmes conditions que pour les trois premiers cas. il nous faut utiliser une liste : my ($a.4 Multi-d´claration e Pour d´clarer plusieurs variables avec un seul my. Le tableau @t2 ne comporte pas trois ´l´ments dont celui du milieu serait ee lui-mˆme un tableau.org Introduction a la programmation en Perl ` • @t = (1.20). e ` e (Ai-je d´j` dit que Perl s’occupe lui-mˆme de la m´moire ?) ea e e 4.

"age". 10.20).Introduction a la programmation en Perl ` c sylvain@lhullier. $b) = @s. Il n’y a pas a proprement parler d’apla` tissement de liste car il s’agit ici d’une l-value (membre gauche d’une affectation).20). mais bon. Il vous est e e 38 .1. (1. D’´ventuelles c ee e autres variables qui le suivraient (cas idiot. la variable aura pour valeur un ´l´ment de la ee liste.org 4. mais la variable $a re¸oit le premier ´l´ment du tableau @s et le c ee tableau @t absorbe tous les autres (@s n’´tant bien-sˆ r pas modifi´). ($a.1. 4. Le membre gauche de l’affectation est constitu´ d’une liste comportant e une variable scalaire et un tableau.@t) = @s. Par exemple.2.7 La structure de boucle foreach Cette instruction permet de parcourir une liste. @t. Aucune modification ni supprese sion dans la liste n’est effectu´e par d´faut dans ce type de boucle. ().6 Absorption d’une liste par un tableau La syntaxe suivante est int´ressante a connaˆ : e ` ıtre ($a."age".2.) serait mises a undef ` s’il s’agit de scalaires et a vide s’il s’agit de tableaux. l’affec` tation suivante : @s = (10. @u. le premier tableau rencontr´ dans la liste de e gauche re¸oit tous les ´l´ments restant de la liste de droite. ´quivaut a : e ` @s $a @t @u $b = = = = = (10.. la liste ´tant parcourue dans l’ordre. undef. Son impl´mentation ope timis´e dans l’interpr´teur Perl rend son usage bien plus efficace qu’un pare e cours qui utiliserait une variable indicielle incr´ment´e a chaque tour d’une e e ` boucle for. Simple et intuitif..2. e u e En fait dans cette syntaxe."age". Sa syntaxe est la suivante : foreach variable ( liste ) { instructions } ` A chaque tour de boucle.20).

@t2) { . } Dans le premier cas..43. L’instruction e last met fin a la boucle. le parcours n’est pas destructif. } Comme pour les autres boucles.@t. par d´faut. dans ce cas c’est la variable sp´ciale $_ qui sera automatiquement utilis´e : e e foreach (@t) { print "$_\n".org Introduction a la programmation en Perl ` possible de modifier la variable de boucle (ce qui aura pour effet de modifier l’´l´ment en question).. } Il est aussi possible de ne pas utiliser explicitement de variable de boucle . ` Voici un petit exemple d’utilisation de foreach affichant des tables de multiplication : 39 . Le second ee exemple illustre les ph´nom`nes d’aplatissement des listes qui se retrouvent e e ici aussi. } Ce petit programme affiche chaque ´l´ment de la liste sur une ligne... } foreach $v (32."toto") { print "$v\n". Il est possible de d´clarer la variable de boucle dans le foreach de la e mani`re suivante : e foreach my $v (@t) { print "$v\n". Ces ee autres exemples sont valides eux-aussi : foreach $v (@t) { . ee e Par exemple : foreach $v (1.."age".c sylvain@lhullier.. mais. les ´l´ments du tableau @t sont parcourus. l’instruction next passe a la valeur sui` vante sans ex´cuter les instructions qui la suivent dans le bloc.

.1.6. • Ajout et suppression a gauche ` • La fonction unshift prend en arguments un tableau et une liste de valeurs scalaires .pl Usage: .4). ces valeurs sont ajout´es au d´but du tableau : e e unshift(@t./mult.pl 5 3 1 2 3 2 4 6 3 6 9 4 8 12 5 10 15 Passons a la suite.2.org 4. die("Usage: $0 <n> <n>\n") if( !defined( $ARGV[1] ) ). ` c sylvain@lhullier.2. 40 ..pl <n> <n> .5. } Et le voici a l’œuvre : ` . $i*$j ).$ARGV[1]) { printf( "%4d".3. Pour chacun des exemples qui vont suivre.3. @t vaut alors la liste (5.Introduction a la programmation en Perl ` #!/usr/bin/perl -w use strict.6). foreach my $i (1.4). je suppose que nous avons un tableau @t d´clar´ de la sorte : e e my @t = (1./mult./mult. } print "\n".$ARGV[0]) { foreach my $j (1.8 Fonctions de manipulation de tableaux Il existe de nombreuses fonctions permettant de manipuler les tableaux.

En effet. ee D’autre manipulations plus complexes du contenu d’un tableau sont possibles avec la fonction splice.9 L’op´rateur qw e L’op´rateur qw nous permet de cr´er facilement une liste de chaˆ e e ınes de caract`res. De fa¸on analogue. c’est-`-dire celle dont les ´l´ments sont pris e a ee dans le sens oppos´ : e @s = reverse(@t). une ee c file est un endroit o` le premier entr´ est le premier a sortir (first in-first out) u e ` comme pour une file a une caisse de magasin.6). On peut par exemple utiliser ` les fonctions push pour ajouter un ´l´ment et shift pour en prendre un. • La fonction pop prend un tableau en argument . il peut sembler p´nible de constituer une longue liste e e de tels ´l´ments en raison du fait qu’il faut d´limiter chacun d’entre eux au ee e moyen de simples ou de doubles quotes : 41 . il est alors envisageable de manipuler des objets algorithmiques tels que les piles et les files. e Avec de telles fonctions.2. • Ajout et suppression a droite ` • La fonction push prend en argument un tableau et une liste de valeurs scalaires . • Inversion En contexte de liste.1) et @t n’est pas modifi´e. $v vaut alors 4 et @t la liste (1. e 4. elle supprime son premier ´l´ment (les autres sont alors d´cal´s) et renvoie cet ee e e ´l´ment : ee $v = shift(@t).3). $v vaut alors 1 et @t la liste (2.3. la fonction reverse prend en argument une liste et renvoie la liste invers´e. @s vaut alors la liste (4.5. ces valeurs sont ajout´es a la fin du tableau : e ` push(@t.org Introduction a la programmation en Perl ` • La fonction shift prend un tableau en argument .2. Une pile est un lieu de stockage ayant pour particularit´ que le dernier ´l´ment a y ˆtre entr´ sera le premier e ee ` e e a en sortir (last in-first out) comme pour une pile d’assiettes sur une ´tag`re ` e e de placard.4. @t vaut alors la liste (1.4).3. elle supprime son dernier ´l´ment et renvoie cet ´l´ment : ee ee $v = pop(@t).6).3. mais je vous renvoie a la documentation pour ` les d´tails.5. On peut utiliser pour cela un tableau. avec les fonctions push pour ajouter un ´l´ment et pop pour en prendre un.2.c sylvain@lhullier.

on aurait pu ´crire : ee ee e ("attention".. e 42 . les tabulations et ıne e e e les retours a la ligne. La liste e ainsi cr´´e comporte donc 4 ´l´ments ."b^tes")."erreurs’". Cette fonction est bien pratique mais peut ˆtre source d’erreurs. ce n’est ee pas ce qui est fait ici.. ’est’. ’quelque’. ceci devient tout a coup plus lisible : ` @t = qw(Cela est bien plus facile a faire non ?). ’. En effet. ni les simples quotes ni les doubles quotes ne constituent un moyen de regrouper des mots pour l’op´rateur qw. ’´crire’. ` Les d´limiteurs les plus souvent utilis´s sont les parenth`ses (comme dans e e e l’exemple pr´c´dent) ainsi que les slashs : e e @t = qw/Ou alors comme cela . a e Avec qw. ’non’. voyez e l’exemple suivant : @t = qw/ attention ’aux erreurs’ b^tes /. ’p´nible’. e Les simples quotes (’) semblent indiquer que le programmeur souhaite constituer un seul ´l´ment comportant les mots aux et erreurs . e ’`’.org La chaˆ de caract`re sera d´coup´e selon les espaces./. ’?’ ). ` c sylvain@lhullier.’. ’peu’.Introduction a la programmation en Perl ` @t = ( ’Ceci’."’aux".

Chapitre 5 ´ Ecrire une fonction Une fonction est un ensemble d’instructions regroup´es de mani`re a ˆtre e e `e utilis´es plusieurs fois sans avoir a dupliquer du code.1 D´claration e Le mot-clef sub permet de d´finir des fonctions en Perl. } Ces quelques lignes d´finissent une nouvelle fonction dont le nom est e maJolieFonction. e Je vous conseille de toujours commencer vos fonctions par une ligne copiant les valeurs de @_ et de ne plus utiliser @_ dans la suite de la fonction (sauf cas sp´cial). e e Modifier une valeur de @_ modifiera les variables d’appel. Les arguments e d’une fonction sont des valeurs scalaires.. sub maJolieFonction { my ($x. c’est-`-dire ses trois premiers param`tres e a e (les r`gles classiques d’affectation entre listes et tableaux s’appliquent ici). a l’exclusion de toutes autres (on ` verra comment faire en sorte de passer un tableau en argument) .. Cette fonction copie dans trois variables locales les trois premi`res valeurs du tableau @_.. instructions . .$t) = @_. e ` 5. la syntaxe peut ˆtre e e e la suivante : 43 .$y. ces param`tres sont accessibles via la variable sp´ciale @_ (qui est donc un tableau). il est donc d’usage d’en faire une copie avant manipulation. Si votre fonction attend un seul param`tre. return $z..

30). e L’instruction return met fin a l’ex´cution de la fonction et on peut lui ` e fournir une expression qui sera alors la valeur de retour de la fonction. celle-ci s’appuie sur le fait que dans une sous-routine. e Enfin.@t) = @_. la variable $x aurait pour valeur le nombre de param`tres (affectation d’un tableau a un scalaire).20. Il est possible d’omettre les parenth`ses lors de l’appel a une fonction : e ` maJolieFonction 10. une autre ´criture que vous verrez souvent dans les programmes e Perl est la suivante : my $x = shift. # ` eviter A ´ 44 .20. Pour r´cup´rer e e e e cette valeur : $v = maJolieFonction(10. la variable $x re¸oit le premier param`tre et le tableau @t re¸oit tous les c e c param`tres restants.30).Introduction a la programmation en Perl ` my ($x) = @_. 5. mais ne peut pas ˆtre : e my $x = @_. l’´ventuelle valeur de retour est ignor´e. La syntaxe e ` suivante peut aussi ˆtre utile : e my ($x. Dans ce cas. #incorrect c sylvain@lhullier.org Cette ligne est incorrect car.20. la fonction shift travaille par d´faut sur @_. dans ce cas.2 Appel La fonction ainsi d´finie peut ˆtre appel´e au moyen de la syntaxe suie e e vante : maJolieFonction(10.30.

dans le code qui suit la d´claa e e e ration.. la variable $t vaudra undef . } maJolieFonction(). par contre si on l’appelle avec plus de trois arguments. il est possible d’acc´der aux variables d´finies a e e ` la ’racine’ du programme (c’est-`-dire en dehors de toute fonction) : il s’agit a donc de variables globales. 45 . Dans une fonction. Mais cette particularit´ du langage est parfois bien pratique. cela n’est pas fait par d´faut. Rien ne e nous empˆche en effet d’appeler la fonction maJolieFonction pr´c´demment e e e d´finie avec deux ou quatre arguments. print "$a\n". Si une variable locale a le mˆme nom qu’une e variable globale. print "$c\n". e e notamment pour ´crire des fonctions a nombre variable d’arguments. dans a une fonction. En particulier. cette derni`re est masqu´e par la variable locale : e e my $a = 3. print "$b\n". S’il est possible en Perl d’imposer le nombre d’arguments pour une fonction (nous n’en parlerons pas ici). si on l’appelle avec deux arguments. les valeurs suivantes seront ignor´es.. les variables d´clar´es au moyen de my sont e e e e e visibles jusqu’` la fin du plus petit bloc qui les englobe. print "$a\n". print "$c\n".org Introduction a la programmation en Perl ` mais cela peut cr´er des ambigu¨ es et je vous d´conseille donc cette e ıt´ e syntaxe.c sylvain@lhullier. # # # # affiche 5 affiche 8 modification de la variable globale affiche 15 # affiche 3 # affiche 8 # affiche 15 De mani`re plus g´n´rale. my $c = 12. my $b = 8. alors qu’elle semble en attendre e trois . print "$b\n". $c = 15. e ` 5. sub maJolieFonction { my $a = 5.3 Visibilit´ des variables e Les variables d´clar´es au moyen de my dans une fonction ne seront e e visibles qu’` l’int´rieur mˆme de la fonction.

) { my $d = 4. print "$e\n". il suffit juste d’utiliser une liste... Ces deux mani`res de proc´der peuvent parfaitement ˆtre utilis´es chae e e e cune dans les deux cas de return pr´-cit´s (ce sont toujours les mˆmes r`gles e e e e d’affectation qui s’appliquent).). ($j.Introduction a la programmation en Perl ` sub maJolieFonction2 { my $d = -3. return @t. } c sylvain@lhullier.5 Premier exemple de fonction Voici un exemple complet de programme en Perl avec une fonction : 1: 2: 3: #!/usr/bin/perl -w use strict..$z). my $t = "Bonjour Larry".org # affiche 4 # affiche 8 # affiche -3 # $e n’existe pas ici 5. print "$e\n". # variable globale 46 . } print "$d\n". print "$d\n"...).. if( .$k) = fonction(.4 Une liste pour valeur de retour Il est tout a fait possible de faire renvoyer plusieurs scalaires a une fonc` ` tion. Et voici comment il est possible de r´cup´rer ces valeurs : e e @s = fonction(. 5. Voici des exemples de syntaxe de liste renvoy´e par des fonctions : e return ($x. le tableau est converti en liste. my $e = 8. Dans le second cas.

org Introduction a la programmation en Perl ` 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: print "$t\n". l’instruction de la derni`re ligne e proc`de d’abord a l’affichage de la variable scalaire $t puis du premier et e ` deuxi`me ´l´ments du tableau @t (les crochets permettent de savoir qu’il e ee s’agit d’´l´ments d’un tableau). en revanche les variables $x. # affiche 120 Aussi lisible que dans tout autre langage.$m). Par ` e d´finition. return ($x+$z. return 1 if( $n == 1 || $n == 0 ). $z et $m sont locales a la fonction. } print Fact(5). $m).5). # retourne une liste } my @t = f(3. printf("%d\n". Elle est r´cursive (c’est-`-dire qu’elle fait e a appel a elle-mˆme) : nous allons calculer la factorielle d’un nombre. Un bon programme Perl commence toujours par les premi`re et deuxi`me e e lignes. F(0)=F(1)=1 et F(n)=n×F(n-1) pour tout n sup´rieur a 1 : e e ` sub Fact { my ($n) = @_. return $n * Fact($n-1). En ligne 12. # deux arguments attendus my $m = $x*$z. le tableau @t re¸oit ` c pour valeur la liste renvoy´e par la fonction. print "$t $t[0] $t[1]\n". Si la variable scalaire $t. en effet.$z) = @_.6 Autre exemple : une fonction r´cursive e Voici un exemple de fonction. Notez bien qu’il n’y a aucun e conflit entre les variables $t et @t . est globale. 47 . ee 5.c sylvain@lhullier. elle. # avec ou sans parenth`ses e sub f { my ($x."\n".

org 48 .Introduction a la programmation en Perl ` c sylvain@lhullier.

$y). e 6.1.3).2 D´couper une chaˆ de caract`res en liste avec e ıne e split La fonction split prend en param`tre un s´parateur et une chaˆ de cae e ıne ract`res . e e` • $s = join(" : ". concat´n´s et ıne e ee e e s´par´s par ce premier param`tre scalaire. notion que nous e e e e aborderons dans la suite. ıne • $s = join(’. Le r´sultat est affect´ a $s. 6. mais dont le minimum de connaissances suffit a ` 49 .1 Joindre les ´l´ments dans une chaˆ avec join ee ıne La fonction join prend en param`tre un scalaire et une liste . e scalaire = join( s´parateur. La variable vaut alors la concat´nation des e valeurs du tableau @t avec " : " pour s´parateur.$x. elle renvoie la liste des ´l´ments de la chaˆ de caract`res d´limit´s e ee ıne e e e par le s´parateur. Le s´parateur est une expression r´guli`re.@t). La variable $s vaut alors la chaˆ "1 2 3".Chapitre 6 Autres fonctions sur les listes Vous savez maintenant manipuler des tableaux et des listes. e Voici quelques exemples : • $s = join(" ". Les valeurs des trois variables sont jointes en les alternant avec des virgules.$y. elle renvoie e une chaˆ de caract`res comportant les ´l´ments de la liste. vous savez aussi ´crire des fonctions : vous voila arm´s pour aborder les tr`s puissantes e e e et bien pratiques fonctions de gestion qui suivent. liste ).’.2. Les arguments pass´s ne sont pas e e e e modifi´s.

e ı Voici quelques exemples : • @t = split(/-/. chaˆne ). e 50 . le bloc d’instruction sera ´valu´ pour comparer deux e e valeurs de la liste .Introduction a la programmation en Perl ` c sylvain@lhullier. ces deux valeurs sont localement affect´es aux variables e sp´ciales $a et $b qui ne sont d´finies que dans le bloc et sur lesquels il e e faut donc effectuer la comparaison. Le tableau comporte alors les ´l´ments ee 4. e • @s = sort( @t ). La liste pass´e en argument n’est pas modifi´e. 12 et 455. e e • print join(’:’. e e Voici quelques exemples : • @s = sort( {$a cmp $b} @t ). e e • n´gative."4-12-455").’salut ici’)). Il faut faire particuli`rement attention e au fait que s’il existe des variables $a et $b dans le programme elles seront localement masqu´es par ces variables sp´ciales (source courante d’erreurs). si $b doit ˆtre avant $a. e C’est l` qu’entrent en jeu les op´rateurs de comparaison cmp et <=> : a e ils permettent de comparer respectivement les chaˆ ınes de caract`res selon e l’ordre lexical et les nombres selon l’ordre num´rique. e e liste2 = sort( liste1 ). s’ils sont ´quivalents. elle renvoie une liste tri´e conform´ment au crit`re de tri constitu´ e e e e par le bloc d’instructions. la liste est tri´e selon l’ordre lexical. (attention a ne pas mettre ` de virgule entre le bloc d’instructions et la liste) Tout au long du tri. • ($x.3 Trier une liste avec sort La fonction sort prend en param`tre un bloc d’instructions optionnel et e une liste . La liste @s a pour valeur la liste @t tri´e selon l’ordre lexical. Affiche salut:ici (il existe des m´thodes plus efficaces et plus lisibles de faire cela.split(/ /. Le fonctionnement est identique a l’exemple pr´` e c´dent. e e • nulle. Si la fonction sort est e appel´e sans bloc d’instruction. e e liste = split( /s´parateur/... liste2 = sort( { comparaison } liste1 ).$y) = split(/==/. e e Le bloc doit ˆtre compos´ d’une expression dont la valeur est : e e • positive.).$v). si $a doit ˆtre avant $b dans la liste r´sultat. e 6.org cette fonction . Les arguments pass´s ne sont pas modifi´s. Les deux variables auront pour valeur les deux premi`res chaˆ e ınes de caract`res qui soient s´par´es par deux e e e signes d’´galit´. admettez ici qu’une telle expression est a placer entre slashs ` (/).

chacune des valeurs e sera localement affect´e a la variable sp´ciale $_ sur laquelle les tests devront e ` e donc ˆtre effectu´s. la fonction grep renvoie le nombre d’´l´ments qui ee correspondent au crit`re : $n = grep { . Plus d’explications ee sur les expressions r´guli`res seront donn´es dans la suite.$b) } @t ). Vous pouvez ´crire votre propre e fonction de s´lection . Une expression compos´e peut bien sˆ r servir de crit`re : le tri est ici d’abord num´rique e u e e puis lexical. Met dans @s les ´l´ments de ee @t diff´rents de 4 et de 8. e La syntaxe de grep comportant une expression r´guli`re est la suivante : e e liste2 = grep( /regexp/. soit un bloc d’instructions (cas sur lequel nous allons nous ´tendre) : e liste2 = grep { s´lection } liste1. elle doit renvoyer un noma bre dont la valeur d´pend de l’ordre voulu (voir juste avant). affecte a ` e e ` @s les ´l´ments de @t qui commencent par deux lettres a.org Introduction a la programmation en Perl ` • @s = sort( {$a <=> $b} @t ). (attention : pas de parenth`ses ni de e e virgule) Les ´l´ments renvoy´s sont ceux pour lesquels l’´valuation du bloc d’insee e e tructions a pour valeur vrai. e • @s = grep { fonction($_) } @t. La liste pass´e en ee e e argument n’est pas modifi´e. Affecte a @t les ´l´ments n´gatifs de ` ee e la liste. e e Voici quelques exemples : • @t = grep { $_<0 } $x. Durant cette ´valuation. les ´l´ments renvoy´s seront ceux qui correspondront ee e a l’expression r´guli`re. Le crit`re de tri est ici num´rique.c sylvain@lhullier.. Vous pouvez ´crire votre e propre fonction de tri (` deux arguments) . e 6. e e e 51 . e Le crit`re de s´lection peut ˆtre soit une expression r´guli`re (cas sur e e e e e lequel nous reviendrons plus tard). e e • @s = sort( {$a <=> $b or $a cmp $b} @t ).$z. • @s = grep { $_!=8 and $_!=4 } @t.$y. liste1 ). Par exemple @s = grep( /^aa/. Cela permet de placer ’8 navets’ avant ’12 carottes’. • @s = sort( { fonction($a.. En quelques mots. ` En contexte scalaire. e e e elle renvoie la liste des ´l´ments correspondant au crit`re.4 S´lectionner des ´l´ments avec grep e ee La fonction grep prend en param`tre un crit`re de s´lection et une liste . } @t. elle doit renvoyer vrai ou faux selon si l’´l´ment e ee est a garder ou non.. et ’12 carottes’ avant ’12 navets’. @t ).

Introduction a la programmation en Perl `

c sylvain@lhullier.org

J’ai affirm´ que la liste d’origine n’´tait pas modifi´e, mais il vous est e e e possible de le faire. Si, durant la s´lection, vous affectez une valeur a $_, la e ` liste sera modifi´e. Mais cela est sans doute une mauvaise id´e de modifier la e e liste pass´e en param`tre d’un grep car la fonction map est faite pour cela. e e

6.5

Appliquer un traitement ` tous les ´l´ments a ee avec map

La fonction map prend en param`tre un bloc d’instructions et une liste ; e elle applique le bloc a chacun des ´l´ments de la liste (modification possible ` ee de la liste) et renvoie la liste constitu´e des valeurs successives de l’expression e ´valu´e. e e liste2 = map( { expression } liste1 ); (attention a ne pas mettre de ` virgule entre le bloc d’instructions et la liste) La variable sp´ciale $_ vaut localement (dans le bloc d’instructions) e chaque ´l´ment de la liste. La valeur de la derni`re expression du bloc sera ee e plac´e dans la liste r´sultat. e e Voici quelques exemples : • @s = map( { -$_ } @t ); Le tableau @s aura pour valeurs les oppos´s des valeurs de @t. e • @p = map( { $_."s" } @t ); Tous les mots de @t sont mis au pluriel dans @p. • @s = map( { substr($_,0,2) } @t ); Le tableau @s aura pour valeurs les deux premiers caract`res des valeurs de @t. e • @s = map( { fonction($_) } @t ); Vous pouvez ´crire votre propre e fonction ; les valeurs qu’elle renverra seront plac´es dans @s. e Dans les exemples qui pr´c`dent, la liste d’origine n’est pas modifi´e e e e (sauf dans le dernier exemple o` elle peut l’ˆtre dans la fonction). Voici un u e exemple de modification de liste : map( { $_*=4 } @t ); Tous les ´l´ments de @t sont multipli´s par ee e quatre.

6.6

´ Un exemple : le crible d’Eratosth`ne e

Nous allons ici illustrer l’usage des listes et des tableaux par un exemple ´ math´matique : le crible d’Eratosth`ne. Cet algorithme permet de calculer e e tous les nombres premiers inf´rieurs a un nombre donn´ n. e ` e Son principe est le suivant : nous construisons tout d’abord la liste de tous les entiers de 2 a n. Ensuite, a chaque it´ration, nous supprimons de la ` ` e 52

c sylvain@lhullier.org

Introduction a la programmation en Perl `

liste tous les multiples du premier nombre de la liste et signalons ce premier nombre comme ´tant premier. Au premier tour de boucle, je supprime tous e les nombres pairs et dis que 2 est premier. Au suivant, je supprime tous les multiples de 3 et affirme que 3 est premier. Au tour suivant, c’est le 5 qui est au d´but de la liste (4 ´tant multiple de 2, il a d´j` ´t´ supprim´), j’enl`ve e e eaee e e de la liste les multiples de 5 et annonce la primalit´ de 5 etc ... L’algorithme e se termine lorsque la liste est vide, j’ai alors d´termin´ tous les nombres e e premiers inf´rieurs a n. e ` Voici la fonction r´alisant cet algorithme en Perl : e sub Crible { my ($n) = @_; # Liste initiale : my @nombres = (2..$n); # Liste des nombres premiers trouv´s : e my @premiers = (); # Tant qu’il y a des el´ments (un tableau ´ e # en contexte bool´en vaut faux s’il est vide) : e while( @nombres ) { # On extrait le premier nombre my $prem = shift @nombres; # On indique qu’il est premier push @premiers, $prem; # On supprime ses multiples @nombres = grep { ( $_ % $prem )!=0 } @nombres; } # On renvoie la liste des nombres premiers return @premiers; } Quiconque a d´j` r´alis´ cet algorithme en C ou C++ comprendra la ea e e joie que cette concision procure ...

53

Introduction a la programmation en Perl `

c sylvain@lhullier.org

54

23. ıne e Vous l’avez sans doute compris. e ` 55 .. une valeur peut ˆtre ee e e associ´e a plusieurs clefs. avoir envie de g´rer en Perl un index t´l´phonique e ee simple : chacun de mes amis a un num´ro de t´l´phone. Il s’agit bien e ee e ` d’une association chaˆ de caract`res vers scalaire. je veux pouvoir e ee retrouver leur num´ro a partir de leur pr´nom. On peut dire d’un tableau ` (notion abord´e pr´c´demment) qu’il associe une valeur scalaire a un entier : e e e ` a la position i (pour i entier). Je vais donc associer le e ` e num´ro au pr´nom : e e "Paul" -> "01. ` e Une table de hachage va nous permettre d’aller au-del` : on pourra faire a correspondre une valeur scalaire (comme pour un tableau) a toute chaˆ de ` ıne caract`res (plutˆt qu’` un entier). e o a Je peux.06. une certaine valeur scalaire est pr´sente. pour les avoir souvent utilis´es en Perl. c’est-`-dire le ”point d’entr´e” dans la table e a e de hachage (comme les indices num´raux le sont pour les tableaux). une clef n’est pr´sente qu’une seule fois et ne peut donc avoir qu’une seule valeur (comme e l’´l´ment d’un indice donn´ d’un tableau). Une table de hachage (hash table en anglais) est un type de donn´e en e Perl permettant d’associer une valeur a une clef. dans une table de hachage.67.. il est dur de repasser a des e ` langages qui n’en sont pas pourvus.06. Par contre.45. par exemple. Les e num´ros de t´l´phone seront les valeurs associ´es a ces clefs." Les pr´noms seront les clefs.89" "Virginie" -> "06.Chapitre 7 Tables de hachage Les tables de hachage de Perl ne se retrouvent pas dans beaucoup d’autres langages .06.06" "Pierre" -> "heu .

on peut uti` liser la syntaxe suivante : my %h = ( "Paul" => "01.06. alors e qu’une valeur particuli`re est d´sign´e a l’aide d’un dollar $h{clef}. On a alors une table de hachage vide (aucune clef). ce qui fait qu’un mot simple (bareword en anglais) sera converti silencieusement en chaˆ de caract`res (mˆme en positionnant l’option -w).89.23.. e des chiffres et le soulign´ (underscore en anglais ’_’).2 Acc´der ` un ´l´ment e a ee Dans une table de hachage %h.67. la totalit´ d’une c e table de hachage se repr´sente au moyen du signe pourcentage (%h).23. "Pierre" => "heu . "Virginie" => "06.23. par exemple $h{Paul} vaut 01. on peut acc´der a la valeur d’une clef e ` au moyen de la syntaxe suivante : $h{clef} . Cette derni`re table de hachage est d´clar´e et initialis´e avec les clefs e e e e Paul. ıne e e De fa¸on similaire aux tableaux avec l’arobase (@t)..06. 06. Si la clef comporte d’autres caract`res que des lettres. e e Voici quelques exemples de manipulation d’´l´ments de la table de haee chage %h : 56 .Introduction a la programmation en Perl ` c sylvain@lhullier..06.06..org 7. Il est possible de signaler explicitement que l’on d´clare une table de hachage vide : e my %h = (). Pour donner des valeurs initiales a notre table de hachage. il faut la d´limiter au e e moyen de simples ou de doubles quotes : $h{"Marie-Pierre"} ou $h{’Marie-Pierre’} En fait.06. 7. cette e e e ` derni`re expression ´tant bien une variable de type scalaire.67.45.45." ). cette syntaxe force un contexte de chaˆ de caract`res entre les ıne e accolades.89.67.45.06.89".06 et heu .1 D´claration et initialisation e Une variable de type table de hachage se d´clare de la sorte : e my %h. Virginie et Pierre ayant respectivement pour valeurs 01.06".

02.02. Elle peut mˆme ˆtre une expression plus complexe : e e sub f { return "Jac"..03." ). if( $h{"Jean-Paul"} ne "Heu .06.02. $h{$k} = "02.02".02". seule l’exhaustivit´ des clefs est garantie.45.02. e my @t = keys(%h).02. e $h{’Jean-Paul’} = "03. "Virginie" => "06.c sylvain@lhullier. nous consid´rerons que la table %h a ´t´ d´clar´e e ee e e ainsi : my %h = ( "Paul" => "01. "Paul").03.06..02.67. Dans les exemples fournis. Cette fonction va nous permettre de parcourir toute la table de hachage en effectuant une boucle sur la liste des clefs : foreach my $k (keys(%h)) { print "Clef=$k Valeur=$h{$k}\n". } $h{f().org Introduction a la programmation en Perl ` $h{Jacques} = "02..02". } La clef utilis´e pour cette syntaxe peut tout a fait ˆtre contenue dans e ` e une variable scalaire (qui sera ´valu´e en contexte de chaˆ de caract`res) : e e ıne e my $k = "Jacques".02.03.89".’ques’} = "02.23.03"... L’ordre des clefs est quelconque." ) { . 7.06".06. • keys : obtenir une liste des clefs Cette fonction prend en param`tre une table de hachage et renvoie e une liste comportant toutes les clefs de la table. Le tableau @t peut par exemple valoir la liste ("Virginie". "Pierre" => "heu .02. print "T´l : $h{Jacques}\n". } 57 .3 Parcours Il existe trois fonctions permettant de parcourir une table de hachage.02. "Pierre"..

• each : it´ration sur les couples (clef.$v) = each(%h) ) { print "Clef=$k Valeur=$v\n".valeur) e Cette fonction renvoie un a un tous les couples (clef. Il n’est bien sˆ r pas possible de retrouver la clef des valeurs que l’on u manipule ainsi.valeur) d’une table ` de hachage. l’expression $h{$k} est la valeur associ´e a la clef e ` $k. 7. je ` vous conseille de toujours l’utiliser dans la syntaxe qui suit : while( my ($k. Ce petit programme affichera donc tous les couples clef/valeur de la table %h. } Libre a vous de parcourir vos tables de hachage avec la fonction qui vous ` convient le mieux. e L’exemple suivant foreach my $v (values(%h)) { print "Valeur=$v\n".org La variable de boucle $k prendra pour valeurs successives l’ensemble des clefs de la table. il sera cr´´. } affichera tous les num´ros de t´l´phone (c’est-`-dire les valeurs) de la e ee a table %h. la fonction values fournit une liste des valeurs . elle renvoie le couple suivant ! De ce fait. Il peut ˆtre int´ressant de savoir que l’ordre des clefs renvoy´es par e e e keys et celui des valeurs par values sera le mˆme a condition de ne e ` pas modifier la table de hachage entre temps.Introduction a la programmation en Perl ` c sylvain@lhullier. • values : obtenir une liste des valeurs De la mˆme fa¸on que keys renvoie une liste des clefs d’une table de e c hachage. pour cette fonction non plus l’ordre n’est pas garanti et seule l’exhaustivit´ l’est. S’il est ee ee utilis´ dans un contexte num´rique. c’est-`-dire qu’elle ne renvoie pas toujours la mˆme chose d’un e a e appel a l’autre : en effet. il prendra pour valeur initiale z´ro. S’il e e e 58 .4 Autovivification Sous ce terme barbare se cache une id´e simple : si vous tentez de modifier e un ´l´ment d’une table de hachage qui n’existe pas. Elle a un comportement un peu sp´cial du fait qu’il faut e l’appeler autant de fois qu’il y a de couples : c’est une fonction avec ´tat.

mais elle suffira a e ` notre exemple). my %comptage = (). elle ne r`gle pas les probl`mes des e e ponctuations.= "apr`s". consid´rons une table de hachage qui ne comporte pas la e clef hello . il prendra pour valeur e ıne e la chaˆ vide (depuis Perl 5. e associe a la clef hello la valeur chaˆ vide puis lui concat`ne la chaˆ ` ıne e ıne "apr`s". Par exemple nous allons ıt e pouvoir compter le nombre d’occurrences des mots dans un texte de mani`re e tr`s simple. l’expression e e c $h{bye}++. foreach my $mot ( @texte ) { $comptage{$mot}++. Supposons que les mots du texte soient d´j` dans un tableau e ea (par exemple en utilisant la fonction qw . Nous allons utiliser chaque mot comme une clef de la table et nous allons ajouter 1 a la valeur de cette clef : ` my @texte = qw( bonjour vous bonjour ). cr´e un ´l´ment de valeur 1.6).$v) = each(%comptage) ) { print "Le mot ’$k’ est pr´sent $v fois\n". e ee Cette propri´t´ d’autovivification est bien pratique dans le cas o` l’on ee u ne connaˆ pas les clefs avant de devoir y acc´der. e } Ce qui donne l’affichage suivant : Le mot ’vous’ est pr´sent 1 fois e Le mot ’bonjour’ est pr´sent 2 fois e Dans la suite nous verrons comment d´couper un texte en mots au moyen e des expressions r´guli`res. l’expression suivante $h{hello} .c sylvain@lhullier.org Introduction a la programmation en Perl ` est utilis´ dans un contexte de chaˆ de caract`res. De la mˆme fa¸on. e e 59 . } while( my ($k. ıne Par exemple. des majuscules et des lettres accentu´es.

Introduction a la programmation en Perl ` c sylvain@lhullier.5 Existence et suppression d’une clef ` A la lecture de ce qui pr´c`de. dans les e parcours effectu´s au moyen des op´rateurs keys. e Par exemple : if( exists( $h{hello} ) ) { print "La clef ’hello’ existe\n". values ou each . delete est la bonne m´thode pour en supprimer ee e un. la clef hello aura une valeur e ind´finie.org 7. } Il est important de noter qu’un test effectu´ au moyen de l’op´rateur e e defined aurait ´t´ possible. En effet. Le d´butant pourrait ˆtre tent´ d’´crire : e e e e $h{hello} = undef. elle sera vraie si l’´l´ment existe ee ee et ne vaut pas undef. l’expression defined( ee $h{hello} ) est fausse dans deux cas tr`s diff´rents : soit si l’´l´ment n’existe e e ee pas. il en est tout autrement. il faut utiliser l’op´e rateur delete. il faut utiliser delete. les auteurs ee de Perl ont tout pr´vu :-) L’op´rateur exists renvoie vrai si l’´l´ment de e e ee table de hachage qu’on lui donne en param`tre existe . Il est donc impossible de distinguer le cas d’un ´l´ment ee absent et celui d’un ´l´ment ind´fini (valant undef) avec defined. Pour supprimer une clef dans une table de hachage. supprime la clef hello de la table %h si elle existe (si elle n’existe pas. par exemple. mais existera toujours ! On la retrouvera. Rassurez-vous. # attention! Ce qui est fort diff´rent car. ee e Cette distinction entre absent et ind´fini peut paraˆ e ıtre artificielle dans ce cas (elle peut tout de mˆme ˆtre importante dans certaines situations !). dans ce cas. e e mais dans le cas de la suppression d’une clef. ce qui e e n’est sans doute pas le but recherch´. 60 . L’instruction delete( $h{hello} ). il faut e utiliser exists et que pour en supprimer une. soit si l’´l´ment existe et vaut undef . il peut sembler impossible de savoir si e e un ´l´ment d’une table de hachage existe ou non. sinon il renvoie faux. on peut dire que pour tester l’existence d’une clef. elle ne fait rien). mais dangereux. e Pour r´sumer. De la mˆme fa¸on que exists est la bonne m´thode pour tester e c e l’existence d’un ´l´ment.

Il est a noter que cette syntaxe rappelle ´trangement l’un des premiers ` e exemple de cr´ation de table de hachage qui utilisait => pour s´parer clefs e e 61 ..06". "Virginie". En effet.89".06".23. c’est la derni`re valeur qui sera prise en compte dans la table de e hachage. voici une mani`re de savoir si une table e de hachage est vide ou non (on qualifie de vide une table de hachage qui ne comporte aucune clef). } La valeur d’un hachage en contexte scalaire n’a pas d’autre utilisation que celle-ci. par exemple. On aurait aussi pu ´crire : e my %h = ("Paul". Voyez. La premi`re instruction cr´e un tableau @t initialis´ a une liste a 6 e e e ` ` ´l´ments. par exemple de cette fa¸on : ıne e c if( %h eq 0 ) { print "%h est vide\n". Si une clef venait a ˆtre pr´sente plusieurs fois dans `e e la liste.06. "heu . "06. "01. Les valeurs du tableau sont prises deux a deux : la e e ` premi`re de chaque couple sera la clef dans la table de hachage. 7. "Pierre". Si le nombre d’´l´ments de la liste est impair.06. Une table vide est un cas particulier.06. Cette syntaxe utilise la table de hachage en contexte de chaˆ de caract`res. my %h = @t.89". la derni`re clef cr´´e ee e ee aura undef pour valeur.23.. "Pierre". le petit programme suivant : my @t = ("Paul". "01. La seconde cr´e une table de hachage %h initialis´e au moyen ee e e du pr´c´dent tableau.."). elle renverra 0. "heu .06.6 Tables de hachage et listes On peut facilement passer d’une liste (ou tableau) a une table de hachage ` et inversement.06. "06.").org Introduction a la programmation en Perl ` En marge de ces deux fonctions.06. scalar(%A) renvoie une valeur du type 4/8 qui indique le nombre de places (buckets en anglais) utilis´es par rapport au nombre e total disponibles dans le hachage.67.45.67. "Virginie".c sylvain@lhullier. la seconde e la valeur.45..

e La conversion dans l’autre sens est aussi possible.. chaque clef pr´c`de sa valeur. "heu . "01. Cette similarit´ est en fait une quasi ´quivalence.06. my %quidonc = reverse %h.89". qui nous a permis d’inverser les listes. Je vous laisse deviner ce que fait le code suivant : foreach my $x (%h) { print "$x\n".06.23.06.67.Introduction a la programmation en Perl ` c sylvain@lhullier.06.89". "06.06. certes.23. Les valeurs deviennent les clefs et inversement. "Pierre". "Virginie". mais l’ordre des couples e e (clef. e mais lors de la transformation de table de hachage en liste l’ordre est quelconque . Si plusieurs valeurs identiques sont pr´sentes le comportement est impr´visible car."..")..45. "06. "Virginie". car il force un contexte de chaˆ a sa gauche. "01.num´ro de t´l´phone est id´ale pour illustrer e ee e cela : my %h = ("Paul". } La fonction reverse. avec la liste suivante : e ("Pierre".org et valeurs. dans un ordre quelconque ` entre couples. L’association individu . "Paul".. peut ˆtre e employ´e pour inverser une table de hachage : e %h = reverse(%h). 62 .. lors de e e la transformation de liste en table de hachage la derni`re valeur compte.. par exemple. L’´valuation d’une e table de hachage dans un contexte de liste renvoie une liste des clefs et des valeurs.valeur) est quelconque (un peu comme pour la fonction each).45. se suivant respectivement deux a deux.06". il n’a ´t´ e e` e ee ajout´ au langage Perl que pour faciliter la lecture des affectations de tables e de hachage. "heu . ce qui permet ıne ` justement d’´crire %a = ( toto => ’titi’ ).06.06") . Une table de hachage se convertit en liste sans encombre d`s qu’elle est e en contexte de liste.67. Le tableau @t2 sera initialis´. car l’op´rateur e e e => peut ˆtre utilis´ a la place de la virgule pour cr´er des listes . La table de hachage %h de l’exemple pr´c´dent peut ˆtre e e e affect´e a un tableau : e ` my @t2 = %h.

c sylvain@lhullier. $ENV{HOME} vaut le nom du r´pertoire personnel de l’utilisateur qui ex´cute le proe e gramme. foreach my $i (0. # Voici mes deux ensembles # Je mets les el´ments dans des tableaux ´ e my @ensA = (1. 5. my %inter = (). 9). } } } Nous verrons dans la suite qu’il est possible de bˆtir de r´els tableaux a a e ` plusieurs dimensions en utilisant des r´f´rences.. etc.. on pourrait en effet imaginer avoir des ` clefs qui seraient la concat´nation des coordonn´es dans les n dimensions : e e dim1 :dim2 :dim3 :. par contre. ee L’exemple suivant concerne les ensembles . my @ensB = (2..org Introduction a la programmation en Perl ` On pourra alors retrouver la personne a partir de son num´ro de t´l´phone.10) { foreach my $k (130. 6. Le premier concerne la variable sp´ciale %ENV qui contient les variables e d’environnement du programme. $ENV{PATH} contient le path. 7. 63 .. Paul et Virginie avaient eu le mˆme num´ro. # les el´ments des ensembles en seront les clefs ´ e my %union = (). 3. on n’aurait pas e e pu pr´dire quel serait la personne renvoy´e. ` e ee Si. nous allons utiliser les tables de hachage pour calculer l’union et l’intersection de deux ensembles. 8). Deuxi`me exemple. my %h = (). 5. e e 7. # Voici mon union et mon intersection.$j.7 Exemples Voici quelques exemples d’utilisation des tables de hachage.4) { foreach my $j (-3.$k).. 7. 3.148) { $h{"$i:$j:$k"} = Calcul($i. les tables de hachage peuvent servir a constituer des e ` tableaux a plusieurs dimensions .

Introduction a la programmation en Perl ` # Je mets tous les el´ments de A dans l’union : ´ e foreach my $e (@ensA) { $union{$e} = 1. # Qu’une seule table . je vous laisse le soin d’en appr´cier le principe : e my @ensA = (1. # Je reconstitue des tableaux a partir ` # des tables de hachage (en les triant # pour l’affichage) my @union = sort( {$a<=>$b} keys(%union) ).. c’est qu’il est e a # dans A : je le mets donc dans l’intersection : $inter{$e} = 1 if ( exists( $union{$e} ) ). 3. # affiche : 1 2 3 5 6 7 8 9 print("@inter\n"). 5. # affiche : 3 5 7 Pour le mˆme probl`me. 8). } 64 . 3. my %hash = (). 6. my @ensB = (2. } foreach my $e (@ensB) { $hash{$e}++. foreach my $e (@ensA) { $hash{$e}++. print("@union\n"). 9). dans A et B inter. # Je le mets dans l’union $union{$e} = 1. 7. voici une solution n’utilisant qu’une seule table e e de hachage.org # S’il est d´j` dans l’union. my @inter = sort( {$a<=>$b} keys(%inter) ). 7. } # # # # Tous sont Tous sont les des les des el´ments ´ e clefs de el´ments ´ e clefs de pr´sents e la table pr´sents e la table dans A ou B union. } # Pour tous les el´ments de B : ´ e foreach my $e (@ensB) { c sylvain@lhullier.. 5.

# affiche : 1 2 3 5 6 7 8 9 print("@inter\n"). print("@union\n"). 65 .org Introduction a la programmation en Perl ` my @union = sort( {$a<=>$b} keys(%hash) ). # affiche : 3 5 7 La compr´hension de cet exemple demande d’avoir assimil´ plusieurs e e notions importantes vues jusqu’ici.c sylvain@lhullier. my @inter = sort( {$a<=>$b} ( grep { $hash{$_}==2 } keys(%hash) ) ).

Introduction a la programmation en Perl ` c sylvain@lhullier.org 66 .

Tout e ` d’abord."age").Chapitre 8 Tranches En Perl. cette instruction affecte 4321 a l’indice 4 du tableau @t et la chaˆ age ` ıne a l’indice 10. pour cela nous allons prendre la tranche coree respondante de ce tableau : @t[4.10] = (4321. les crochets permettent de sp´cifier les indices. Ensuite.$t[10]) Quelques explications sur la syntaxe. l’expression commence par une arobase. Par exemple la fonction stat prend en param`tre e 67 .. Un autre utilisation des tranches de tableau apparaˆ avec les fonctions ıt qui renvoient une liste. ee Imaginons par exemple un tableau @t duquel nous souhaiterions manipuler les ´l´ments d’indice 4 et 10 .10] est une liste a deux ´l´ments qui est ` ee ´quivalente a ($t[4]. l’ensemble des indices est indiqu´ par une liste e e d’entiers : @t[2.3] @t[3.$t[10]) = (4321. Cela s’appelle une tranche (slice en anglais). par exemple $t[4] est un scaee e e laire.. e etc) et comme l-value (expression a gauche du signe ´gal d’affectation) : ` e @t[4. car il s’agit d’une liste d’´l´ments . ` 8. le dollar est r´serv´ aux scalaires. Une telle tranche est utilisable comme valeur (passage de param`tres. Enfin.5] @t[fonction()] . comme d’habitude pour les tableaux. il est possible de manipuler plusieurs ´l´ments d’un tableau ou ee d’une table de hachage a la fois..10."age").1 Tranches de tableau Une tranche de tableau est un sous-ensemble des ´l´ments du tableau.4. On aurait pu ´crire ` e ($t[4].

$size.$ino.2 Tranches de table de hachage De la mˆme fa¸on qu’il existe des tranches pour les tableaux et les listes.$mtime. L’appel a la fonction est plac´ entre parenth`ses et on ne prend que les ` e e ´l´ments d’indice 9 et 10 de sa valeur de retour.10]. si %h est une table de hachage. # D´claration d’une table de hachage : e my %h. e Une utilisation (assez complexe) des tranches serait indiqu´e lorsque l’on e veut construire automatiquement une liste de valeurs uniques a partir d’un ` tableau dont on n’est pas sˆ r que ses valeurs soient uniques : u # Un tableau avec des valeurs dupliqu´es : e my @t = qw(hello toto hello vous).org un nom de fichier et renvoie toute sorte d’informations sur le fichier : taille.$blocks) = stat($filename).’clef2’} est une liste ´quivalente a ($h{’clef1’}.$rdev.$uid. dates.$blksize. propri´taire etc. Par exemple.$ctime. Par e e exemple. Il est courant d’´crire : e e ($dev. etc). # On prend la tranche de %h dont les clefs # sont les valeurs du tableau @t # et on leur associe la valeur undef 68 . si seules les dates de modification (indice 9) et de cr´ation (indice e 10) vous int´ressent.$h{’clef2’}) Il est ensuite pose ` sible d’utiliser cette liste comme bon vous semble (affectation.Introduction a la programmation en Perl ` c sylvain@lhullier. e c il en existe pour les tables de hachage. Les tranches peuvent intervenir si seules quelques informations vous int´ressent et que vous ne voulez pas d´clarer de variables inutiles.$nlink.$mode. $atime. passage en param`tre. alors @h{’clef1’. On a alors une liste a deux ee ` ´l´ments. La s´lection s’effectue bien sˆ r sur les e u clefs.$gid. La fonction renvoie une liste qui est affect´e aux variables de la liste e de gauche. celle-ci est affect´e a la liste a gauche du signe ´gal et donc ces ee e ` ` e deux ´l´ments sont affect´s aux deux variables. ee e 8.$ctime) = ( stat($filename) )[9. vous pouvez ´crire : e e ($mtime.

et on est s^r de ne les u # retrouver qu’une seule fois : @t = keys %h. Le tableau @t comporte alors une fois et une seule chacun de ses ´l´ments.org Introduction a la programmation en Perl ` @h{@t} = (). ee 69 . # Les clefs de %h sont donc constitu´es des e # valeurs de @t.c sylvain@lhullier.

Introduction a la programmation en Perl ` c sylvain@lhullier.org 70 .

Ceci n’exclut pas que e -f ou -d renvoie vrai. e • -d teste si son param`tre est un r´pertoire. ce e e nom de fichier doit ˆtre un scalaire (une variable ou une constante). e • -x teste si le programme a le droit d’ex´cuter le fichier ou d’acc´der e e 71 . Nous allons voir dans cette partie e comment manipuler des fichiers en Perl.Chapitre 9 Manipulation des fichiers Pour le moment nous avons ´crit des programmes dont les interactions e avec leur environnement ´taient faibles. } • -f teste si son param`tre est un fichier normal. mais la mani`re tr`s simple et tr`s puissante de les manipuler e e e font des fichiers une facilit´ de Perl. • -e teste si son param`tre est un chemin valable dans le syst`me de e e fichier (r´pertoire.1 Op´rateurs sur les noms de fichier e Perl dispose d’op´rateurs prenant en param`tre un nom de fichier . fichier. Leur e valeur de retour est souvent bool´enne et quelquefois num´rique. Les coutue e miers du shell retrouveront de nombreuses options de la commande test. • -r teste si le programme a le droit de lire le fichier/r´pertoire/etc pass´ e e en param`tre. etc). On pourrait l’utiliser ainsi : e if( -e "/usr/tmp/fichier" ) { print "Le fichier existe\n". Les fichiers se retrouvent dans tous les langages. e 9. e e • -l teste si son param`tre est un lien symbolique. e • -w teste si le programme a le droit d’´crire.

h liste tous les ` fichiers commen¸ant par une majuscule ayant l’extension . e e • -o teste si le fichier appartient a l’utilisateur qui ex´cute le programme. Apr`s l’ex´cution d’une de ces deux lignes.2 La fonction glob La fonction glob prend en argument une expression et renvoie une liste de noms de fichiers. @l = </usr/include/*. my $age = -M $file.o Notez bien qu’il ne s’agit pas d’une expression r´guli`re (pour ceux qui e e connaissent . glob( ’*.o’ ) renvoie la liste des fichiers du r´pertoire e courant ayant l’extension . • -s teste si le fichier est non vide .h c Il existe une syntaxe plus concise et au comportement identique a cette ` fonction : l’expression peut ˆtre mise entre chevrons. Les deux lignes suie vantes effectuent la mˆme op´ration : e e @l = glob(’/usr/include/*. Simple et efficace. Cette liste correspond a l’´valuation de l’expression ` e selon les wildcards du shell. en fait cet op´rateur renvoie la taille e du fichier. le tableau @l contient la liste e e des noms absolus des fichiers d’include pour le C du r´pertoire /usr/include e 72 . Par exemple. nous en parlerons plus tard). 9.org (ou ax´der :-)) au r´pertoire...h’). Il existe tout plein d’autres op´rateurs sur les fichiers . pour en connaˆ e ıtre la liste complˆte. • -M renvoie l’ˆge en jour du fichier (depuis le d´but de l’ex´cution du a e e programme).. pour les autres. je vous invite a lancer la commande perldoc -f -X e ` Voici quelques exemple d’utilisation de ces op´rateurs : e my $file = "/usr/doc/perl". mais bien d’une expression telle qu’on la donnerait a un shell : ls [A-Z]*. } my $taille = -s $file. if( -f $file && -w $file ) { .h>. ` e • -z teste si le fichier est vide.Introduction a la programmation en Perl ` c sylvain@lhullier.

c sylvain@lhullier. C’est ce descripteur qui devra ˆtre e fourni aux fonctions de lecture et d’´criture pour manipuler le fichier. } Il affiche les liens symboliques du r´pertoire courant.. print "$name : ". Pour e ne pas rentrer trop dans les d´tails.)."\n". e e e La fonction effectuant cette op´ration en Perl se nomme open et sa syntaxe e est la suivante : open( HANDLE. e Voici un second exemple : #!/usr/bin/perl -w use strict. foreach my $name ( <*> ) { print "$name\n" if( -l $name ). 9. il est n´cessaire de l’ouvrir pr´alablement. foreach my $name ( <.4 Ouverture de fichier Pour lire ou ´crire dans un fichier.3 Premiers exemples Voici un premier exemple de manipulation de noms de fichiers : #!/usr/bin/perl -w use strict. expression ) Le param`tre HANDLE sera l’identifiant du fichier apr`s ouverture (on e e pourrait parler de descripteur de fichier).org Introduction a la programmation en Perl ` 9. next if( ! -w $name ). la convention veut qu’on le mettre e e toujours en majuscules. 73 . et . <*> ) { next if( ! -d $name ). } Ce programme affiche le nom et la taille des sous-r´pertoires du r´pertoire e e courant sur lesquels j’ai les droits d’´criture (y-compris ceux commen¸ant e c par un point.*>. donc . ni de $ pour la d´buter) . un descripteur de fichier se repr´sente e e dans le code Perl par une simple chaˆ de caract`res (sans quotes pour ıne e la d´limiter. ( -s $name ) .

org Le param`tre expression est un scalaire (chaˆ de caract`res) compore ıne e tant le nom du fichier a ouvrir pr´c´d´ de z´ro. car on ne peux jamais ˆtre sˆ r de rien.html en lecture et open(FIC2. Cette fonction open renvoie une valeur bool´enne vrai ou faux indiquant e le bon d´roulement ou non de l’op´ration."</tmp/$a") or die("open: $!").html") l’ouvre en ´criture-´crasement (c’este e a-dire que le fichier sera vid´ avant que le curseur ne soit plac´ au d´but du ` e e e fichier). Vous noterez que l’utilisateur qui ex´cute le programme n’est pas e inform´ de la cause de l’´chec .txt") ) { exit(1).html") ouvre le fichier index. L’exemple suivant va nous permettre de lui afficher un joli message d’erreur : open(FIC2. tout au plus sait-il e e qu’il y a eu un probl`me avec l’ouverture de ce fichier.">index. Voici deux exemples e u de tests de la valeur de retour d’open : if( ! open(FIC. les autres valeurs sont utilis´es pour signaler au shell appelant une e erreur). un ou deux caract`res indi` e e e e e quant le mode d’ouverture : Caract`re(s) e aucun < > >> +> +< Mode d’ouverture lecture lecture ´criture (´crasement) e e ´criture (ajout) e lecture et ´criture (´crasement) e e lecture et ´criture (ajout) e Le habitu´s du shell retrouveront certaines notations connues. Il est tr`s important de tester les e e e valeurs de retour des fonctions manipulant les fichiers (cela est vrai quel que soit le langage). e Par exemple open(FIC1."<index. le programme se termine. } Dans ce premier exemple. mais il n’en connaˆ e ıt pas la cause.Introduction a la programmation en Perl ` c sylvain@lhullier. 74 . la valeur 0 signalant la fin normal du programme. on tente d’ouvrir en ajout un fichier data.">>data. on appelle la fonction exit qui met fin au programme e (la valeur 1 signale une erreur .txt . en cas d’impossibilit´.

org Introduction a la programmation en Perl ` Nous cherchons ici a ouvrir en lecture le fichier dont le nom serait la ` concat´nation de la chaˆ /tmp/ et du contenu de la variable $a. En contexte de liste.c sylvain@lhullier. En l’occurrence. C’est ce qu’il se passe ici : si open() renvoie vrai. Vous noterez bien que l’op´rateur chevrons (diamond operator en anglais) est ici e en contexte scalaire.5 Lecture. La lecture des fichiers texte s’effectue typiquement au moyen de l’op´rae teur chevrons. le d´butant e e e s’abstiendra de chercher a trop comprendre les m´canismes sous-jacents. e Les descripteurs de fichier sont d’une esp`ce ´trange en Perl. ` e Ce que l’on pourrait dire. par exemple No such file or directory ou e Permission denied etc. La fonce ıne tion die met fin au programme comme exit le ferait. c’est qu’il n’est pas n´cessaire de d´clarer un e e descripteur de fichier. En effet. la fonction open valant d´claration. il n’est pas n´cessaire e d’´valuer die(). mais affiche en plus le param`tre qu’on lui passe. il est courant de faire ainsi : e 75 . ´criture et fermeture de fichier e Une fois un fichier ouvert. cette lecture se faisant ligne par ligne. il renvoie la liste de toutes les lignes restant dans le fichier : @t = <FIC>. La syntaxe open() or die(). Cette instruction ’absorbe’ toutes les lignes du fichier dans une liste qui est plac´e dans le tableau @t. il nous est possible d’´crire et/ou de lire dedans e (selon le mode d’ouverture) et de le fermer. Cette instruction lit la prochaine ligne disponible du fichier FIC. e 9. L’utilisateur est donc inform´ de la cause de la fin e du programme. le param`tre fourni est la e e chaˆ de caract`res comportant le nom de la fonction qui cause l’´chec (on ıne e e aurait pu ajouter le nom du fichier) ainsi que la variable $!. dans l’expression (a or b) si a est vrai. e il n’est pas n´cessaire d’´valuer b pour connaˆ e e ıtre la valeur de l’expression. $l = <FIC>. e Pour it´rer sur les lignes d’un fichier. En contexte de chaˆ de caract`res. ainsi que sa signification proviennent de l’´valuation paresseuse du or. cette variable magique $! contient le message errno de ıne e la derni`re erreur survenue.

} c sylvain@lhullier. e il faut faire appel a la fonction close : ` close( FIC ). Il faut noter qu’il n’y a pas de virgule apr`s le descripteur de fichier (il e ne faut pas en mettre !). Perl ne rousp´tera pas et fermera consciencieue e sement le premier fichier avant d’ouvrir le deuxi`me. Si vous utilisez la variable sp´ciale omni-pr´sente $_. la construction e e while( defined( $_ = <FIC> ) ) peut mˆme s’abr´ger en : e e while( <FIC> ) Pour ´crire dans un fichier. e Il existe plusieurs fichiers ouverts automatiquement par Perl d`s le lane cement du programme : • STDIN : l’entr´e standard (souvent le clavier). mais permettent de lever certaines ambigu¨ es. printf( FIC "%03d". vaut le num´ro de la ligne ` e e courant du dernier fichier lu (ici FIC). ` A noter que si vous r´utilisez un descripteur de fichier dans un open sans e faire de close au pr´alable.org La boucle while donne pour valeur a la variable $l une a une toutes les ` ` lignes du fichier. $i ). La ıt´ fonction printf fonctionne comme printf ou fprintf du C et ne sera donc pas d´taill´e ici (voir man 3 printf). Les parenth`ses sont comme toujours optionnelles e autour des arguments. La variable sp´ciale $.Introduction a la programmation en Perl ` while( defined( $l = <FIC> ) ) { chomp $l. La fonction chomp supprime le dernier caract`re s’il s’agit e d’un retour a la ligne. print "$. : $l\n". e e Pour fermer un descripteur de fichier (et donc vider les buffers associ´s). nous allons utiliser les fonctions print et e printf que nous avons d´j` vues. Elles prennent en premier argument le ea descripteur de fichier : print( FIC "toto\n" ). e 76 .

si le programme est lanc´ sans argument. e e Pour ´crire des donn´es non textuelles dans un fichier.%total). mais n’est pas l’inverse de read. e • STDERR : la sortie d’erreur standard (souvent le terminal). e mais nous allons les extraire d’un fichier. e e voici leurs noms en Perl : sysopen. e Nous n’allons plus consid´rer que les mots sont contenus dans un tableau. le tampon n’est pas compl`tement rempli."<$filename. vous pouvez tout e e a fait utiliser les fonctions print et printf car les chaˆ ` ınes de caract`res de e Perl peuvent contenir le caract`re de code ASCII z´ro. S’il vous est n´cessaire d’utiliser les fonctions d’entr´e/sortie bas niveau. #!/usr/bin/perl -w use strict. mais souvent bien pratique. Discutons un peu de la manipulation de fichiers binaires.org Introduction a la programmation en Perl ` • STDOUT : la sortie standard (souvent le terminal).$word. $tailleALire ).6 Deuxi`me exemple e Voici le prolongement de l’exemple donn´ pour les tables de hachage. $tampon. Les exemples de lecture de fichiers donn´s jusqu’ici ne conviennent pas a de tels fichiers mais e ` plutˆt a des fichiers contenant du texte.@words. syswrite et close. l’entr´e standard e e est lue. foreach $word (@words) 77 . Les e ` donn´es seront plac´es dans la variable $tampon A la fin du fichier.c sylvain@lhullier. e Vous pouvez aussi faire usage de la fonction read qui lit un nombre d´termin´ e e de caract`res : $tailleLue = read( FIC. Par d´faut print et e printf ´crivent sur ce flux. $line ). ou s’il e e y a un probl`me. pour cela. C’est pour cela e e que l’on r´cup`re la valeur de retour de read. Vous pouvez. open(FILE. while( defined( $line = <FILE> ) ) { @words = split( /\W+/. my($line. utiliser la o ` fonction getc qui renvoie le prochain caract`re disponible : $c = getc(FIC). sysread. 9. e • ARGV : ce descripteur est un peu sp´cial. e Les lignes lues sont celles des fichiers de la ligne de commande (donc les arguments pass´s au programme sont consid´r´s comme des noms e ee de fichier) . On notera que la e e fonction write existe. NB : vous pouvez ´crire soit <ARGV> soit <> La variable sp´ciale e e $ARGV contient le nom du fichier en cours de lecture. Par d´faut e warn et die ´crivent sur ce flux.txt") or die"open: $!".

e ` e e La syntaxe open(HANDLE."|gzip > $a."|mail robert\@bidochon.org } close(FILE).7 Ex´cution de commandes avec open e Il est facile en Perl de lancer une commande shell et de r´cup´rer sa e e sortie standard ou de fournir son entr´e standard. } c sylvain@lhullier."commande|") par exemple : open(FIC1. ´ e e } On effectue une boucle while sur les lignes du fichier. foreach $word (sort keys %total) { print "$word a et´ rencontr´ $total{$word} fois."df -HT $device|") Les lignes lues via le descripteur de fichier ainsi cr´´ seront celles que la ee commande aurait affich´es a l’´cran si on l’avait lanc´e depuis un terminal. Chaque mot est mis en minuscules au e e e moyen de l’op´rateur tr (que nous expliquerons avec les expressions r´gue e li`res). par exemple : e open(FIC3.org") Quoi de plus simple ? 78 ."ls|") open(FIC2. e Pour lire la sortie standard d’un programme. Chaque ligne est alors d´coup´e en mots par la fonction split (\W+ correspond aux suites de e e caract`res non-alphanum´riques.\n".gz") open(FIC4. $total{$word}++. il suffit d’utiliser la syntaxe suivante : open(HANDLE. Les lignes ´crites dans le descripteur de fichier constitueront son e entr´e standard.Introduction a la programmation en Perl ` { $mot =~ tr/A-Z/a-z/. nous verrons cela dans la suite lorsque nous e e ´tudierons les expressions r´guli`res)."|commande") permet de lancer une commande. e 9.

dbmclose(%h) or die($!).0644) or die($!). il nous est possible de manipuler directement une table de hachage en la liant avec un tel fichier : les valeurs de la table de hachage et du fichier sont synchronis´es. Il comporte deux phases : ` dans la premi`re nous allons cr´er un fichier DBM comportant un couple e e clef/valeur."data".8 ´ Ecrire une table de hachage sur disque avec les fichiers DBM Le format DBM est un format de fichier de hachage (clef/valeur) standardis´. Un ensemble de fichiers data* est alors cr´´."data". Lors de cet appel a dbmopen la table %h retrouve la valeur qu’elle avait ` lors du dbmclose du premier script. dans la seconde nous utiliserons ce fichier pour retrouver ce couple. Il existe en dehors de Perl. dbmopen(%h.c sylvain@lhullier. dbmclose(%h) or die($!). Ces fichiers sont ensuite ee exploitables de la sorte : my %h. 79 . $h{’prenom’} = ’Larry’.0644) or die($!).org Introduction a la programmation en Perl ` 9. e En Perl. Pour y acc´der nous utiliserons les fonctions e e dbmopen et dbmclose Nous allons directement passer a un exemple. Premier script : my %h. dbmopen(%h. print "$h{’prenom’}\n".

Introduction a la programmation en Perl ` c sylvain@lhullier.org 80 .

sed. L’acquisition de leur maˆ e ıtrise peut s’av´rer difficile au d´but. on utilise en anglais le terme regular expression (souvent abr´g´ en regexp voire regex). Perl en tire une partie de sa grande puissance pour l’analyse et le e e traitement des donn´es textuelles. e C++ et mˆme Java. e e e Au niveau vocabulaire. e On retrouve les expressions r´guli`res dans certaines fonctions Perl que e e vous connaissez d´j`. La lecture de cette partie du document e peut aussi int´resser toute personne utilisant grep. e e matching=correspondance) et la substitution. La correspondance est le fait de tester (v´rifier) si une chaˆ de cae ıne 81 . C. PHP.Chapitre 10 Expressions r´guli`res e e Nous abordons ici un sujet tr`s riche en d´veloppements : les expressions e e r´guli`res. La seconde est entr´e dans les mœurs et sera donc e e e utilis´e ici.1 Fonctionnalit´s e Il existe deux types principaux de fonctionnalit´s dans les expressions e r´guli`res : la correspondance (pattern matching en anglais : pattern=motif. ce qui a donn´ en fran¸ais une trae e e c duction correcte ”expressions rationnelles” et une traduction mot a mot ` ”expressions r´guli`res”. les expres` sions r´guli`res permettent de manipuler le texte de fa¸on tr`s puissante et e e c e tr`s concise. aussi bien pour programmer en e Perl que pour utiliser les outils classiques du shell ou les autres langages pr´c´demment cit´s. comme par exemple split ou grep . mais elles existent ea aussi par le biais d’op´rateurs sp´cifiques. Python. e Atout important de Perl par rapport a d’autres langages. e e mais en vaut tr`s largement la chandelle. e e 10.

La substitution permet de faire subir des transformations a la valeur ` d’une variable.2 Bind Pour ”lier” une variable a une telle expression. Etc. les slashes (/) servent a d´limiter le motif recherch´ ainsi que la chaˆ de remplacement. il faut utiliser l’op´rateur ` e =~ (dit bind en anglais). $v =~ m/sentier/ v´rifie si la variable $v comporte le mot sentier. Sa syntaxe est la suivante : s/motif/chaˆne/ ı Le s indique que nous voulons faire une substitution. nous venons de lier une expression r´guli`re e e e a une variable.Introduction a la programmation en Perl ` c sylvain@lhullier. e e Par cette op´ration de bind. Supprimer de $v tous les mots entre guillemets. On e dit alors que la variable est ”li´e” a l’expression r´guli`re. Par exemple. nous l’utiliserons donc tr`s souvent dans une structure e de contrˆle de type if : o if( $v =~ m/sentier/ ) { instructions } Dans les cas o` le test est vrai. les instructions seront ex´cut´es. Cette expression e ` e e vaut vrai ou faux . on pourrait se poser les e questions suivantes et y r´pondre par un match : la variable $v commencee t-elle par un chiffre ? Comporte-t-elle au moins deux lettres majuscules ? Contient-elle une sous-chaˆ r´p´t´e deux fois d’au moins 5 caract`res ? ıne e e e e Etc. si je veux r´cup´rer e e e le premier nombre que comporte $v. j’utiliserai aussi la correspondance. e Cette fonctionnalit´ nous permettra aussi d’extraire des sous-chaˆ e ınes d’une variable donn´e sans la modifier.org ract`res comporte un certain motif. Par exemple. ` e e ıne 10. une telle expression s’applique a la variable $_ ` e ` (comme beaucoup de fonctions Perl). les slashes (/) servent a ` d´limiter le motif recherch´ (on verra plus loin comment utiliser d’autres e e s´parateurs). e c 82 . Par exemple : remplacer dans la variable $v toutes les souschaˆ ınes toto par titi. Sa syntaxe est la suivante : m/motif/ Le m indique que nous voulons faire un match. c’est-`-dire si la variable contient le motif u a (ici si $v contient sentier). De la mˆme fa¸on. Par d´faut.

remplace la premi`re occurrence de voiture dans la variable $v par e pieds (on verra plus loin comment remplacer toutes les occurrences). un caract`re vaut pour lui mˆme . e if( $w !~ m/pieds/ ) { . il existe aussi l’op´rateur !~ qui ´quivaut a =~ e e ` suivi d’une n´gation de l’expression. Le reste de $v n’est pas modifi´. Si vous avez besoin de rechercher ces caract`res. mais nous verrons e plus tard qu’il est possible d’en changer. e Il faut ajouter a cette liste le caract`re choisi comme s´parateur. } Les instructions sont ex´cut´es si $w ne contient pas la chaˆ pieds. cela n’est pas le cas.. } est plus concis et est ´quivalent a e ` if( ! ( $w =~ m/pieds/ ) ) { . il e faut donc les d´sp´cifier au moyen d’un anti-slash (\). e Les caract`res sp´ciaux habituels peuvent ˆtre utilis´s . Ces e e caract`res ont un rˆle particulier dans les expressions r´guli`res (nous allons e o e e voir cela dans la suite)..org Introduction a la programmation en Perl ` $v =~ s/voiture/pieds/. Le point-virgule indique la fin de l’instruction. t o contigus.. Voici la liste de ces e e caract`res : \ | ( ) [ ] { } ^ $ * + ? . Cela semble ´vident. Pour ` e e le moment. pour certains caract`res sp´ciaux. comprenez que e e e e lorsque l’on utilise l’expression r´guli`re m/a/ on v´rifie si la variable (ici e e e non cit´e) contient le caract`re a. nous allons voir quels sont les motifs utilisables dans les expressions r´guli`res. seul le slash (/) est utilis´ dans ce document.c sylvain@lhullier. En effet. e Pour la correspondance. e e ıne 10. e e Dans le cas g´n´ral. Par exemple $x =~ m/to\. mais il est bon de le e e e dire.to/ est vrai si la variable $x comporte les caract`res t o .3 Caract`res e Dans cette sous-partie et dans les suivantes. en voici quelques e e e e exemples : Motif \n \r \t \f \e Caract`re e saut de ligne retour chariot tabulation saut de page ´chappement e 83 ..

. totbV . soit un 4. par exemple toute variable comportant une des chaˆ ınes suivantes correspondra au motif : tata.. il faut le mettre e e e en premi`re ou en derni`re position afin de lever toute ambigu¨ e possible e e ıt´ avec un intervalle. par exemple R-Z ou toute autre combinaison tant que le num´ro ASCII du pree mier caract`re est inf´rieur a celui du second. e e e ` Il est possible de d´finir des intervalles de caract`res dans ces ensembles. soit un tiret.4 Ensembles Le caract`re . puis une autre lettre t. Le caract`re ^ (accent circonflexe) a un rˆle particulier s’il est plac´ en e o e d´but d’intervalle ./ reconnaˆ ıtra toute variable comportant une lettre t suivie d’un caract`re quelconque.”.. il faut le lire e e ”tout caract`re sauf ... Si le caract`re tiret (-) doit ˆtre pr´sent dans l’ensemble. tot9 . t%tK. totAV. le motif [ -~] e e ` correspond a un caract`re ASCII imprimable et de num´ro inf´rieur a 127. puis un autre caract`re quele e conque . tote ou tate..t.Introduction a la programmation en Perl ` Seuls les plus utiles sont pr´sent´s ici.. ` e e e ` Un intervalle peut prendre place au milieu d’un motif quelconque : m/tot[a-zA0-9]V/ matche totaV. e e Par exemple a-z ´quivaut aux 26 lettres minuscules de l’alphabet. Par exemple [^ao] matche tout caract`re sauf le e e a et le o. e e c sylvain@lhullier. e e 84 .. On peut aussi utiliser les ensembles A-Z ou 0-9 . Autre exemple. Cela e e signifie qu’` l’emplacement de ce point dans le motif pourra (devra) cora respondre un caract`re quelconque dans la variable. On comprendra ais´ment que e si un caract`re est pr´sent plusieurs fois dans cette liste.org 10. Le ıtre motif m/t[oa]t[ie]/ reconnaˆ toute variable comportant une des quatre ıtra chaˆ ınes suivantes : toti. tati. il prend le compl´mentaire de l’ensemble. cela a le mˆme effet e e e que s’il ´tait pr´sent une seule fois : [aeiouyie] est ´quivalent a [aeiouy]. Par e exemple [2a-zR] entrera en correspondance avec toute lettre minuscule ou bien avec le 2 ou bien avec le R majuscule. Vous comprenez pourquoi il faut d´sp´cifier le caract`re point avec un e e e anti-slash si vous voulez chercher un point litt´ral : sans cela un point matche e avec n’importe quel caract`re. par extension tout intervalle est envisageable. totzV. Par exemple [qwerty] peut reconnaˆ une de ces six lettres. le motif e m/t. Le motif [^0-9] matche tout caract`re non num´rique. Par exemple [a-z4-] matche soit une minuscule. e Le motif [caract`res] matche un caract`re parmi ceux pr´sents entre e e e crochets. tot0V . tot9V. (point) correspond a un caract`re quel qu’il soit (sauf e ` e \n (ce comportement peut ˆtre chang´ : nous verrons cela plus loin)). Par exemple.

Ils permettent de e e e e sp´cifier un nombre de fois o` ce motif peut/doit ˆtre pr´sent. avec a. a.org Introduction a la programmation en Perl ` Nous verrons un peu plus loin qu’il existe des raccourcis pour les ensembles les plus courants..m} le motif pr´sent e 0 fois ou plus 1 fois ou plus 0 ou 1 fois n fois exactement au moins n fois au plus n fois entre m et n fois exemple m/a*/ m/a+/ m/a?/ m/a{4}/ m/a{2. aaa.1}. aaa. aa. e u e e Par exemple l’´toile * indique que le motif peut ˆtre pr´sent z´ro fois ou e e e e plus : m/a*/ se met en correspondance avec le mot vide.}/ m/a{. de mˆme que ? pour {0.5}/ mots match´s e mot vide.. par exemple a un ensemble : e ` ` m/[0-9-]{4.. a. On peut les appliquer a tout motif.}. et si ıne on effectue l’instruction suivante : $v =~ s/ba*/hello/..} {. c’est-`-dire qu’il se met en correspondance avec le plus e a de caract`res possible dans la variable li´e. aaaa . mot vide. Nous verrons e ` plus loin comment faire cela.. aaaa . Il est par ailleurs important de noter qu’un tel quantificateur est par d´faut gourmand.. e 85 .8}/ recherche une chaˆ comportant entre 4 et 8 caract`res ıne e num´riques ou tirets contigus. aaa . mot vide ou a aaaa aa. a. aaa . 10. Quand je dis qu’un quantificateur s’applique au motif atomique le plus petit possible. tous les quantificateurs sont appliqu´s a e e e ` un caract`re.. aaaa ou aaaaa On remarquera que * est un raccourci pour {0.c sylvain@lhullier. aa.. je veux dire par l` que dans l’expression r´guli`re m/za*/ a e e l’´toile s’applique uniquement a la lettre a et non au mot za. ` Voici un tableau des quantificateurs : * + ? {n} {n.3}/ m/a{2. Cela a son importance dans le e e cas d’une substitution : si la variable $v contient la chaˆ vbaaal.n} {n. la chaˆ match´e ıne e par la premi`re expression ba* sera baaa (le quantificateur matche le plus de e caract`res possible) et la substitution aura pour effet de donner pour valeur e vhellol a la variable $v.5 Quantificateurs Les quantificateurs s’appliquent au motif atomique (c’est-`-dire le plus a petit possible) le pr´c´dant dans l’expression r´guli`re. aa ou aaa aa.} ainsi que + pour {1. aa. aaa. e Dans les exemples pr´c´dents.

l’autre majuscule. ´quivalent a [^0-9a-zA-Z_] e e ` • \s : un espacement. ´quivalent a [^ \n\t\r\f] e ` On remarquera qu’un ensemble et son compl´mentaire sont not´s par la e e mˆme lettre. c’est que e le point et les chiffres qui le suivent soient rendus solidaires dans l’absence ou la pr´sence. ´quivalent a [^0-9] e e ` • \w : un alphanum´rique. sign´ ou non : un caract`re + ou ıtre e e e optionnel. j’aime a leur dire que e e ` m/meuh{3}/ permet de meugler longtemps et que m/(meuh){3}/ de meugler plusieurs fois ! 86 .Introduction a la programmation en Perl ` c sylvain@lhullier.org 10. ´quivalent a [ \n\t\r\f] (s comme space) e ` • \S : un non-espacement. Pour marquer la m´moire de mes ´tudiants. l’expression r´guli`re suivante : m/[+-]?\d+\. e Par exemple. 10. l’une est minuscule.d+)?/ reconnaˆ donc les nombres tels que nous les souhaiıt tons.7 Regroupement Si dans notre exemple pr´c´dent. ´quivalent a [0-9a-zA-Z_] (w comme word. nous souhaitons rendre optionnelle la e e partie d´cimale. Or ce que l’on veut. e Pour cela nous allons utiliser des parenth`ses pour effectuer un regroue pement entre plusieurs motifs (ici le point et les chiffres) pour leur appliquer conjointement le mˆme quantificateur. on pourrait ´crire : m/[+-]?\d+\. un point et enfin au moins un chiffre. ´quivalent a [0-9] (d comme digit. e e ` c’est un caract`re d’un mot) e • \W : un non-alphanum´rique.6 Ensembles (suite) Nous allons ici ´num´rer un certain nombre de raccourcis pour des ene e sembles courants : • \d : un chiffre. chiffre en anglais) e ` • \D : un non-num´rique. au moins un chiffre.\d+/ pere e met de reconnaˆ un nombre d´cimal.?\d*/ rendant ainsi none e obligatoire la pr´sence du point et celle des chiffres apr`s la virgule. L’expression r´guli`re e e e m/[+-]?\d+(\. Le e e probl`me de cette expression est que la pr´sence du point et de ces chiffres e e sont d´corr´l´es : l’expression r´guli`re reconnaˆ un nombre o` l’une de ces e ee e e ıtra u deux parties serait pr´sente et l’autre absente.

8 Alternatives Il est possible d’avoir le choix entre des alternatives . S’il est au d´but d’un ensemble entre o e crochets. il marque le d´but de la chaˆ e e e ıne. Le signe ^ a donc plusieurs rˆles. Par exemple m/\btoto\b/ matche ”toto”. vous l’avez compris. Cela e e signifie que l’expression match´e par ce regroupement est gard´ en m´moire e e e 87 . elle ne correspond a aucun caract`re (aucune ”consommation” de caract`res n’est effectu´e). l’accent circonflexe (^) correspond au d´but de la chaˆ e ıne. soit Paul. c’est-`-dire entre \w et \W e a (ou entre \w et une fin ou d´but de chaˆ e ıne). ”toto autreMot”. Il en existe d’autres dont \b qui marque un d´but ou une fin de mot . soit Julie Martin mais rien n’oblige Fred a s’appeler Fred Martin ni Paul a s’appeler Paul Martin. Le dollar ($) correspond a la fin de la chaˆ L’expression $v =~ m/c$/ ` ıne. ` e e e Par exemple. ` ` comme on aurait sans doute aim´ que cela se fasse (dans ces deux derniers e cas. e un regroupement est n´cessaire. L’expression $v =~ m/^a/ est vraie si la variable $v commence par la lettre a. s’il est au d´but de e e l’expression r´guli`re. il faut pour cela utiliser le signe pipe (|) : l’expression m/Fred|Paul|Julie/ reconnaˆ les ıt mots comportant soit Fred. Pour cela. l’expression m/Fred|Paul|Julie Martin/ reconnaˆ e c ıt les chaˆ ınes comportant soit Fred. L’expression r´guli`re e e e m/(Fred|Paul|Julie) Martin/ reconnaˆ les trois fr`res et soeur de la faıt e mille Martin.9 Assertions Une assertion marque une position dans l’expression. soit Paul. est vraie si la variable $v se termine par la lettre c. mais pas ”unMot totoMotColl´” car le deuxi`me \b ne peut pas ˆtre vrai entre la e e e lettre o et la lettre M. etc.10 R´f´rences arri`res ee e Le regroupement au moyen des parenth`ses est dit m´morisant. 10. il permet d’en prendre le compl´mentaire . On veillera a ne pas ` les confondre. seul le pr´nom est reconnu. pas le nom).c sylvain@lhullier.org Introduction a la programmation en Perl ` 10. soit Julie. 10. De la mˆme fa¸on. ”unMot toto autreMot”. Ces deux assertions sont les plus courantes.

+). la e e deuxi`me. Ces motifs m´moris´s sont aussi accessibles depuis le second membre e e d’une substitution au moyen des notations $1.. Par exemple.+).*) avec \1 \2/ matchera par exemple les valeurs suivantes : ”Paul et Julie avec Paul Julie” et ”lala et et lili avec lala lili” 88 .org par le moteur d’expressions r´guli`res et qu’elle pourra servir a nouveau e e ` dans la suite de l’expression. (.*\w+/ ne saurait nous sae e ee tisfaire . expression entre parenth`ses (il n’est pas possible d’acc´der e e e a une expression au-del` de \9. ee ` e e e Autre exemple basique. $2 etc. du e e ee mot et puis d’une autre espace et enfin du premier motif. la r´ponse a notre probl`me de deux occurrences d’un mˆme e ` e e mot est la suivante : m/(\w+). L’expression m/\w+. on ne peut a donc pas s’en servir . puis un certain second motif ´galement suivi d’une virgule et e d’une espace. La solution est d’utiliser les notations \1. \2 et \1/ matchera une chaˆ ıne de caract`res comportant un certain premier motif suivi d’une virgule et e d’une espace.* permet comme avant qu’il y ait e e un nombre ind´fini de caract`res quelconques entre les deux occurrences. mais cela nous donne d´j` une expression ` a ea tr`s lourde a g´rer).*\1/ Le \w+ matchera un mot. le .*) (?:et )+(. en effet elle matche toute valeur comportant deux mots pouvant ˆtre diff´rents. puis ce second motif doit ˆtre r´p´t´ suivi d’une espace.Introduction a la programmation en Perl ` c sylvain@lhullier. e ` e Par exemple. e Par exemple m/(. l’instruction suivante $v =~ s/([0-9]+)/"$1"/ place des guillemets de part et d’autre du premier nombre de la variable $v : ’sdq 32sq’ deviendra ’sdq "32"sq’. e e enfin \1 fait r´f´rence a la valeur trouv´e par le \w+ pr´c´dent. L’exemple typique consiste a se demander si une variable contient le ` mˆme mot r´p´t´ deux fois. Je vais alors vous dire : il existe un regroupement non-m´morisant ! La notation (?:motifs) permet de regrouper les motifs e (pour leur appliquer le mˆme quantificateur par exemple) sans pour autant e qu’une m´morisation n’ait lieu. les parenth`ses e m´moriseront la valeur alors trouv´e. \2 etc qui font e e r´f´rence aux sous-chaˆ ee ınes match´es par (respectivement) la premi`re. m/(. Vous allez me dire : mais cela signifie que d`s que l’on fait un regroupee ment. etc.. le moteur d’expressions r´guli`res m´morise la valeur et si l’on n’utilise e e e pas certains regroupements et que d’autres sont au-del` de 9.

mais e qui peuvent ˆtre int´ressantes : e e • $& vaut toute la sous-chaˆ matchant. # ’aa’ print "$2\n". $2 etc. } 89 . 10.. e e a e e Elles correspondent bien sˆ r aux sous-chaˆ u ınes match´es entre parenth`ses. a e mais ´vitez leur usage dans un projet de plusieurs milliers de lignes ou dans e un script CGI appel´ 10 fois par seconde. # ’fe’ } Il est bon de savoir que cela est possible sans obligatoirement se souvenir du nom de toutes les variables.12 Valeurs de retour de m// Je vous ai dit jusqu’ici que l’op´rateur de correspondance m// retournait e vrai ou faux .. # ’za ’ print "$’\n". qui ont pour effet secondaire d’en e e ralentir fortement la vitesse d’ex´cution. Si vous avez besoin de ces variables e dans un petit script qui ne sert qu’` cela. ıne • $‘ vaut toute la sous-chaˆ qui pr´c`de la sous-chaˆ matchant. dont je vous d´conseille l’usage.org Introduction a la programmation en Perl ` 10. cela est exact en contexte scalaire. ıne ıne Je vous d´conseille en effet l’usage de ces trois variables sp´ciales car leur e e pr´sence dans un script active pour tout le script des m´canismes particuliers e e dans le moteur d’expressions r´guli`res.c sylvain@lhullier.11 Variables d´finies e Ces variables sp´ciales $1. # ’t’ print "$&\n". e e Nous pouvons nous en servir pour extraire certaines sous-chaˆ ınes et les utiliser ensuite. sont aussi accessibles apr`s l’expression e e r´guli`re (jusqu’` la fin du bloc courant ou une autre expression r´guli`re). C’est par exemple le cas lorsqu’on ´crit : e if( $w =~ m/motif/ ) { . pas de probl`me pour les utiliser. if( $v =~ /(a+) et ([a-z])/ ) { print "$1\n". # ’aa et t’ print "$‘\n". e Voici un exemple : my $v = "za aa et tfe". Il existe aussi trois autres variables. ıne e e ıne • $’ vaut toute la sous-chaˆ qui suit la sous-chaˆ matchant.

} • $v =~ s/^ServerRoot/DocumentRoot/. e e e e Que font les instructions suivantes ? • if( $v =~ m/\w+ \d* ?:/ ) { . les variables $x et $y e ` re¸oivent les valeurs entre parenth`ses. On parle ici d’extraction.*(B+)$/ ) ) { . On a alors combin´ correspondance c e e et extraction. 10.$m) = ( $v =~ m/(\w+)=(\d+)/ ). on n’ex´cute les instructions du if que si $v comporte au e moins un A en son d´but et un B a sa fin. On peut en effet ´crire : e if( ($x.*(B+)$/ ).13 Exemples de probl`mes e Dans cette partie.})".Introduction a la programmation en Perl ` c sylvain@lhullier. e e ` Par exemple : ($x. } • if( $v =~ m/^"([a-z]{4. Essayez de ne pas vous pr´cipiter pour les lire. Mais en contexte de liste.$y) = ( $v =~ m/^(A+).$m) = ( $v =~ m/(\w+)=(\d+)/ ) ) { print "$n $m\n". } • ($n.. $2 etc. je vais vous pr´senter diff´rents petits exercices prae e tiques sur les expressions r´guli`res. prenez le temps de e chercher dans ce qui pr´c`de ce qu’il vous faut pour r´soudre les probl`mes. Les solutions se trouvent un peu plus e e loin. } auquel cas. Dans ce cas.org On parle alors de correspondance.$y) = ( $v =~ m/^(A+). Il se peut tout a fait que cette op´ration ´choue (en cas d’absence des ` e e lettres aux endroits attendus par exemple). 90 . place dans $x les caract`res A du d´but de la chaˆ $v et dans $y la e e ıne suite de caract`res B terminant la chaˆ e ıne... Cet usage peut ˆtre combin´ e e avec l’utilisation d’un test./ ) { print "$1\n". et cela sans limite a 9). } • if( $v =~ m/([a-z]+)[a-z]*\1/ ) { print "$1\n". cet op´rateur retourne la liste des ´l´ments e ee match´s entre parenth`ses (les fameux $1.. • if( ($n.

/ ) { print "$1\n". • Extraire de $v le dernier caract`re non-num´rique. suivi d’au moins quatre e lettres minuscules (que l’on m´morise).. les instructions du if sont ex´cut´es. } On v´rifie que $v comporte un mot d’une lettre ou plus (\w+) suivi e d’une espace. e • if( $v =~ m/([a-z]+)[a-z]*\1/ ) { print "$1\n". e • V´rifier que $v comporte deux fois de suite un mˆme nombre (s´par´es e e e e par un signe d’op´ration math´matique). • $v =~ s/ +/ /.. • Supprimer les guillemets autour du nombre entier de $v. } On v´rifie que $v commence par un guillemet. e • Extraire de $v les deux premiers mots. Si la variable est du bon format. ´ Ecrivez les instructions r´alisant les actions suivantes : e • V´rifier que $v comporte velo. e e • Extraire de $v chacun des deux premiers caract`res. Si c’est le cas.})". Je rel`ve les copies dans 30 minutes . d’un autre guillemet puis d’une e virgule. puis ´ventuellement d’un nombre (\d*).14 Solutions des probl`mes e Voici les solutions de la premi`re partie des probl`mes : e e • if( $v =~ m/\w+ \d* ?:/ ) { .org Introduction a la programmation en Perl ` • $v =~ s/^C="([^"]*)"/D=’$1’/.c sylvain@lhullier. e • V´rifier que $v finit par une lettre majuscule.-))) e 10. puis d’une ese pace optionnelle ( ?) et enfin du signe deux-points. } On recherche quelque chose de la forme : une suite de caract`res en e minuscules (au moins 1) puis une deuxi`me suite de caract`res en e e 91 . • Supprimer de $v les espaces en fin de chaˆ ıne. e e • if( $v =~ m/^"([a-z]{4. ces quatre lettres (ou plus) sont affich´es. e e • Remplacer dans $v rouge par bleu.

Si la variable $v comporte e e un tel mot.. on affiche la variable e e e et le nombre de l’affectation. On recherche une suite alphanum´rique.org • • • • • minuscules (´ventuellement aucun) et enfin la mˆme suite de caract`res e e e que la premi`re suite. e $v =~ s/ +/ /. } Si la variable $v est du format pr´c´demment cit´..$m) = ( $v =~ m/(\w+)=(\d+)/ ) ) { print "$n $m\n". $v =~ s/^ServerRoot/DocumentRoot/. La variable et le nombre sont respectivement affect´s aux variables $n et $m.. On cherche donc un mot (suite de lettres) dont e un certain nombre de lettres se r´p`tent. Le dollar nous permet de nous ”accrocher” en fin de chaˆ : ıne if( $v =~ m/[A-Z]$/ ) { . Un signe doit suivre (il faut d´sp´cifier le signe de la e e e division car il est aussi le s´parateur de l’expression r´guli`re). e e Encore un match. On recherche en d´but de chaˆ une sous-chaˆ C="motif" dont motif e ıne ıne ne comporte pas de ". } • V´rifier que $v finit par une lettre majuscule. e Pas trop dur : il s’agit d’un simple match. if( $v =~ m/velo/ ) { . } • V´rifier que $v comporte deux fois de suite un mˆme nombre (s´par´es e e e e par un signe d’op´ration math´matique). un signe ´gal puis un nombre.$m) = ( $v =~ m/(\w+)=(\d+)/ ).Introduction a la programmation en Perl ` c sylvain@lhullier. e if( ($n. on affichera ces lettres r´p´t´es. Finae e e lement le mˆme nombre qu’avant doit ˆtre pr´sent (\1) : e e e 92 . $v =~ s/^C="([^"]*)"/D=’$1’/. e e Il s’agit d’une affectation. On remplace ServerRoot par DocumentRoot s’il est en d´but de chaˆ e ıne. Nous cherchons un nombre \d+ que nous m´morisons e (parenth`ses). e ee ($n. e Match ici aussi. Remplace dans $v la premi`re suite d’espaces par une seule espace. Tout cela est remplac´ par D=’motif’ o` motif e u est inchang´.. e Voici les solutions de la seconde partie des probl`mes : e • V´rifier que $v comporte velo.

• Extraire de $v les deux premiers mots.$deux) = ( $v =~ m/^\W+(\w+)\W+(\w+)/ ). } • Extraire de $v chacun des deux premiers caract`res. Voici d’autres fonctionnalit´s plus pouss´es et e e e donc plus int´ressantes.. on prend un caract`re avec . • Remplacer dans $v rouge par bleu.org Introduction a la programmation en Perl ` if( $v =~ m/(\d+)[+*\/-]\1/ ) { . que l’on e ıne e m´morise. c’est qu’entre deux mots (\w+). Vous noterez que. apr`s le dernier caract`re non-num´rique. en m´morisant ce fameux nombre : e $v =~ s/"(\d+)"/$1/. • Supprimer de $v les espaces en fin de chaˆ ıne. Les quantificateurs non-gourmands et surtout les e options sont des points importants.$deux) = ( $v =~ m/^(. Le seul point e e e e un peu d´licat a voir. Les fonctionnalit´s les plus importantes ont ´t´ abord´es vous voila par´s e ee e e pour la suite des op´rations. le dollar pour se placer a la fin de e e ` la chaˆ : ıne ($c) = ( $v =~ m/(\D)\d*$/ ). puis de la mˆme fa¸on pour le deuxi`me. l’usage de la fonction substr est possible (et indiqu´ . • Extraire de $v le dernier caract`re non-num´rique. On va remplacer tous ces espaces par rien : $v =~ s/ +$//.c sylvain@lhullier. il n’y a e c e e e que des num´riques (z´ro ou plus). il doit forcement e ` y avoir des caract`res ”non-mot” (\W+) : e ($prem. e e c e dans ce cas. 93 .) e ($prem. • Supprimer les guillemets autour du nombre entier de $v.. La m´thode est la mˆme que pour l’exemple pr´c´dent. e Nous allons utiliser un match pour faire de l’extraction : on se place en d´but de chaˆ avec ^.. Facile (seule la premi`re occurrence est remplac´e) : e e $v =~ s/rouge/bleu/.)/ ). On va faire une substitution..)(. e e De la mˆme fa¸on.

il est de ce fait fort fastidieux de devoir d´sp´cifier e e chaque slash utilis´. Si cette option est e sp´cifi´e. dans ce cas. comme par exemple dans l’expression suivante (ici une e version simplifi´e de l’expression r´guli`re qui reconnaˆ les URL) : e e e ıt if( $v =~ m/http:\/\/\w+/(\w+\/)*\w\. e e 10. sachant que dans la grande ` e majorit´ des cas le slash est utilis´. la lettre m n’est pas obligatoire e pour faire un match : $v =~ /velo/ est ´quivalent a $v =~ m/velo/ e ` Libre a vous de choisir le bon s´parateur. remplace chaque groupe de plusieurs espaces par une seule (contrairement a un des exercices ` 94 . l’op´rateur s/// effectue la transformation de la premi`re e e e occurrence du motif recherch´ et ne va pas plus loin. Par d´faut. Par exemple. e e Si vous utilisez le slash comme s´parateur. le caract`re slash fait partie des motifs que l’on est suse ceptible de rechercher .Introduction a la programmation en Perl ` c sylvain@lhullier.15 Choisir son s´parateur e Il est tout a fait possible de choisir un autre caract`re que le slash (/) e comme s´parateur. le signe ´gal par e e exemple : if( $v =~ m=http://\w+/(\w+/)*\w\. Il se peut par exemple que nous ayons a manipuler des e ` URL .16 Options Apr`s le dernier s´parateur des op´rateurs de correspondance (m ou rien) e e e ou de substitution (s) il est possible d’indiquer une ou plusieurs options.html= ) La plupart des caract`res est utilisable comme s´parateur. Voici la liste de quelques options parmi les plus utiles : e e • L’option i rend le motif insensible a la case (minuscules/majuscules) : ` l’expression r´guli`re m/toto/i recherche le mot toto indiff´remment e e e en majuscules ou en minuscules. l’expression $v =~ s/ +/ /g. le moteur d’expressions r´guli`res avancera dans la variable e e e e tant qu’il pourra y faire des substitutions.org 10. Les syntaxes sont donc : m/motif/options et s/motif1/motif2/options Les options permettent de modifier le comportement du moteur d’expressions r´guli`res. On aurait pu ´crire e m/[tT][oO][tT][oO]/ • L’option g permet d’effectuer toutes les substitutions dans la variables.html/ ) Il serait plus lisible de prendre un autre s´parateur.

remplace le premier nombre trouv´ dans la variable $s par la valeur e de retour de la fonction appliqu´e a ce nombre. } L’affichage effectu´ est le suivant : e to tb tc • Dans une substitution. • L’option o a pour effet qu’une seule compilation de l’expression r´guli`e e re a lieu. il la compile (pour ceux qui connaissent. avec cette option. while( $v =~ m/t. ce changement ne sera pas pris en compte./g ) { print "$&\n". avec des options combin´es celui-l` : e a $s =~ s/0x([0-9a-f]+)/hex($1)/gei. On l’utilise typiquement e dans une boucle . si cette expression e est utilis´e plusieurs fois.org Introduction a la programmation en Perl ` pr´c´dents o` l’expression r´guli`re ne rempla¸ait que la premi`re oce e u e e c e currence du motif trouv´). e e il construit l’automate) . e Voyez par exemple le code suivant : $t = $s = "sd et sd". la compilation a lieu une seule fois lors de la premi`re ex´cution. si le motif peut changer (voir la suite concernant les variables dans les motifs). voyez cet exemple : my $v = "aatobbtbvvtczz". c’est-`-dire de poursuivre sa ree e a cherche en partant du dernier motif trouv´. En temps normal. Par exemple : $s =~ s/(\d+)/fonction($1)/e. Le principal avantage est un e e temps d’ex´cution plus court pour le programme. e ` Autre exemple. # => "toto et sd" $s =~ s/sd/toto/g. Les inconv´nients sont une place m´moire e e e occup´e (inutilement si l’expression r´guli`re ne sert que peu de fois) e e e et que.c sylvain@lhullier. Il existe deux options (exclusives l’une de l’autre) qui permettent de 95 . et remplace le motif trouv´ par la valeur de cette e expression. l’option e ´value le membre de droite comme e une expression Perl. Elle permet a cet ` op´rateur de fonctionner avec ´tat. a chaque fois que l’interpr´teur Perl passe ` e sur une expression r´guli`re. $t =~ s/sd/toto/. # => "toto et toto" L’option g est aussi utilisable en correspondance. transforme tous les nombres hexad´cimaux en nombres d´cimaux dans e e la variable $s.

Pour les exemples qui suivent. Par exemple ($s=~m/t.Introduction a la programmation en Perl ` c sylvain@lhullier. • Le caract`re . Par exemple e e ($s=~m/mot$/m) est vrai. ($s=~m/mot$/s) est faux. • Le caract`re . ne matche pas \n.lu$/) est e faux.m} Non gourmand *? +? ?? {n. : • Par d´faut : mode interm´diaire. 10. car dans notre exemple la chaˆ ’r’ g ’e’ ıne serait match´e. Par exemple ($s=~m/t. de consommer le moins de caract`res possible. La premi`re id´e est d’´crire quelque chose comme : /’. Nous avons une chaˆ de la forme e ıne "s ’r’ g ’e’ y" de laquelle nous souhaitons extraire les chaˆ ınes qui sont entre guillemets. • Avec l’option m : on travaille en ligne multiple. e e • Les caract`res ^ $ se positionnent en d´but/fin de chaˆ Par exemple e e ıne. • Le caract`re . • Les caract`res ^ $ se positionnent en d´but/fin de chaˆ Par exemple e e ıne. au contraire. ($s=~m/mot$/) est faux.17 Quantificateurs non-gourmands Posons-nous le probl`me suivant. je pose $s = "mot\nlu". peut matcher \n. ne matche pas \n. on peut ´crire /’.*’/ e e e ce qui n’est pas satisfaisant. En effet. On parle alors de quantificateurs e non-gourmands.lu$/m) est e faux. ´conomes ou frugaux.m}? Pour revenir a notre exemple. • Les caract`res ^ $ se positionnent en d´but/fin de ligne. e e e On parle de quantificateurs gourmands. avides ou greedy en anglais. Leur notation est la mˆme que celle e e des quantificateurs que vous connaissez mais suivie d’un point d’interrogation : Gourmand * + ? {n. • Avec l’option s : on travaille en ligne unique.lu$/s) est e vrai. Il existe des quantificateurs dont le comportement est. je vous avais dis que les quantificateurs consomment e le plus de caract`res possible. gloutons.*?’/ et la correspon` e 96 .org changer certains comportements sur les d´buts et fins de chaˆ e ınes. Par exemple ($s=~m/t. nous voici dans une illustration du ph´nom`ne.

exactement comme si nous avions ´crit : e e if( $v =~ m/ve(lo$/ ) { . e e e e e 97 . e Vous allez me dire. ils seront vus comme tels. Si e e e dans notre exemple. Je r´pondrais e que je suis d’accord avec vous. Notez cependant que si la variable substitu´e contient des caract`res e e sp´ciaux au sens des expressions r´guli`res.org Introduction a la programmation en Perl ` dance sera effectu´e telle que nous la souhaitions. Cette variable sera substitu´e par son contenu. Par e e e exemple : $s = "velo". Il est ainsi possible de rechercher la valeur d’une variable dans une autre. la variable $s avait pour valeur la chaˆ ”ve(lo”. Si cette fois la chaˆ a pour valeur ıne "s STARTrSTOP g STARTe fSz zSTOP y" et que nous souhaitons extraire les sous-chaˆ ınes plac´es en les marqueurs START et STOP. Il existe pour cela une fonction quotemeta qui prend en param`tre une chaˆ de caract`res et renvoie cette mˆme chaˆ e ıne e e ıne en ayant d´sp´cifi´ les caract`res sp´ciaux. le ıne moteur d’expression r´guli`re nous signalerait une erreur due a la parenth`se e e ` e ouvrante qui n’est pas referm´e. Perl sait automatiquement si un $ correspond a une variable ` ou a la sp´cification ”fin de chaˆ ` e ıne”. il nous est fort ais´ e e d’´crire : /START.. Dans notre exemple. La mˆme chose est possible avec la e substitution. Mais voici un autre exemple o` les quantificateurs non-gourmands nous u sauvent la mise. car vous avez tout compris aux expressions r´guli`res e e . qu’il est possible de faire cela sans utiliser ces quantificateurs nongourmands. le premier dollar concerne la variable $s.*?STOP/ e 10.. } # incorrect Cela peut aussi poser des probl`mes de s´curit´ si le programmeur ne e e e sait pas ce que peut contenir la variable substitu´e (par exemple si sa valeur e provient de l’utilisateur).. le second marque la ıne fin de chaˆ ıne..-) . } La variable sera substitu´e et la recherche s’effectuera sur le mot velo en e fin de chaˆ .c sylvain@lhullier.18 Substitution de variables dans les motifs Il est tout a fait possible de mettre une variable dans un motif d’une ` expression r´guli`re. on peut tout a fait ´crire : /’[^’]*’/ ce qui ` e permet de ne pas accepter de guillemets entre les guillemets. if( $v =~ m/$s$/ ) { . aussi bien pour le premier membre que pour le second.

cela r´sout bien des probl`mes.. la deuxi`me lettre de la premi`re chaˆ par la deuxi`me e e ıne e lettre de la seconde chaˆ ıne. mais e e e il en est proche. e 10. Certes. # affiche 0z4rty Dans la variable $s. etc. e e Voici un petit exemple : $s = "azerty". e e 10. tous les b en 1. met par exemple le contenu de la variable en majuscules. Cette transformation a lieu sur la variable li´e ou sur $_ par d´faut.. Les maˆ e e e ıtriser ouvre des portes au programmeur. Il est possible d’utiliser des intervalles : $s =~ tr/a-z/A-Z/.19 Op´rateur tr e Cet op´rateur ne concerne pas vraiment les expressions r´guli`res. C’est l’un des seuls usages courants de l’op´rateur tr. tous les e en 4 etc. } c sylvain@lhullier. il est souvent difficile de rentrer dans le jeu. tr est un op´rateur de translation lettre a lettre (on parle de transe ` litt´ration). Voici sa syntaxe : tr/chaˆne1/chaˆne2/ ou encore e ı ı y/chaˆne1/chaˆne2/ ı ı Les deux chaˆ ınes doivent ˆtre de la mˆme longueur car cet op´rateur va e e e remplacer la premi`re lettre de la premi`re chaˆ par la premi`re lettre de e e ıne e la seconde chaˆ ıne. $s2 = quotemeta($s).org fds\(ds Pensez a toujours utiliser cette fonction lorsque vous voulez placer une ` variable dans un motif .Introduction a la programmation en Perl ` $s = "fds(ds". mais cet effort est r´compens´ par de nouvelles possibilit´s inimaginables e e e avant. 98 . print "$s2\n". print "$s\n". Mettez de cˆt´ ce que vous venez d’apprendre sur celles-ci oe pour lire la suite. # affiche if( $v =~ m/$s2/ ) { . tous les a seront transform´s en 0. e etc.20 Un dernier mot sur les expression r´guli`res e e Les expressions r´guli`res sont un outil tr`s puissant. $s =~ tr/abcde/01234/.

dont le nom provient des initiales de ”Perl-compatible regular expressions” .c sylvain@lhullier.. Sachez aussi que toutes les fonctionnalit´s des expressions r´guli`res e e e n’ont pas ´t´ trait´es ici. e e c’est bien.. Les plus courantes ou importantes le sont.org Introduction a la programmation en Perl ` Les expressions r´guli`res de Perl sont si puissantes et bien pens´es que e e e de nombreux langages les impl´mentent. 99 . Sachez de plus que les expressions r´guli`res. en se vantant d’ˆtre perl5-regexes e e compliant ! On peut. par exemple. mais ee e il en existe d’autres encore . mais il faut savoir quand les utiliser et quand ne pas les utiliser.. citer la librairie pcre du langage C..

Introduction a la programmation en Perl ` c sylvain@lhullier.org 100 .

Chapitre 11 R´f´rences ee Les r´f´rences permettent de bˆtir des structures complexes et comee a pos´es : tableau de tableaux ou de tables de hachage et inversement. Ici la variable $refv (on aurait pu choisir un tout autre nom pour cette variable) est une r´f´rence vers la variable $v. table e de hachage de tableaux ou de tables de hachage . ee ee quelque soit celui de la variable qu’elle r´f´rence (scalaire. est un scalaire. Une e e telle r´f´rence peut elle-mˆme ˆtre stock´e dans une variable scalaire. Chaque variable. est pr´sente a une position donn´e dans la m´moire. ee e e e 11. Les habitu´s du C ou C++ ` ee e noterons que les calculs sur r´f´rences sont interdits en Perl. Une variable de type r´f´rence. Une r´f´rence vers une e ` e e ee variable est (sch´matiquement) l’adresse m´moire de cette variable. tableau ou table ee de hachage). qu’elle soit scalaire. On peut repr´senter la relation entre ces deux e variables de la fa¸on suivante : c 101 . Le terme de r´f´rence en Perl correspond a peu pr`s a celui de pointeur ee ` e ` en C et C++ et a celui de r´f´rence en Java. tableau ou table de hachage.1 R´f´rences sur scalaire ee L’op´rateur qui permet de prendre la r´f´rence d’une variable est l’antie ee slash (\) : \$v est la r´f´rence de la variable $v ee my $refv = \$v. ce qui permet ee d’´viter toutes sortes de probl`mes dus a des acc`s m´moire erron´s (plus e e ` e e e de Segmentation fault)...

Autrement dit. car on va pouvoir manipuler $v (l’afficher. # affiche -43.org $refscalaire $v −43.5 L’affichage effectu´ est -43. Dit de mani`re plus prosa¨ e ee e ıque. my $refv = \$v. On dit que ` $refv pointe vers $v.5 La variable $refv contient l’adresse de la variable $v (ainsi que l’information consistant a savoir que $v est une variable scalaire). Pour e e e ee faire un parall`le avec le langage C.5 (c’est-`-dire la valeur de $v).5. Cette notae a tion $$refv est ´quivalente a $v puisque $refv est une r´f´rence sur $v. On dit alors que l’on d´r´f´rence la variable $refv. e ` ee Cette ´quivalence vaut aussi bien lorsque l’on a besoin de la valeur de $v e (affichage etc) que lorsque l’on veut affecter une nouvelle valeur a $v : ` $$refv = 56. la notation $$refv ´quivaut a la variable e ` scalaire point´e par la r´f´rence $refv. # affecte 56 a $v ` 102 . Affichons e e e maintenant la variable point´e par $refv (c’est-`-dire $v ici) : e a print "$$refv\n". # affiche SCALAR(0x80ff4f0) On voit bien alors que la r´f´rence pointe vers une variable de type scaee laire (SCALAR) dont l’adresse m´moire est affich´e en hexad´cimal. il s’agit de l’´quivalent de l’´toile (*) e e e appliqu´e a un pointeur. On affiche la valeur de la r´f´rence : ee print "$refv\n". la modifier etc) en utilisant $refv . on repr´sente ce lien par une fl`che de $refv vers e e $v. Nous d´clarons ensuite une autre variable scalaire $refv a e ` laquelle on affecte l’adresse de $v . e ` Revenons sur notre exemple. La notation $$refv (donc avec deux dollars) est ´quivalente a $v tant que $refv e ` pointe vers $v. Il nous est alors possible de manipuler $v au travers de $refv. Nous d´clarons une variable scalaire $v que e nous initialisons.Introduction a la programmation en Perl ` c sylvain@lhullier. on va acc´der a la variable qu’il y a ”au bout” de la r´f´rence (au bout de la e ` ee fl`che du sch´ma). $refv est donc une r´f´rence sur $v : ee my $v = -43.

# affiche 56 # affiche 56 Rien de bien sorcier. ceci est tout a ` ` fait l´gal et sans risque en Perl. 103 . on ` a ` voit bien qu’elle contient cette nouvelle valeur : print "$$refv\n". } Cette fonction prend en argument une r´f´rence et affecte 0 a la variable ee ` scalaire point´e par cette r´f´rence.org Introduction a la programmation en Perl ` On affecte 56 a $$refv. c’est-`-dire a $v. Voici un autre exemple simple d’utilisation des r´f´rences : ee sub f2 { my $w = 43. } Cette fonction f2 d´clare une variable locale $w et renvoie une r´f´rence e ee vers cette variable. Contrairement a ce qu’il se passe en C. Si on affiche cette variable. 11.c sylvain@lhullier. print "$v\n". $$ref = 0. Voici comment utiliser cette fonction : e my $reff = f2(). return \$w. On pourrait ` aussi ´crire directement : e f( \$v ).2 Utilisation des r´f´rences sur scalaire ee ` A quoi peut bien servir une r´f´rence sur un scalaire ? Par exemple a le ee ` modifier dans une fonction : sub f { my ($ref) = @_. Ce qui aurait pour effet de mettre la variable $v a la valeur 0. On pourrait l’utiliser ainsi : e ee f( $refv ).

C’est le garbage-collector (ramasse-miette e e ou glaneur de cellules) qui la lib´rera lorsque plus aucune r´f´rence sur la e ee variable n’existera.4 Pour d´r´f´rencer une telle r´f´rence. ee elle est conserv´e en m´moire. une autre va` riable $w sera cr´´e ind´pendante de la premi`re . il n’y aura donc pas d’effet ee e e de bord sur la premi`re r´f´rence renvoy´e.3 R´f´rences sur tableau ee Il est possible de cr´er une r´f´rence sur un tableau. Mais tant qu’il existe une r´f´rence vers la variable. il convient d’utiliser une arobase eee ee (@) : @$reft est ´quivalent a @t. my $reft = \@t. elle n’a plus de nom. ee $reff 0 En temps normal. Cette variable scalaire valant 43 est l’ancienne variable $w de la fonction f2. une variable locale a une fonction est d´truite lorsque ` e l’on sort de la fonction. L’op´rateur qui e ee e permet cela est le mˆme que pour les scalaires .Introduction a la programmation en Perl ` c sylvain@lhullier. La variable scalaire $reft est donc une r´f´rence vers le tableau @t : ee $reft @t 0 23 1 ab 2 −54.4). On peut ainsi utiliser la valeur de @t en e ` utilisant $reft : 104 . mais en dehors de l’appel a cette ` fonction qui l’a cr´´e.-) 11. il s’agit de l’anti-slash (\) e appliqu´ a une variable de type tableau : e` my @t = (23. La variable $reff pointe donc vers une variable qui n’a plus de nom : dans f2 elle s’appelait $w. Nous sommes ici en pr´sence e ee e e d’une fonction qui peut faire office de g´n´rateur de r´f´rences sur scalaire e e ee . -54.org La variable scalaire $reff devient donc une r´f´rence vers une variable ee scalaire valant 43. Il faut noter que lors d’un prochain appel a la fonction f2. "ab".

C’est la e ee ee e notation la plus souvent utilis´e pour cela . On peut alors dire. } On peut aussi modifier @t de la sorte : @$reft = (654.3.. ıne Ce qui peut se repr´senter sous la forme suivante : e 105 . un r´capitulatif des ´quivalences de notations : e e Tableau t @t $t[i] $t[i] R´f´rence ee $reft @$reft $$reft[i] $reft->[i] Cette derni`re notation $reft->[i] est ´quivalente a $$reft[i] et core e ` respond donc au i`me ´l´ment du tableau r´f´renc´ par $reft.. e L’expression $reft->[1] = "coucou".c sylvain@lhullier.org Introduction a la programmation en Perl ` my @t2 = @$reft. il va nous ˆtre ee e e possible de stocker une r´f´rence comme valeur dans un tableau : ee my @t1 = ( 16. \@t1. on peut ´crire $reft a la place. -33 ). un deuxi`me ee e ´tant une r´f´rence vers un tableau a deux ´l´ments. Si.7. il e e ee e e est maintenant possible d’´crire $$reft[i]. il ´tait possible d’´crire $t[i]. en effet.. de mani`re e e sch´matique et pour fixer les choses. my @t = ( 6. tant que $reft pointe u e e ` sur @t). il va maintenant nous ˆtre possible de cr´er des ee e e tableaux de tableaux. un troisi`me une e ee ` ee e r´f´rence vers un tableau a trois ´l´ments et enfin un ´l´ment valant la ee ` ee ee chaˆ "s". affecte donc a l’´l´ment d’indice 1 du tableau point´ par $reft une ` ee e nouvelle valeur. elle rappelle la mˆme notation e e fl`che (->) du langage C. Voici. Cela ´tait pour le moment impossible en raison de e l’aplatissement des listes. Une r´f´rence ´tant un scalaire. \@t2. "s" ). Le tableau @t comporte donc un premier ´l´ment valant 6. Munis des r´f´rences. 0. que la notation $reft est ´quivalente e e au nom t de la variable dans toute les syntaxes utilisant ce tableau (partout o` l’on peut ´crire t. 4 ). -9. pour acc´der au i`me ´l´ment de @t. my @t2 = ( "el". foreach my $e (@$reft) { . "bonjour").

la cr´ation e c e d’une r´f´rence vers une table de hachage utilise l’op´rateur anti-slash (\) : ee e my %h = ( ’Paul’ => 21. ( "el". Nous verrons dans la suite d’autres syntaxes pour construire des tableaux de tableaux. 0. 4 ).4 R´f´rences sur table de hachage ee De la mˆme fa¸on que pour les scalaires et pour les tableaux. ( 16. La variable scalaire $refh est donc une r´f´rence vers la table de hachage ee %h : $refh %h Julie Paul => => 19 21 106 . -33 ). "s" ). my $refh = \%h. 11.Introduction a la programmation en Perl ` c sylvain@lhullier.3 2 4 0 16 1 −33 Vous noterez bien que la syntaxe suivante correspond a la cr´ation d’un ` e tableau a sept ´l´ments (aplatissement des listes) : ` ee my @t2 = ( 6.org @t 0 6 1 2 3 s 0 el 1 0. ’Julie’ => 19 ).3.

org Introduction a la programmation en Perl ` Pour d´r´f´rencer une r´f´rence vers une table de hachage. } Cette notation fl`che rend l’expression plutˆt lisible.. foreach my $k (keys %$refh) { . e o 11. car l’interpr´teur veille au grain.c sylvain@lhullier. un de ces trois messages sera affich´ lors de l’ex´cution e e e et le programme prendra fin : 107 .5 R´flexions ` propos des r´f´rences e a ee On a vu que pour d´r´f´rencer une r´f´rence vers un scalaire on utilise eee ee le caract`re dollar ($). il faut utiliser eee ee le caract`re pourcentage (%) . En cas d’ine compatibilit´ de type. %$refh est ´quivalent a %h : e e ` my %h2 = %$refh. e $refh->{Jacques} = 33. Il refusera de e e consid´rer comme un tableau une variable scalaire par exemple. } Les deux notations suivantes permettent d’acc´der a la valeur associ´e a e ` e ` la clef Paul : $$refh{Paul} et $refh->{Paul} sachant que la seconde est la plus utilis´e pour des raisons identiques aux cas des tableaux.. Mais que se passerait-il s’il e nous venait a l’id´e de ne pas choisir le bon caract`re de d´r´f´rencement. Voici un r´capitulatif des ´quivalences : e e Hash h %h $h{Paul} $h{Paul} R´f´rence ee $refh %$refh $$refh{Paul} $refh->{Paul} Voici une fa¸on d’afficher tous les couples clef/valeur de la table de hac chage r´f´renc´e par $refh : ee e foreach my $k (keys %$refh) { print "$k $refh->{$k}\n". vers un tableau le caract`re arobase (@) et vers une e e table de hachage le caract`re pourcentage (%). ` e e eee par exemple d’utiliser le dollar pour une r´f´rence sur tableau ou bien le ee pourcentage pour une r´f´rence sur scalaire ? N’arriverons-nous pas a des ee ` incoh´rences comme en C ? e La r´ponse est non.

c’est-`-dire de vaee a riable point´e et donc de type de variable point´e : e e my $v = 45. my $r = \$v.-2). e De plus. 108 . il sera donc impossible de la d´r´f´rencer. Not a HASH reference at script. # affiche 135255237 On voit bien ici que la variable $r perd son caract`re sp´cifique de e e r´f´rence .org Comme une r´f´rence peut pointer vers n’importe quel type de structure ee (scalaire. vous pourrez donc la modifier dans e ee la fonction : sub f3 { my ($reftab) = @_. tableau. la strucee e ture point´e par la r´f´rence ne l’est pas . $$r = -32. # affiche SCALAR(0x80fd4c4) "$r\n". my @t = ("ee". elle a toujours pour valeur l’adresse de la variable (ici incr´ment´e ee e e de 1 : 80fd4c4 est la repr´sentation hexad´cimale du nombre 135255236). e ee ` vous devez bien voir que la copie de la seule r´f´rence est effectu´e. table de hachage). Not an ARRAY reference at script. les habitu´s du langage C seront invit´s a se mettre une bonne e e ` fois pour toute dans la tˆte :-) qu’il n’y a pas d’arithm´tique possible sur les e e r´f´rences en Perl.Introduction a la programmation en Perl ` Not a SCALAR reference at script. "$r\n".pl line 23.pl line 23.pl line 23. Ajouter 1 a une r´f´rence ne correspond pas a pointer vers ee ` ee ` l’´l´ment d’indice 1 d’un tableau. $r->[0] = 28. ee eee Notez aussi qu’une r´f´rence peut changer de valeur. c sylvain@lhullier. # modification de $t[0] Derni`re chose importante. = \$v. # modification de $v $r = \@t. mais a faire perdre le caract`re r´f´rence ee ` e ee a la variable (elle devient un scalaire comme un autre) : ` my $v my $r print $r++. print = 45. e e mais n’est plus une r´f´rence. cette v´rification ne peut avoir lieu e qu’au moment de l’ex´cution. si vous passez une r´f´rence a une fonction.

3 $reftab Visibilité de la fonction f3 Les deux r´f´rences pointent donc vers la mˆme zone m´moire. "hello". La syntaxe pour cr´er directement une r´f´rence anonyme vers un scae ee laire est la suivante : \valeur-constante my $ref1 = \34. f3( $r ). mais cela n’est pas la fa¸on de faire la c plus simple. my $r = \@t. Nous avons d´j` vu comment faire cela pour un scalaire avec une ea fonction (fonction f2 un peu avant). my $ref2 = \"er". ee e e 11.org Introduction a la programmation en Perl ` $reftab->[2] = 32. 109 . # equivalent ´ # @t est modifi´ e On peut sch´matiser ce qu’il se passe de la mani`re suivante : e e Visiblité du programme principal $r @t 0 49 1 hello 2 −2 32. f3( \@t ).6 R´f´rences anonymes vers scalaire ee Une r´f´rence anonyme est une r´f´rence vers une variable qui n’a pas ee ee de nom.c sylvain@lhullier. -2 ). } my @t = ( 49. print "$$ref1 $$ref2\n".3.

Introduction a la programmation en Perl ` c sylvain@lhullier. il est impossible de modifier la valeur point´e par la r´f´rence (diff´rence avec le m´canisme de la fonction f2) : e ee e e $$ref1 = "hello". "ac". La variable $r est une r´f´rence vers un tableau comportant trois ´l´ments ee ee alors que la variable @t est un tableau a trois ´l´ments (cette derni`re nota` ee e tion nous est d´j` famili`re) : ea e $r 0 34.4 1 ac 2 −71 @t 0 34. etc] est une r´f´rence ee ee ee ee vers un tableau comportant les ´l´ments en question. elles le sont bien plus avec les tableaux et les tables de e hachage. 11.4. il faut utiliser la e ee notation suivante : [´l´ment1. ee my $r = [ 34. my @t = ( 34.4 1 ac 2 −71 110 . ´l´ment3.org $ref1 34 $ref2 er Une telle valeur est une constante. -71 ].4. "ac". Ce n’est pas dans le cas des scalaires que les r´f´rences anonymes sont ee les plus utilis´es . ´l´ment2.7 R´f´rences anonymes vers tableau ee Pour cr´er une r´f´rence anonyme vers un tableau. -71 ).pl line 24. Modification of a read-only value attempted at script.

peut donc s’´crire de la mani`re suivante : e e my @t = ( 6. e Le structure pr´c´demment d´crite par e e e my @t1 = ( 16. 0.3..c sylvain@lhullier. [ "el". 4 ). donc a une liste de r´f´rences. -33 ].. 4 ]. [ 16.org Introduction a la programmation en Perl ` On acc`de aux ´l´ments de cette r´f´rence anonyme comme pour une e ee ee r´f´rence normale : ee print "$r->[0]\n". my @t2 = ( "el". \@t2. 0. "s" ). } Attention a ne pas ´crire \(2. Ce qui peut se repr´senter toujours sous la forme suivante : e @t 0 6 1 2 3 s 0 el 1 0.3 2 4 0 16 1 −33 On peut pousser le vice jusqu’` utiliser une r´f´rence pour le premier a ee tableau : 111 . ce qui est fort e ` ` ee diff´rent.$v) si vous voulez cr´er une r´f´rence ` e e ee vers un tableau. $r->[2] = 901."er". "s" ).3. -33 ). \@t1.\"er". my @t = ( 6. car cette syntaxe fait toute autre chose : elle est en fait ´quivalente a (\2.\$v). foreach my $e (@$r) { .

3 print "$r->[2]->[2]\n".. [ "el". e e e ` 112 . # affiche 0. @{$r->[1]} est le ee tableau en question.. 0. # affiche el print "$r->[2]->[1]\n". # affiche 16 print "$r->[1]->[1]\n". ee print "$r->[0]\n". # affiche s Ce n’est pas si complexe qu’il n’y paraˆ pour peu que nous ayons un bon ıt sch´ma sous la main . [ 16. } # Parcourt 16 et -33 Il faut noter qu’en cas de d´r´f´rencements successifs. e o De plus. # affiche -33 # $r->[2] est une r´f´rence vers tableau e e print "$r->[2]->[0]\n". # affiche 6 # $r->[1] est une r´f´rence vers tableau e e print "$r->[1]->[0]\n".. On peut donc ´crire : e foreach my $e ( @{$r->[1]} ) { .org $r 0 6 1 2 3 s 0 el 1 0. Vous noterez que nous faisons usage de l’op´rateur e e fl`che (->) plutˆt que de la syntaxe double-dollar ($$). si $r->[1] est une r´f´rence vers tableau. "s" ].. 4 ]. seule la premi`re eee e fl`che est n´cessaire : $r->[2][1] est ´quivalent a $r->[2]->[1]. # affiche 4 print "$r->[3]\n".3 2 4 0 16 1 −33 Comment acc´der aux ´l´ments des diff´rentes profondeurs d’une telle e ee e construction ? Il suffit de suivre les r´f´rences .3. -33 ].Introduction a la programmation en Perl ` my $r = [ 6... c sylvain@lhullier.

nous allons mettre sur pied des e c tables de hachage de tables de hachage : my %h1 = ( ’rue’ ’tel’ my %h2 = ( ’rue’ ’tel’ my $r = { ’Paul’ ’Julie’ => => => => => => ’Pasteur’. \%h2 }. La notation {clef1=>valeur1. clef2=>valeur2. "e" }. ’03729103’ ).c sylvain@lhullier. ’Jaures’. "e" ).8 R´f´rences anonymes vers table de hachage ee De la mˆme fa¸on il est possible de cr´er une r´f´rence anonyme vers une e c e ee table de hachage. 113 . ’06461341’ ). \%h1.org Introduction a la programmation en Perl ` 11. etc} est une r´f´rence vers une table de hachage comportant les couples clef/valeur en ee question. La variable $r est une r´f´rence vers une table de hachage alors que la ee variable %h est une table de hachage (notation famili`re) : e $r Julie Paul => => e 21 %h Julie Paul => => e 21 De la mˆme fa¸on qu’avec des tableaux. 21. my $r = { ’Paul’ ’Julie’ my %h = ( ’Paul’ ’Julie’ => => => => 21.

Introduction a la programmation en Perl ` Ou plus directement : my $r = { ’Paul’ => { ’rue’ ’tel’ ’Julie’ => { ’rue’ ’tel’ };

c sylvain@lhullier.org

=> ’Pasteur’, => ’06461341’ }, => ’Jaures’, => ’03729103’ }

$r

Julie Paul

=> =>

rue tel

=>

Jaures

=> 03729103

tel rue

=> 06461341 => Pasteur

Voici comment acc´der a tous les ´l´ments d’une telle construction : e ` ee # $r->{Paul} est une r´f´rence vers une table de hachage e e print "$r->{Paul}->{tel}\n"; # affiche 06461341 114

c sylvain@lhullier.org

Introduction a la programmation en Perl `

print "$r->{Paul}{tel}\n"; # equivalent ´ print "$r->{Paul}{rue}\n"; # affiche Pasteur # $r->{Julie} est une r´f´rence vers une table de hachage e e print "$r->{Julie}{tel}\n"; # affiche 03729103 print "$r->{Julie}{rue}\n"; # affiche Jaures

Il suffit de suivre sur le sch´ma, d’o` l’importance de faire un bon sch´ma. e u e

11.9

R´f´rences anonymes diverses ee

Il est bient-sˆ r tout a fait possible de m´langer les r´f´rences vers les u ` e ee tableaux et vers les tables de hachage :

my $r = [ [’a’,4], ’b’, [1,’z’], {’P’=>[-2,"er",0],’A’=>7}, 8 ];

Voici le sch´ma correspondant a cette structure (essayer de vous en e ` convaincre !) : 115

Introduction a la programmation en Perl `

c sylvain@lhullier.org

$r

0

1

b

2

3

4

8

0

1

1

z

0

a

1

4

A P

=> =>

7

0

−2

1

er

2

0

Voici comment acc´der a un ´l´ment d’une telle structure : e ` ee print "$r->[3]->{P}->[1]\n"; # affiche "er" print "$r->[3]{P}[1]\n"; # equivalent ´ Les crochets correspondent a une prise d’indice d’un tableau ; les acco` lades a la clef d’une table de hachage. ` Je peux parcourir le premier tableau du deuxi`me niveau (celui qui come porte a et 4) de la mani`re suivante : e my $reft = $r->[0]; foreach my $v (@$reft) { print "$v\n; } Je cr´e une variable $reft qui est une r´f´rence vers ce tableau, je peux e ee ensuite parcourir @$reft qui repr´sente le tableau en question. e 116

ee • faux si son argument n’est pas une r´f´rence (c’est un scalaire clasee sique).org Introduction a la programmation en Perl ` Il est possible d’´crire cela sans cr´er de variable temporaire. les accolades d´limitent e c e la r´f´rence a laquelle on applique le pourcentage : ee ` foreach my $k (keys %{$r->[3]}) { print "$k $r->[3]{$k}\n".10 L’op´rateur ref e La question qui pourrait maintenant venir a l’esprit est la suivante : ` comment pourrait-on ´crire une boucle sur les ´l´ments du tableau r´f´renc´ e ee ee e par $r et surtout comment savoir de quel type ils sont pour pouvoir les utiliser ? Pour r´pondre a cette question. Voici ce que cela donne : foreach my $v (@{$r->[0]}) { print "$v\n". e ` e Il permet de connaˆ le type d’une r´f´rence. On peut alors ´crire le code suivant : e foreach my $p (@$r) { if( ref($p) eq "ARRAY" ) { print "( ". la syntaxe e e est la suivante : @{r´f´rence} Ces accolades n’ont rien a voir avec les tables ee ` de hachage elles permettent juste de d´limiter la r´f´rence a laquelle on e ee ` applique l’arobase. ee • "ARRAY" si son argument est une r´f´rence sur tableau. 117 . ee • "HASH" si son argument est une r´f´rence sur table de hachage. ıtre ee Cette fonction renvoie : • "SCALAR" si son argument est une r´f´rence sur scalaire. } On fait de la mˆme fa¸on pour un table de hachage. } Commencez-vous a voir l’int´ret de faire des sch´mas ? ` e e 11. voici un nouvel op´rateur : ref().c sylvain@lhullier.

} } L’affichage suivant est effectu´ : e ( b ( P A 8 a 4 ) 1 z ) : ARRAY(0x8100c20) : 7 c sylvain@lhullier. afficher le tableau associ´ a la clef P. il existe ee e ` e d´j` une telle fonctionnalit´ en Perl : ea e use Data::Dumper. c’est-`-dire.Introduction a la programmation en Perl ` foreach my $v (@$p) { print "$v ". un seul premier niveau de r´f´rences est explor´.org Dans cet exemple. La seconde consiste en l’affichage de la valeur de retour de o e la fonction Dumper : cette fonction renvoie une (longue) chaˆ de caract`res ıne e repr´sentant toute la structure r´f´renc´e par $r : e ee e $VAR1 = [ [ 118 . La premi`re ligne ajoute des fonctions a Perl (c’est un peu le #include du e ` langage C) et ne doit donc ˆtre pr´sente qu’une seule fois dans le programme e e (plutˆt au d´but). } elsif( ref($p) eq "HASH" ) { foreach my $k (keys(%$p)) { print "$k : $p->{$k}\n". } print ")\n". Ne vous fatiguez pas a les ´crire. } } elsif( !ref($p) ) { print "$p\n". il faudrait a a e ` concevoir un ensemble de fonctions s’appelant les unes les autres en fonction du type des r´f´rences rencontr´es. Pour ee e aller au-del`. print Dumper($r).

{ ’P’ => [ -2.11 R´f´rences circulaires ee La notion de r´f´rence circulaire n’a rien de compliqu´ . Vous noterez que l’affichage effectu´ est directement int´grable dans un e e code Perl. 0 ]. ’A’ => 7 }. ’z’ ]. 4 ]. c’est juste le fait ee e que plusieurs tableaux et/ou tables de hachage et/ou scalaires peuvent se r´f´rencer entre elles. Par exemple : ee 119 . ’b’.org Introduction a la programmation en Perl ` ’a’. ’er’. 8 ]. 11. [ 1.c sylvain@lhullier.

7. $VAR1 = [ 71. $r->[1]{Ptt}{Od} = $r. ee ee Voici comment ´crire cela en Perl : e my $r = [ 71.Introduction a la programmation en Perl ` c sylvain@lhullier. On comprend bien qu’il n’est pas possible de cr´er une telle structure en e une seule instruction.7 On voit bien alors qu’un cycle de r´f´rences existe entre ces r´f´rences. 120 . Comment se comporte Data::Dumper dans une telle situation ? Ne va-t-il pas boucler a l’infini ? Et bien non : il se comporte ` bien : print Dumper($r). { "Hello" => -34.org $r 0 71 1 * Od R5 => => As4 Hello Ptt => => −34. "Ptt" => { "R5" => "As4" } } ].

c sylvain@lhullier. Je viens de casser le lien indiqu´ par un ast´risque. e ` e La solution pour ´viter cela est de ”casser” la circularit´ avant de modie e fier la valeur de la variable $r : $r->[1] = undef. tout ce que $r r´f´ren¸ait serait lib´r´. A a e e ` l’exemple pr´c´dent. e ee 121 . En temps normal. cette fuite m´moire e e n’est pas forc´ment a n´gliger. Et la m´moire sera lib´r´e . Nous sommes e ee donc en pr´sence de zones m´moires inaccessibles (aucune variable ne nous e e permet d’y acc´der) et non lib´rables : cette m´moire est perdue pour le e e e programme ! Elle sera bien sˆ r lib´r´e quand le programme prendra fin.. Mais ici. ’Od’ => $VAR1 }. En effet. qu’en fait. il n’y a plus de boucle e e dans les r´f´rences. ce ee c ee n’est pas le cas.7’ } ]. Data::Dumper se rend compte qu’il passe sur une r´f´rence qu’il a d´j` ee ea parcourue et l’affiche comme telle ($VAR1). je pourrais ´crire : e e e $r = undef. u ee mais s’il s’agit d’un d´mon qui tourne en permanence. je puis sans risque ee ´crire : e $r = undef.. les trois objets peuvent ˆtre lib´r´s. ’Hello’ => ’-34. chacun des tableaux et des tables de hachage ont encore au moins une r´f´rence vers elle. le garbage-collector ne se rend ee pas compte.org Introduction a la programmation en Perl ` { ’Ptt’ => { ’R5’ => ’As4’. Maintenant et seulement maintenant. Pourquoi vous parler de r´f´rences circulaires ? Premi`rement parce qu’il ee e faut savoir qu’il est possible d’en faire (cela peut ˆtre utile de cr´er des listes e e chaˆ ees circulaires etc). Mais surtout parce qu’elles posent des probl`mes ın´ e ` la suite a au garbage-collector dans sa tˆche de lib´ration de la m´moire.

Voici la syntaxe pour cela : open(FILE. sub affiche { my ($ref) = @_. } affiche( $reff ). On peut obtenir une r´f´rence vers une fonction de la mani`re e ee e suivante : sub affcoucou { 122 .13 R´f´rences sur fonctions ee Comme dans le langage C. e Cette adresse correspond a l’endroit de la m´moire o` le code de la fonction ` e u est stock´. 11. Il nous est aussi possible de cr´er une r´f´rence vers un des trois fichiers e ee pr´-existant : e my $refo = \*STDOUT.">toto") or die("$!"). # equivalent ´ close( $reff ). une fonction a elle-aussi une adresse m´moire. Cette derni`re ligne est ´quivalente a close(FILE). affiche( \*FILE ). print $reff "ok\n". my $reff = \*FILE. my $reff = \*FILE. On peut sans rese e ` trictions stocker une r´f´rence vers fichier dans une table de hachage ou dans ee un tableau.12 R´f´rences sur fichiers ee Une ouverture de fichier cr´e une variable dont il est possible de prendre e l’adresse.Introduction a la programmation en Perl ` c sylvain@lhullier. print $ref "ok\n".">toto") or die("$!").org 11. La variable scalaire $reff est une r´f´rence vers le descripteur de fichier ee FILE. Voici des exemples d’utilisation de ces r´f´rences : ee open(FILE.

11.org Introduction a la programmation en Perl ` my ($p) = @_.. # equivalent ´ sub f { my ($f. # appel $ref->("Larry"). N’allons pas trop vite car Perl a ´t´ pr´vu pour la programmation ee e objet et propose les fonctionnalit´s n´cessaires (h´ritage . print "Coucou $p\n".14 Un dernier mot sur les r´f´rences ee De telles structures nous donnent envie de faire de la programmation objet (champs et m´thodes pourraient ˆtre stock´es dans une table de hae e e chage).c sylvain@lhullier. "Larry" ).. } my $ref = \&affcoucou.) en se basant sur e e e les modules. # equivalent ´ Notez bien qu’il est tout a fait possible de stocker une telle r´f´rence ` ee dans un tableau ou dans une table de hachage . La variable scalaire $ref est une r´f´rence vers la fonction affcoucou. ee Elle peut s’utiliser des fa¸ons suivantes : c &$ref("Larry"). 123 .$p) = @_. $f->( $p ).. } f( $ref. "Larry" ). f( \&affcoucou..

org 124 .Introduction a la programmation en Perl ` c sylvain@lhullier.

une ea e e distribution de Perl inclut les modules les plus utilis´s. e e La premi`re chose que je vous invite a faire. peu d’autres langages (voire aucun) ne peuvent pr´tendre ˆtre aussi e e riche que Perl. d’un mˆme protocole . permet d’acc´der a des fonce e ` tions math´matiques de trigonom´trie autres que les seuls cosinus et sinus e e pr´d´finis dans Perl sous les noms de cos et sin. Le nom INC rappelle ´trangement (et c’est u e e voulu) la notion d’include en C. Ces fonctions y sont regroup´es car elles touchent toutes e a un mˆme domaine. Cette variable de type tableau contient la liste des r´pertoires e o` seront recherch´s les modules. le module nomm´ Math::Trig . En quelques mots. e Ainsi. c’est-`-dire de biblioth`ques a e ou encore librairies. L’ordre des r´pertoires de cette variable est e important car si un module vient a ˆtre pr´sent dans deux r´pertoires. dont le contenu de la variable @INC.. c’est a lancer la commande e ` ` perl -V : elle affiche toute sorte d’informations. Perl tire sa puissance de la richesse des modules existants . Par exemple. o 12..Chapitre 12 Utilisation de modules Nous allons aborder ici l’usage des modules. quasiment tous les protocoles r´seau auxquels e vous pouvez penser sont accessibles en Perl en utilisant un module existant.1 Utilisation d’un premier module Il existe de nombreux modules d´j` install´s sur votre syst`me . e e Je vous invite a taper la commande perldoc Math::Trig dans un termi` 125 . a un mˆme ensemble de fonctionnalit´s autour d’une ` e ` e e mˆme utilisation. un module est un ensemble de fonctions regroup´es e dans un fichier. seule `e e e l’occurrence pr´sente dans le premier r´pertoire de la liste comptera (mais e e ce cas proviendrait plutˆt d’une erreur de nommage ou d’installation).

$z = asin(2. vous verrez d´taill´es e e les fonctionnalit´s auxquelles vous avez acc`s avec un module donn´. $x = tan(0. e Ils ont pour objet de modifier ou d’´tendre la s´mantique de Perl. vous visualiserez ainsi la documentation de ce module. Le nom des o modules de ce type est en minuscule. Une fois charg´.9). De petits exemples simples d’utilisations vous sont aussi ` fournis. acos ou e ` asin ainsi qu’` des fonctions de conversion entre unit´s d’angles ou bien a e a la valeur de pi. Cette commande perldoc fonctionne un peu comme la commande man . $rad = deg2rad(120). $y = acos(3.org nal .2-alpha1 qui vous permet d’avoir ces messages avec des explications en fran¸ais). un module n’est pas ”d´chargeable”. Ils sont appel´s modules pragmatiques. Ainsi e e diagnostics permet d’avoir des messages d’erreurs plus complets (vous pouvez charger sur CPAN la version 1. $pi_sur_deux = pi/2. Voici un exemple de code Perl ` l’utilisant (j’en plagie ici la documentation) : use Math::Trig.Introduction a la programmation en Perl ` c sylvain@lhullier. La premi`re ligne de code a ´crire pour utiliser un module est la suivante : e `e use NomDuModule. ce module ayant pour rˆle de rendre la syntaxe Perl plus coercitive. e e 126 . Pour ` notre exemple. e e Vous remarquerez que la ligne use strict.4). n’est en fait que le chargement d’un module . la ligne est : use Math::Trig. e e e Typiquement toutes les lignes use sont regroup´es au d´but du script. Dans bien des cas. c Revenons a notre module Math::Trig.7). cette instruction ajoute des fonctions et des variables a l’espace de nommage (nous reviendrons sur ce point dans la suite). Vous e e e taperez ’q’ pour quitter. Cette ligne devra ˆtre plac´e dans chaque script qui fait usage du module e e et ˆtre ex´cut´e avant tout usage de fonctions ou de variables du module. On voit ici que nous avons acc`s a des fonctions comme tan. que je vous ai conseill´ de e placer dans chaque script. Je laisse au lecteur le soin de deviner (ou plutˆt comprendre) ce que font o ces instructions.

$ftp->cwd("/pub/CPAN/").c sylvain@lhullier. Il est par exemple possible de copier un fichier vers un autre e (fichiers disque ou flux de donn´es).’-anonymous@’). il est ais´ de comprendre comment utiliser de e tels modules (de toute fa¸on la documentation des modules comporte des c exemples).’ move("/dev1/fileA". il permet certaines manipulations de fichiers lourdes a mettre en œuvre avec de simples ap` pels syst`me. Comme l’indique e perldoc File::Copy : use File::Copy. comment se connecter sur un serveur (en mode passif.3 O` trouver les modules ? u C’est tr`s bien tout cela. my $ftp = Net::FTP->new("ftp.\*STDOUT). mais comment trouver le module qui r´pond e e a mon probl`me ? Pour cela je dois vous pr´senter l’archive de tous les mo` e e 127 . Voici un autre exemple de module en action.cpan. Il s’agit du module Net:FTP qui nous permet d’acc´der tr`s simplement aux fonctionnalit´s d’un client e e e FTP. use Net::FTP."/dev2/fileB").org". ->) . Debug => 0. $ftp->quit()."file2"). Voici.gz"). Mˆme si nous ne verrons la programmation objet que e dans une prochaine partie.pm". par exemple. ou d’en d´placer un d’une partition e e vers une autre (impossible avec l’appel syst`me rename). $ftp->login("anonymous". On remarquera au passage la notation objet (new. Quoi de plus simple finalement pour faire du FTP client ? Comment faisais-je avant pour mettre a jour mon site web des seules pages que j’ai ` modifi´es depuis la derni`re fois ? ? ? e e 12. car j’ai un firewall). Passive =>1 ) or die("$!"). copy("file1". copy("Copy. changer de r´pertoire et t´l´charger un fichier : e ee #!/usr/bin/perl -w use strict. beaucoup de modules l’utilisent. $ftp->get("ls-lR.2 D’autres modules Voici l’exemple d’un autre module : File::Copy .org Introduction a la programmation en Perl ` 12.

des versions compil´es (Perl binary distributions) dispoe nibles pour de tr`s nombreuses plate-formes.PL. vous v´rifiez alors que ce module est pr´sent sur votre syst`me en e e e tapant perl -e ’use Net::SMTP’ et vous n’avez plus qu’` l’utiliser. Je vous invite a entrer SMTP et a voir la vari´t´ des modules qui ` ` ee gravitent autour de ce protocole . Une page vous est propos´e avec de nombreuses sections listant des modules regroup´s par th`me. e Je vous invite a visiter le site http://www.. Les modules CPAN sont pr´sents sous forme de package e e dans toute bonne distribution Linux. 128 . CPAN n’en reste pas moins e la source majeure d’informations sur les modules de votre syst`me. Par exemple sous Debian. juste deux mots pour vous dire que les commandes perl Makefile. il s’agit des paquets libxxx-yyy-perl (o` xxx-yyy correspond au nom du module u Xxx::Yyy mis en minuscules). Le lien int´ressant est : CPAN ee e modules. e e L’installation de modules CPAN n’est pas au menu de ce document.cpan. La a documentation sera accessible par perldoc Net::SMTP Juste pour sourire deux minutes. ainsi que de la documentation e sur les modules et de quoi les t´l´charger. le module le plus int´ressant est sˆ rement e u Net::SMTP (plus le nom d’un module est court et semble canonique. je ne vais pas m’appesantir sur la question . make test et make install sont la clef du succ`s.org dules Perl. e e e ainsi qu’un champ de saisie servant a la recherche de mots clefs dans les ` modules. Diff´rents liens permettent de visualie e ser la documentation (le perldoc correspondant) ainsi que de t´l´charger le ee module le cas ´ch´ant.. distributions. j’ai nomm´ CPAN (Comprehensive Perl Archive Network). Cette e archive recense tous les modules diffus´s pour Perl. Vous e vous rendez par exemple compte que le module Net::SMTP r´pond a vos e ` besoins.org/ vous y trouverez de ` tout a propos de Perl. je vous invite a rechercher dans CPAN ` un module nomm´ Sex ´crit un premier avril et d’en lire la documentation e e (ainsi que le code) . Mˆme si vous n’installez pas de module.Introduction a la programmation en Perl ` c sylvain@lhullier.org). Vous pouvez t´l´charger les sources de l’interpr´teur ` ee e (Perl source code). plus il y a de chance qu’il soit int´ressant).cpan. make. and authors (search.

Voici un exemple simple d’un tout petit module complet : # --.1 Premier exemple Pour ´crire un module. e Ce fichier doit contenir une premi`re ligne indiquant le nom du module . pour commencer vous pourriez le placer dans e votre r´pertoire de travail a cˆt´ du script qui l’utilisera.pm : e par exemple Utils. Il est important de voir que le nom du package doit ˆtre le mˆme que celui e e du fichier (` l’extension pr`s).pm Ce fichier doit ˆtre plac´ dans un des r´pertoires e e e list´s dans la variable @INC .pm --package Utils. vous devez ´crire : e package Utils. Le fichier peut ensuite contenir des d´finitions a e e de fonctions. 129 . print "Bonjour $prenom\n". car le r´pertoire .fichier Utils. `e 13. sub bonjour { my ($prenom) = @_. e e e nous allons maintenant apprendre a ´crire nos propres modules. L’extension de ce fichier est imp´rativement . e pour cela.Chapitre 13 ´ Ecrire un module Apr`s avoir manipul´ des modules existants et avoir parl´ de CPAN. e ` oe e est pr´sent dans ce tableau @INC. use strict. nous devons cr´er un fichier ind´pendant du ou e e e des scripts qui l’utilisent.

La derni`re ligne correspond a l’appel de la fonction bonjour du module e ` Utils. Ces variables e seront : • soit accessibles exclusivement aux fonctions pr´sentes dans le module e (on pourrait parler de variables priv´es.Introduction a la programmation en Perl ` } 1. # chargement du module Utils::bonjour( "Paul" ).2 Et les variables ? Il est possible de d´clarer des variables propres au module.pl --use strict. il est n´cessaire d’ine voquer l’instruction use suivie du nom du module. e e # --. e e • soit aussi accessibles a l’ext´rieur du module (on pourrait parler de ` e variables publiques ou variables globales). 13. Une variable aussi accessible depuis l’ext´rieur ıt e a e du module se d´clare avec our (my pour dire ”` moi”. celle qui contient 1. 130 . Une variable accessible exclusivement aux fonctions du module se d´clare e avec my (que l’on connaˆ d´j`).pm --package Utils.fichier script. e nous reviendrons plus tard sur son rˆle.org Il est important de ne pas oublier la derni`re ligne. . on utilisait un autre m´canisme dont e je ne parlerai pas ici. e e e les variables d´clar´es dans les fonctions sont comme toujours locales au bloc e e dans lequel elles sont d´clar´es. Voici un exemple de l’utilisation du module pr´c´dent : e e #!/usr/bin/perl -w # --. La syntaxe est la suivante : le nom du module est suivi de deux signes deux-points puis du nom de la fonction. o Pour pouvoir utiliser ce module dans un script. Avant la version 5. assurez-vous d’avoir une version r´cente de Perl (cf e perl -v). correspondant aux variables e static d´clar´es en dehors des fonctions en C).6 de Perl. our pour dire ”` e a a nous”). use strict.fichier Utils. c sylvain@lhullier. Ces variables doivent ˆtre d´clar´es en dehors de toute fonction . use Utils.

# Ok : print "$Utils::x\n". ce qui e e donne : $Utils::x au final. a la fin du fichier de e ` notre module. Il n’y a pas d’erreur de ma part : on n’´crit pas e Utils::$x ! :-) 13.pl --use strict. Ici. print "$x $y\n". De mˆme que pour les fonctions. Utils::bonjour( "Paul" ). depuis e l’ext´rieur du module. } 1. use Utils.c sylvain@lhullier.3 De la derni`re ligne d’un module e Jusqu’ici.org Introduction a la programmation en Perl ` # variable accessible our $x = ’toto’. Que la variable soit d´clar´e avec my ou avec our. # fonction sub bonjour { # Variable locale my ($prenom) = @_. # variable inaccessible my $y = ’toto’. A l’inverse. le nom complet de la variable est donc Utils::x qu’il faut faire pr´c´der d’un signe dollar. seule la variable $x est e a accessible. #!/usr/bin/perl -w # --. il est tout a fait possible e e ` ` d’y acc´der depuis une fonction du module (ici bonjour).fichier script. c’est-`-dire depuis le script. les noms de variable sont pr´fix´s par e e e le nom du module puis deux signes deux-points. # Erreur : print "$Utils::y\n". nous avons toujours plac´ une ligne 1. print "Bonjour $prenom\n". Il faut savoir que cette valeur est la valeur du chargement du 131 .

pm doit ˆtre pr´sent dans ce r´pertoire e e e Truc. une e e valeur vraie (comme ici 1) indique au contraire que le chargement s’est bien d´roul´.org module (valeur de l’instruction use Utils. Une valeur fausse mettra fin au script qui fait appel a l’instruction e e ` use. Ces noms compos´s permettent de regrouper les modules par type d’usages . Je ne done nerai pas d’exemple ici car le cas est rare de la n´cessit´ d’un tel usage.pm --package Truc::Utils.) et le fichier Utils. our $x = ’toto’. ` e Revenons a notre exemple Truc::Utils. sub bonjour { my ($prenom) = @_. Voici un exemple de tel module : # --.Introduction a la programmation en Perl ` c sylvain@lhullier. 13. use strict. d’une connexion r´seau (ou je-ne-sais-quoi encore.) et qu’elle indique si ce chargement s’est bien pass´ ou non : une valeur fausse indique un probl`me.pl --132 . print "Bonjour $prenom\n". Il est donc tout a fait possible de mettre une autre valeur qu’une valeur ` constante .fichier Truc/Utils. par e exemple Net correspond a tout ce qui concerne le r´seau. e e On pourrait imaginer conditionner le chargement du module a l’ouverture ` d’un fichier. Ce nom Truc correspond a un ` ` r´pertoire qui doit ˆtre pr´sent dans un des r´pertoires de la variable @INC e e e e (par exemple .. Et voici un script l’utilisant : #!/usr/bin/perl -w # --. on peut.. envisager mettre un test en derni`re inse truction pour v´rifier si les conditions sont r´unies pour l’usage du module.4 R´pertoires e Voyons maintenant comment cr´er des modules aux noms compos´s e e comme Truc::Utils (nous avons par exemple vu le module Net::FTP). mais e e il faut savoir que cela est possible.). par exemple. } 1.fichier script.

5 Blocs BEGIN et END Les amoureux de awk retrouveront ici deux de leurs enfants pr´f´r´s eee :-)). avant toute autre instruction du module (y compris les use plac´s dans le module). Truc::Utils::bonjour( "Paul" ). Tout se passe comme si e e 133 .. } 1. use Truc::Utils. Rien de sorcier. Ces blocs vont nous servir a pr´parer le e ` e terrain au d´but et a lib´rer les ressources a la fin. 13.. mais bien de blocs lab´lis´s. Notez bien qu’il ne s’agit pas de fonctions (pas de mot clef sub).. } BEGIN { print "Chargement du module\n".c sylvain@lhullier. Dans un module. Le bloc END sera ex´cut´ lors de la fin du programme. ces instructions sont e e ex´cut´es au moment du chargement du module. } END { print "Fin d’usage du module\n". use strict. package Utils. Le bloc BEGIN sera ex´cut´ lors de l’instruction e e e e use Utils. e ` e ` Lorsque dans un module sont pr´sentes d’autres instructions que des e d´finitions de variables et des d´finitions de fonctions. sub f { .org Introduction a la programmation en Perl ` use strict. print "$Truc::Utils::x\n". e e e L’usage de ces deux blocs peut ˆtre n´cessaire lorsque l’utilisation du e e module est conditionn´e par l’obtention d’une ou plusieurs ressources comme e un fichier ou une connexion r´seau. il est possible de pr´voir deux blocs d’instructions e qui seront ex´cut´s soit d`s le chargement du module (bloc BEGIN) soit lors e e e de la fin de l’usage du module (bloc END).

e 13. e • ceux qui sont individuellement exportables en fonction de ce que demande le script utilisateur.org ces instructions figurent dans un BEGIN implicite. Placer une fonction ou une variable d’un module dans l’espace de nommage d’un script ou d’un autre module s’appelle faire un export.Introduction a la programmation en Perl ` c sylvain@lhullier. La premi`re est l’invocation du module Exporter . Pour avoir la capacit´ d’exporter des symboles. notre module future exportateur doit comporter les lignes suivantes : package Utils. L’usage d’un bloc BEGIN permet juste au programmeur d’´crire un code un peu plus lisible et e propre. 134 . e avec la seconde on indique que notre module est un (ISA) Exporter (nous reverrons cette syntaxe et ses implications en programmation objet). Notre module est maintenant capable d’exporter des symboles. Je veux dire par e l` que d’´crire Utils::bonjour a chaque fois que vous voulez appeler cette a e ` fonction est sans doute lourd et est quelque peu p´nible a la longue. Ce symbole est donc import´ e par le script. • ceux qui sont exportables en groupe (on parle de tags) selon ce que demande le script utilisateur. Ces deux nouvelles lignes d’instructions doivent ˆtre plac´es juste apr`s e e e l’instruction package. on parle d’exporter le symbole (fonction ou variable). dans la mesure o` toutes ces instructions sont regroup´es sous un u e nom (BEGIN) qui rappelle explicitement qu’elles sont ex´cut´es au d´but. e e e Notez bien que la programmation objet (lire la suite) a quelque peu rendu ces deux blocs obsol`tes voire inutiles. use Exporter. Il existe e ` un moyen pour n’avoir qu’a ´crire bonjour sans avoir a rappeler le nom e ` du module qui contient la fonction. Il existe quatre types de symboles (fonctions ou variables) : • ceux qui sont export´s pas d´faut : le script utilisant le module n’a e e rien besoin de faire de sp´cial (autre que de faire le use) pour que ces e symboles soient export´s.6 Introduction ` l’export de symboles a Sous ce titre barbare se cache une id´e simple : il peut ˆtre p´nible de e e e toujours ´crire le nom complet des fonctions de modules. our @ISA = qw(Exporter). En faisant cela nous allons ajouter la fonction dans l’espace de nommage du script.

e e` C’est-`-dire que ce symbole n’est pas export´ par d´faut. 13. hello("Peter"). Sachez juste que ce et-commercial peut ˆtre e omis. e e Chacun des trois premiers ensembles est associ´ a une variable d´clar´e e` e e avec our. Cette ligne plac´e dans le module Utils a la suite de la ligne e ` our @ISA = qw(Exporter). o 13. Il est courant d’initialiser ce tableau avec l’op´rateur qw que nous avons d´j` vu et sur lequel je ne reviendrai e ea donc pas : our @EXPORT = qw(&bonjour &hello $var). si e les variables doivent ˆtre cit´es avec leur caract`re de diff´rentiation de type e e e e (le dollar. Plutˆt simple. il s’agit donc d’un tableau. Notez bien que. l’arobase ou le pourcentage). e e Un symbole doit apparaˆ dans la variable @EXPORT_OK pour ˆtre auıtre e toris´ a ˆtre export´ : e`e e 135 .org Introduction a la programmation en Perl ` • ceux qui ne sont pas exportables (c’est-`-dire qu’il faudra toujours a faire pr´c´der leur nom par le nom complet du module). il en est de mˆme avec les fonctions e et le signe ”et-commercial” (&). print "$var\n". bonjour("Paul").8 Export individuel de symboles Un symbole peut ˆtre export´ a la demande de celui qui utilise le module.7 Export par d´faut de symboles e Les symboles export´s par d´faut doivent ˆtre list´s dans la variable e e e e @EXPORT . Voici comment on peut maintenant utiliser le module en question : use Utils.c sylvain@lhullier. mais il peut faire a e e l’objet d’un export s’il est nomm´ment cit´ lors de l’instruction use. va permettre d’utiliser les fonctions bonjour et hello ainsi que la variable scalaire $var sans pr´fixe dans le script utilisateur.

print "$var2\n". Pour cela il convient d’ajouter une liste de symboles a l’instruction ` use : use Utils qw(&ciao $var2). 136 . L’import d’un tag provoque l’import de tous les symboles composant ce tag.. 13. print "$var2\n". ciao("Paula"). il nous faut ajouter a la liste e ` ` des imports le tag :DEFAULT : use Utils qw(:DEFAULT &ciao $var2).Introduction a la programmation en Perl ` our @EXPORT_OK = qw(&gutenTag &ciao $var2). Ce m´canisme de s´lection des symboles export´s permet a l’utilisateur e e e ` du module de ne pas trop polluer son espace de nommage et de choisir les seules fonctions dont il aura besoin. Un tag est une liste de symboles. c sylvain@lhullier.. ciao("Paula"). print "$var\n". Pour rem´dier a cela. Cette ligne importe donc les symboles demand´s et ces derniers sont e donc utilisables sans pr´fixe. je trouve cela aussi stupide que vous .9 Export par tags de symboles Il est possible de regrouper les symboles dans des tags. ne me demandez pas pourquoi. La variable qui entre ici en jeu est %EXPORT_TAGS . bonjour("Paul"). T2=>[qw(&ciao $var2)]). e Il se trouve qu’une telle ligne n’importe plus les symboles par d´faut e (ceux de la variable @EXPORT) . A chaque tag est associ´e une r´f´rence vers e ee un tableau contenant la liste des symboles du tag : our %EXPORT_TAGS=(T1=>[qw(&ciao &gutenTag)].org Ces trois symboles sont maintenant exportables dans le script utilisant ce module. il s’agit ` donc d’une table de hachage. hello("Peter").

gutenTag("Hans"). ciao("Paula"). print "$var2\n".pm : package Utils.c sylvain@lhullier. leur export sera impossible. } 137 . Le nom du tag est plac´ dans la liste des modules pr´c´d´ par le signe e e e e deux-points. our @EXPORT = qw(&f1 &f2). use Exporter. bonjour("Paul"). our @ISA = qw(Exporter). print "$var2\n". T2 => [qw(&f4 &f6)]). our %EXPORT_TAGS = (T1 => [qw(&f5 &f6)].org Introduction a la programmation en Perl ` Le tag T1 est associ´ aux fonctions ciao et gutenTag. sub f1 { print "f1\n". 13.10 Exemple complet d’exports Voici un exemple complet d’usage des exports dans les modules . j’ai essay´ de regrouper toutes les configurations. Voici un usage de ce module : use Utils qw(:T2). Remarque importante : les symboles pr´sents dans les listes associ´es e e aux tags doivent absolument ˆtre pr´sents dans @EXPORT et/ou @EXPORT_OK. On voit alors que DEFAULT est un tag. print "$var\n". use strict. ciao("Paula"). Il est possible de combiner les diff´rents types d’acc`s : e e use Utils qw(:DEFAULT &ciao :T1). Le nom des tags est par e ` ` convention en majuscules. e Voici le module Utils dans le fichier Utils. our @EXPORT_OK = qw(&f3 &f4 &f5 &f6). e e Dans le cas contraire. Le tag T2 est e associ´ a la fonction ciao et a la variable $var2. hello("Peter").

13. "f5\n". Pour plus d’informations et d’exemples je vous invite a vous r´f´rer a ` ee ` perldoc Exporter.11 Fonctions inaccessibles Vous allez me poser la question suivante : comment faire pour rendre une fonction d’un module inaccessible depuis le script ? Et je vous r´pondrai : e cela n’est a priori pas possible (vous allez voir que si finalement). } } } } } c sylvain@lhullier. e notamment par rapport a des langages comme Java ou C++.org Et voici un script l’utilisant (apr`s chaque appel de fonction est signal´e e e la raison qui fait qu’il est possible de l’appeler sans pr´fixe) : e #!/usr/bin/perl -w use strict.Introduction a la programmation en Perl ` sub sub sub sub sub 1. "f4\n". mais qui n’en e reste pas moins utilisable. Perl n’est pas un langage extrˆmement coercitif. # tag DEFAULT f2(). f2 f3 f4 f5 f6 { { { { { print print print print print "f2\n". "f3\n". # pas import´e e f6(). # individuellement f4(). Cette confiance en l’utilisateur du module est souvent suffisante et les modules CPAN sont bˆtis sur ce mod`le. a e 138 . use Utils qw(:DEFAULT :T2 &f3). # tag T2 Utils::f5(). Il n’y a donc ` rien de pr´vu dans le langage pour rendre certaines fonctions uniquement e accessibles depuis l’int´rieur du module. "f6\n". f1(). Vous l’avez compris. # tag DEFAULT f3(). # tag T2 Notez bien le cas de la fonction f5 qui n’est pas import´e. Est alors apparue la convention e suivante : toute fonction ou variable dont le nom commence par un soulign´ e (ou under-score ’_’) est priv´e et ne doit pas ˆtre utilis´e a l’ext´rieur du e e e ` e module.

si vous ˆtes outr´ par ce que je viens d’´crire car vous ˆtes e e e e e un fanatique de Java ou autres.12 Documentation des modules Documenter son travail est important pour une r´-utilisation du code e par d’autres ou mˆme par soi-mˆme plus tard . 13. permet cela. comme le code Perl est toujours accessible en lecture.c sylvain@lhullier.pm .5). my $affiche = sub { my ($n.$m) = @_.org Introduction a la programmation en Perl ` N´anmoins. il existe un moyen d’´crire des fonctions e vraiment internes aux modules. use strict. print "$n. Il faut pour cela d´clarer une variable avec e my (donc invisible depuis l’ext´rieur du module) et d’en faire une r´f´rence e ee anonyme vers fonction : package Utils.. En Perl la documentation e e des modules se fait dans le code mˆme du module.Useful functions 139 . Perl n’est pas fait pour les parano¨ ıaques. Son usage est donc r´serv´ aux fonctions d´clar´es dans e e e e le module : sub truc { $affiche->(4... il est toujours possible a l’utilisateur du module de prendre le code en copier` coller et d’en faire une fonction personnelle . }. Les instructions POD commencent toujours par e le signe ´gal (=). $m\n". e La documentation d’un module commence typiquement ainsi : =head1 NAME Utils. } Remarquez que. e e nomm´e POD. La variable $affiche est donc une variable priv´e qui pointe vers une e fonction anonyme. Une syntaxe particuli`re..

Les blocs de POD et les portions de code peuvent alterner : cela est mˆme recommand´ de documenter une fonction et d’en faire suivre le code. 140 .org =head1 SYNOPSIS use Utils. Les tags =over. Le reste du texte est libre. Le tag =cut indique la fin du POD. =head1 DESCRIPTION Blabla blabla =head2 Exports =over =item :T1 Blabla =item :T2 Blabla =back =cut Les tags =head1 d´finissent des en-tˆtes de premier niveau (des gros e e titres) et les tags =head2 d´finissent des en-tˆtes de deuxi`me niveau (des e e e sous-titres). La fin de ce POD est signal´e a l’aide du tag =cut et le code Perl peut e ` alors reprendre. =head1 FUNCTION hello This function prints hello.Introduction a la programmation en Perl ` c sylvain@lhullier. package Utils. Il est de coutume de mettre les premiers exclusivement en majuscules. =item et =back permettent de mettre en place une liste. bonjour("Paul"). e e Pour cela vous devez savoir que l’apparition en d´but de ligne d’un tag POD e indique la fin temporaire du code Perl et le d´but d’un bloc de documentae tion.

c sylvain@lhullier. =cut sub bonjour { my ($prenom) = @_. print "Bonjour $prenom\n".pm . ıt Quoi de plus simple ? NAME Utils.Useful functions SYNOPSIS use Utils.org Introduction a la programmation en Perl ` =cut sub hello { my ($firstName) = @_. DESCRIPTION Blabla blabla Exports :T1 Blabla :T2 Blabla 141 . bonjour("Paul"). print "Hello $firstName\n". allez-vous me demander ? Rien de plus simple : perldoc est notre alli´ ! Tapez donc perldoc Utils e (ou tout autre nom que vous aurez choisi de donner a votre module) et ` sa documentation apparaˆ au format man comme tout bon module CPAN. } =head1 FUNCTION bonjour This function prints hello in french. } Comment visualiser une telle documentation.

je vous invite a e ` consulter perldoc perlpod o` de nombreux exemples sont donn´s.. des coll`gues e voire avec la communaut´... c sylvain@lhullier. FUNCTION bonjour This function prints hello in french. 13.. ne serait-ce que pour une r´-utilisation de fonctionnalit´s dans e e d’autres scripts ou pour partager votre code avec des amis. Mais mˆme sans cela. n’h´sitez pas a faire des ` e e e ` modules.org Pour plus d’informations et de d´tails sur ce format. Vous u e pouvez aussi jeter un oeil au code d’un module ou deux dont le perldoc vous intrigue . Vous e vous rendrez compte de cette n´cessit´ lorsque vous aurez un fichier de e e code trop gros a g´rer .13 Un dernier mot sur les modules J’esp`re que la lecture de cette partie vous a donn´ envie de structurer e e votre code en regroupant vos fonctions dans de telles biblioth`ques. e 142 .Introduction a la programmation en Perl ` FUNCTION hello This function prints hello.

1 Vous avez dit objet ? Sans revenir sur la th´orie de la programmation objet. Perl. Le programe meur est invit´ a faire les choses proprement. mais rien de l’y oblige. le langage Perl ne saurait ˆtre aussi strict que des langages exclusivement objet.Chapitre 14 Programmation objet La programmation objet est le concept nouveau de ces vingt derni`res e ann´es. Le C++ ´tant compil´ et devant rester compatible e e avec le C. qui utilisait un garbage collector bien avant que Java n’existe. la richesse et la facilit´ d’´criture qu’il manque aux langages e e uniquement objet. La programmation par objets ouvre le champ des possibilit´s offertes au e programmeur . Java a ´t´ mis au point e a ee (entre autres) pour passer outre les nombreux pi`ges et probl`mes de C++. La programmation orient´e objet est un e type de programmation qui se concentre principalement sur les donn´es. elle offre e ` la souplesse. cela fut un challenge de mettre sur pied ce langage . cela explique sans doute pourquoi C++ est si complexe et comporte tant de pi`ges. e de par sa nature interpr´t´e. e` 14. e ` On notera que ces extensions sont peu nombreuses car l’id´e a ´t´ de e ee r´utiliser au maximum ce qui existait d´j` en Perl et de l’appliquer a la e ea ` programmation objet. ne pouvait pas ˆtre en reste et la communaut´ Perl a rapidement propos´ les e e e extensions du langage n´cessaires a ce type de programmation. ee e Perl. je vais tenter ici e d’y faire une courte introduction. n’a pas pos´ de probl`me pour s’´tendre a ee e e e ` l’objet. C++ est bˆti sur le C et apporte l’objet. de par sa nature permissive. e e Ruby est un langage interpr´t´ bas´ sur ce concept objet. La e 143 . alli´e a un langage puissant et flexible comme Perl. Toutefois.

e e 14. Dans e notre exemple. la couleur.pm --package Vehicule. on dit en Perl que l’on b´nit (bless en anglais) la r´f´rence.pm e comme nous le faisons pour tout module.2 Pr´paratifs e Nous allons maintenant voir comment ´crire une classe en Perl. la couleur et la mati`re sont renseign´es. 1: 2: 3: # --. e sous forme de la clef pour le nom du champ et de la valeur pour la valeur du champ. il s’agirait d’une chaussure dont la pointure. cela est tr`s simple et d´mystifie la programmation objet. e e En Perl. Elle contient un champ d´crivant la e e pointure. Dans le ee e ` constructeur. par exemple. e ee Les champs de l’objet seront en fait stock´s dans cette table de hachage. la mati`re etc. ee e On parle de ”classe”. Grose e e si`rement une m´thode est une fonction appliqu´e a un objet. use strict.3 ´ Ecrire un constructeur Nous d´finissons un package Vehicule dans un fichier Vehicule. Voyons un exemple : d´finissons une classe Vehicule qui comporte deux e champs : un nombre de roues et une couleur. ` En programmation OO. nous allons donc cr´er une r´f´rence (typiquement vers une e ee table de hachage) et nous allons l’associer au package en question . qui pose la question ”quelles sont les fonctions/actions a faire ?”. e e e ` Une fois d´finie une telle classe. ces traitements sont appel´s ”m´thodes”.org question qui se pose en programmation OO (orient´e objet) est ”quelles sont e les donn´es du probl`me ?” a l’instar de la programmation proc´durale par e e ` e exemple. on parle ainsi d’objets.Introduction a la programmation en Perl ` c sylvain@lhullier. une classe n’est autre qu’un module et un objet (instance de cette classe) n’est autre qu’une r´f´rence associ´e a cette classe. Vous e verrez. qui est une mani`re de repr´senter des donn´es e e e et comporte des traitements : une classe ”Chaussure” d´crit. 144 . e les caract´ristiques d’une chaussure.fichier Vehicule. auxquels on peut affecter des variables/attributs (propri´t´s) et des fonctions/actions (m´thodes). 14. il est possible d’en construire des inse tances : une instance d’une classe est dite ˆtre un objet de cette classe. Une telle classe comporte de plus des e traitements sur ces donn´es . lors de cette association.

cela e semble superflu.. Il s’agit donc d’un constructeur .org Introduction a la programmation en Perl ` 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: sub new { my ($class. bless($this. La ligne 13 comporte le fameux code de retour du chargement du module. $class). my $this = {}. un constructeur en Perl est une simple fonction renvoyant un objet. $this->{NB_ROUES} = $nbRoues.. } 1.$nbRoues. e e Cette fonction prend en premier param`tre le nom de la classe . Mais comprenez bien qu’il n’y a rien d’obligatoire dans cette appellation. return $this. :-) ee Nous d´finissons une fonction new (ligne 4) dont le but est de construire e un objet Vehicule. Cette r´f´rence est stock´e dans une variable scalaire nomm´e $this ee e e car il va s’agir de notre futur objet. Le nom de cette variable est totalement arbitraire et j’ai choisi de prendre le nom $this car il rappelle les variables this de C++ et de Java. les noms exclusivement en majuscules sont in´l´gants. A La ligne num´ro 2 indique le nom du package actuel . simplement pour des raisons d’orgae nisation et de maintenance. $this->{COULEUR} = $couleur. Il est bon de noter que le choix du nom pour cette fonction est totalement libre . le nom des modules et donc des classes que le programmeur d´finit e doit ˆtre compos´ de majuscules et de minuscules. En Perl. On pourrait par exemple choisir le nom de la classe (si on est un habitu´ de C++ ou de Java). Il est d’ailleurs fr´quent que le nom de l’objet dans les e m´thodes soit plutˆt $self en Perl (vous trouverez ce nom dans la plupart e o 145 . Ligne 7. mais on verra qu’il n’en est rien.$couleur) = @_. # ` ne pas oublier. avec typiquement une e e majuscule au d´but de chaque mot . il est courant de l’appeler new mais rien ne nous y oblige. mais on verra par la e suite que cela n’est pas forc´ment une bonne id´e. Les param`tres suivants e sont laiss´s a la discr´tion du programmeur : bien souvent on passe ici les e ` e valeurs de champs pour l’initialisation. C’est ce que l’on fait ici : le nombre de roues et la couleur sont transmis (ligne 6). La ligne 3 force une syntaxe plus rigoureuse.c sylvain@lhullier. les noms de package exclusivement en e minuscules sont r´serv´s pour les modules pragmatiques de Perl (dits moe e dules pragma comme strict etc). il est conseill´ de e e choisir le mˆme nom que pour le fichier. nous cr´ons une r´f´rence anonyme vers une table de hachage e ee vide {}.

Notez que le nombre. le nom et le contenu des champs peuvent donc varier d’une instance de la classe a une autre instance de cette mˆme classe. il est e ` libre de faire ce qu’il veut de chacun de ses objets. Pour affecter un champ de l’objet que nous sommes en train de construire. L’op´rateur e bless associe le package en question a la r´f´rence. e Dans les lignes 9 et 10. Cette variable $class vaudra ici Vehicule. 146 . Comme pour tout module. les champs NB_ROUES et COULEUR sont initialis´s.Introduction a la programmation en Perl ` c sylvain@lhullier. nous devons explicitement indiquer que nous allons l’utiliser : use Vehicule. nous indiquons que cette r´f´rence est li´e au package (` la ee e a classe) $class. La ligne 11 consiste en un return de la r´f´rence vers la table de hachage ee ainsi construite. Nous pouvons maintenant utiliser le constructeur que nous avons d´fini : e my $v = Vehicule->new( 2.4 Appeler le constructeur Pour faire usage de cette classe. e Le champ d’un objet n’est rien d’autre qu’une entr´e dans la table de hachage e qui constitue l’objet. il va respecter les habitudes de ce type c de programmation qui veut que toutes les instances d’une mˆme classe aient e les mˆmes champs . il suffit de cr´er un couple clef/valeur dans la table e de hachage r´f´renc´e par $this. La r´f´rence est main` ee ee tenant li´e au package. my $v2 = Vehicule->new( 4. "rouge" ). Ligne 8.org des modules objet de CPAN). nous allons devoir disposer d’un script ´crit dans un autre fichier (par exemple script. ` e Libre au programmeur de faire ce qu’il veut : si le but est de vraiment programmer objet de fa¸on formelle. mais s’il ne tient pas a respecter ces contraintes. 14.pl) : e #!/usr/bin/perl -w use strict. "bleu" ). J’ai pris l’habitude de mettre le nom des ee e champs en lettres majuscules.

ce nom est totalement arbitraire. Elle est donc une r´f´rence vers une table de hachage dont ee deux champs sont initialis´s et qui a ´t´ b´nie (bless) en Vehicule. Idem e ee e pour $v2. comme e e on le verra un peu plus loin.c sylvain@lhullier. Cette formulation va sans doute rassurer les habitu´s de Java ou de e C++. En effet. 14. Il n’en est rien . "bleu" ). ils sont de la mˆme classe Vehicule. la modification de l’un ne modifiant pas l’autre. mais peut induire le programmeur en erreur. la r´f´rence $v sait de quelle classe elle est. On dit e que ces deux variables $v et $v2 sont des Vehicule.org Introduction a la programmation en Perl ` Nous venons ici de cr´er deux instances de la classe Vehicule. si ee 147 .5 Manipulations de l’objet Revenons a notre exemple. Ces deux objets sont donc ind´pendants l’un de l’autre . Voici un sch´ma de l’´tat de notre m´moire : e e e $v Vehicule NB_ROUES COULEUR => => 2 bleu $v2 Vehicule NB_ROUES COULEUR => => 4 rouge Cette syntaxe Vehicule->new correspond a l’appel du constructeur new ` que nous venons d’´crire. En effet. mais e e en constituent des instances autonomes. Il est aussi possible de faire usage de la syntaxe suivante : my $v = new Vehicule( 2. La variable $v est initialis´e a la valeur de retour e e ` de cette fonction. cette derni`re e syntaxe semble indiquer que new est un op´rateur sp´cifique pour appeler un e e constructeur et est donc un mot r´serv´ du langage. En plus de savoir qu’elle pointe vers une ` table de hachage.

e 148 . nous obtenons quelque chose de la forme : e HASH(0x80fef74) Un objet (` partir de maintenant nommons ainsi une r´f´rence vers une a ee table de hachage b´nie) sait donc de quelle classe il est. Autrement dit."\n". e e e e e e Il faut bien voir que $v est une r´f´rence vers un objet. nous obtenons deux variables qui pointent vers le mˆme objet. print Dumper($v). ’NB_ROUES’ => 2 }. ’Vehicule’ ).Introduction a la programmation en Perl ` nous l’affichons : print "$v\n". ee si on fait une copie de cette variable my $w = $v.org Je vous rappelle que dans le cas de l’affichage d’une r´f´rence vers une ee table de hachage non b´nie. L’affichage suivant est effectu´ : e $VAR1 = bless( { ’COULEUR’ => ’bleu’. Cela va lui permettre e de choisir le bon package quand on appelera une m´thode sur cet objet (lire e la suite). Voyons maintenant ce que donne le module Data::Dumper (dont j’ai d´j` ea parl´) sur une telle r´f´rence : e ee use Data::Dumper. On remarquera que la tradition de Data::Dumper qui consiste en ce que la chaˆ renvoy´e est directement int´grable dans un code Perl est ıne e e respect´e : mˆme l’op´ration de b´n´diction (bless) est pr´sente. Nous obtenons la chose suivante a l’´cran : ` e Vehicule=HASH(0x80f606c) c sylvain@lhullier.

en fait un constructeur est une simple fonction qui renvoie une r´f´rence b´nie.org Introduction a la programmation en Perl ` $v Vehicule NB_ROUES => => 2 bleu $w COULEUR $v2 Vehicule NB_ROUES COULEUR => => 4 rouge La modification de l’objet point´ par l’un modifiera celui point´ par e e l’autre car il s’agit du mˆme objet. $class). Je peux donc ´crire un autre constructeur (donc e avec un autre nom) : sub nouveau { my ($class. Le nom new que j’ai choisi pour le constructeur n’a rien d’obligatoire. return $this. } Ce constructeur de Vehicule prend par exemple un seul param`tre (la e ` couleur) et n’affecte pas de champs NB_ROUES car rien de ne l’y oblige.c sylvain@lhullier. Seule la syntaxe d’appel change par rapport a ce que ee e ` l’on a vu pour les modules. my $this = {}. e 14.$couleur) = @_. bless($this. A moi 149 . $this->{COULEUR} = $couleur.6 Plusieurs constructeurs Comment ´crire plusieurs constructeurs pour une mˆme classe ? Rien e e de plus simple.

org de savoir comment je veux g´rer mes v´hicules.7 ´ Ecrire une m´thode e Une m´thode est une fonction qui s’applique a une instance de la classe. $class). ` e 14. il est possible e c e e d’utiliser la syntaxe suivante : my $v2 = nouveau Vehicule( "bleu" ). je roule a $vitesse. $this->{NB_ROUES} = 0. quelque peu d´routant. De la mˆme fa¸on que pour le pr´c´dent constructeur.Introduction a la programmation en Perl ` c sylvain@lhullier. ` } 150 . Ce qui est. e ` Cela est vrai dans tous les langages objet. print "Avec $this->{NB_ROUES} roues. reconnaissons-le. return $this.\n". e dans notre cas rien de masqu´.$vitesse) = @_. C’est pour cela que e je vous conseille d’utiliser plutˆt la premi`re syntaxe Vehicule->nouveau() o e ou alors de vous en tenir a un constructeur new pour ´crire new Vehicule(). my $this = {}. a savoir comment j’autorise e e ` qu’ils soient construits. mais bien souvent cela est masqu´ . Pour ˆtre propre et coh´rent. bless($this. } Voici comment on va faire appel a ce constructeur : ` my $v2 = Vehicule->nouveau( "bleu" ). $this->{COULEUR} = $couleur.$couleur) = @_. nous allons tout de mˆme consid´rer qu’il e e e e est sage d’affecter une valeur a la clef NB_ROUES : ` sub nouveau { my ($class. le premier param`tre de la fonction sera e e l’objet (la r´f´rence b´nie) : ee e sub roule { my ($this.

` ´ Ecrivons par exemple une m´thode d’affichage : e sub toString { my ($this) = @_. e Cette m´thode peut d`s maintenant ˆtre appel´e depuis le fichier e e e e script. la seule ` contrainte est sa premi`re place parmi les arguments. Les habitu´s de Java noterons que j’ai choisi le nom de cette fonction e pour leur rappeler des souvenirs. La fonction appel´e sera celle qui a pour nom roule d´finie dans le e e package li´ a la r´f´rence $v lors de sa b´n´diction. } Cette m´thode renvoie une chaˆ de caract`res.pm a donc pour premier e e param`tre l’objet sur lequel elle est appel´e. repr´sentation de l’obe ıne e e jet. mais qu’il n’a rien de sp´cial. ` 151 .pl : e e $v->roule( 15 ). return "(Vehicule:$this->{NB_ROUES}. e` ee e e L’affichage suivant a donc lieu : Avec 2 roues. Vous noterez une fois de plus e e que rien n’oblige le programmeur a nommer cette variable $this . je roule a 15.bleu) Libre a vous de choisir un plus bel affichage."\n". Pour appeler la m´thode.pl sur les objets de type Vehicule. il suffit d’´crire dans le fichier script. Il n’y pas de n´cessit´ de faire e e usage du lourd m´canisme d’Exporter car nous n’avons pas besoin de moe difier l’espace de nom des fonctions des scripts appelant.c sylvain@lhullier.$this->{COULEUR})". Voici come ment l’utiliser dans le script : print $v->toString(). Et l’affichage a lieu : (Vehicule:2.org Introduction a la programmation en Perl ` Cette fonction d´clar´e dans le fichier Vehicule.

ee nous pouvons ´crire dans le fichier script. pourquoi modifier un objet Net::FTP e alors qu’il fait tr`s bien son travail ? De toute fa¸on.-))) et il ne modifiera pas une instance d’une classe qu’il n’a pas ´crite. Faute de champs priv´s en Perl. Comment prot´ger les donn´es d’un objet ? allez-vous alors me demane e der. ee le fait qu’elle soit b´nie ne change rien au fait que je peux la d´r´f´rencer e eee et acc´der aux diverses valeurs qu’elle contient. Dans le script. mais c’est comme cela . } C’est-`-dire que je peux acc´der sans restriction a l’ensemble des champs a e ` de l’objet.8 Reparlons des champs Un champ est une donn´e propre a une instance de classe. Je peux aussi bien modifier e ces valeurs ou mˆme en ajouter ou en supprimer. Perl n’a rien pr´vu pour ca. Cette convention est aussi valable pour les m´thodes (une m´thode dont le e e nom commence par une underscore est une m´thode priv´e). En effet. il existe une convention qui dit que e les champs dont la clef commence par un underscore (soulign´ _) sont des e champs priv´s et les scripts qui utilisent les objets ainsi faits sont pri´s de e e respecter cette convention.Introduction a la programmation en Perl ` c sylvain@lhullier.pl : e foreach my $k (keys %$v) { print "$k : $v->{$k}\n". car il s’agit en effet d’une e table de hachage comme les autres. e ` ces champs sont stock´s comme clef/valeur dans la table de hachage qui e constitue l’objet (si on utilise une table de hachage comme objet. C’est le cas de beaucoup de modules CPAN. En Perl. ce qui est souvent le cas). Et bien. ils y sont accessibles. Ces champs ´tant de simple clef/valeur d’une table de hachage dont on e dispose d’une r´f´rence dans le script. En effet.org 14. Nos v´hicules comportent deux champs : NB_ROUES et e COULEUR. il a forc´ment acc`s au e c e e code source de cette classe et s’il veut la modifier. certaines choses ne sont e donc pas possibles. e e De fa¸on g´n´ral. il peut en faire une copie et la modifier ! 152 .. j’ai en main une r´f´rence vers une table de hachage . un programmeur Perl est quelqu’un de bonne ´ducation c e e e (sinon il programmerait en Java . Perl vous propose les principaux m´canismes pour faire de la programmation objet e tout en restant coh´rent avec le reste du langage.. Cela va sans doute faire hurler e ¸ les puristes de la programmation objet.

Un garage devra donc contenir une e liste de v´hicules. $class). Voyons ensuite le constructeur : sub new { my ($class. ici les m´thodes qui vont suivre e 1. Pas dramatique pour faire de e e l’objet. pour cela elle est initialis´e a e e ` la r´f´rence anonyme vers une liste vide. return $this. } Ce constructeur prendra en param`tre le nombre de places disponibles e du garage . use strict..pm contenant : e package Garage.. e Je d´cide qu’un garage aura une taille limite : il s’agira du nombre maxie mal de v´hicules qu’il pourra contenir. La m´thode ajoute se chargera ee e d’ajouter les v´hicules dans la limite du nombre de places : e sub ajoute { 153 . my $this = {}.c sylvain@lhullier. # . $this->{PLACES} = $places.org Introduction a la programmation en Perl ` La protection des donn´es est donc plus une n´cessit´ sociale (manque de e e e confiance en l’esp`ce humaine a laquelle les d´veloppeurs pr´tendent encore e ` e e faire partie :-))) qu’une n´cessit´ technique.9 Composition Prenons le temps de faire un petit exemple pratique pour illustrer le concept de composition. $this->{VEHICULE} = []. e Nous devons cr´er un fichier Garage. Le champ e VEHICULE comportera la liste des v´hicules . 14. bless($this. Par exemple un garage comporte des v´hicules. cette valeur est enregistr´e dans le champ PLACES. La composition est le fait qu’un objet est constitu´ e d’autres objets.$places) = @_.

Elle e e ee e compare la longueur de la liste des v´hicules au nombre total de places e (l’expression @{$this->{VEHICULE}} est la liste point´e par la r´f´rence e ee $this->{VEHICULE} . $g->ajoute( Vehicule->new( 4. ´ Ecrivons maintenant une m´thode d’affichage pour un tel objet : e sub toString { my ($this) = @_. "jaune" ) ) or die("ajoute: plus de place"). if( @{$this->{VEHICULE}} < $this->{PLACES} ) { push @{$this->{VEHICULE}}. $g->ajoute( $v ) or die("ajoute: plus de place"). "bleu" ). Voici comment l’utiliser dans le script : use Garage. sinon elle renvoie faux. } 154 . my $g = Garage->new(3). le v´hicule est ajout´ (fonction push) et ee e e elle renvoie vrai. my $s = "{Garage:$this->{PLACES}."}". $g->ajoute( Vehicule->new( 1.org Cette m´thode prend en param`tre une r´f´rence vers un v´hicule. } c sylvain@lhullier. S’il reste de la place. $vehicule.$vehicule) = @_. } return 0. elle vaut son nombre e e e d’´l´ments).Introduction a la programmation en Perl ` my ($this.= $v->toString(). return 1. ´valu´e en contexte num´rique. my $v = new Vehicule( 2.". foreach my $v ( @{$this->{VEHICULE}} ) { $s . } return $s. "vert" ) ) or die("ajoute: plus de place").

} Ce qui donne l’affichage suivant : {Garage:3. } Ce qui donne l’affichage suivant : {Garage:3.(Vehicule:4.jaune)} On pourrait ´crire cette m´thode diff´remment si on voulait s´parer e e e e chaque v´hicule par une virgule : e sub toString { my ($this) = @_.". $s .(Vehicule:2.(Vehicule:2.bleu). $s .= join( ’.(Vehicule:1. my $s = "{Garage:$this->{PLACES}. return $s. map( { $_->toString() } @{$this->{VEHICULE}} ) ).bleu).(Vehicule:4."\n".jaune)} Pour ajouter encore une difficult´. map( {$_->toString()} sort( {$a->{NB_ROUES} <=> $b->{NB_ROUES} } @{$this->{VEHICULE}} ) ) )."}"."}". Ce qui donne l’affichage suivant : {Garage:3.(Vehicule:1.= join( ’.vert)} Ces deux derniers exemples vous sont propos´s pour que vous vous tore turiez un peu les m´ninges .bleu)(Vehicule:4.c sylvain@lhullier.’.org Introduction a la programmation en Perl ` On appelle sur chaque objet Vehicule la m´thode toString de fa¸on a e c ` le faire apparaˆ dans la chaˆ que nous allons renvoyer. my $s = "{Garage:$this->{PLACES}.(Vehicule:2. return $s.jaune).vert)(Vehicule:1.-)) e 155 . je d´cide de trier les v´hicules par e e e nombre de roues croissant : sub toString { my ($this) = @_. Voici comment ıtre ıne appeler cette m´thode dans le script : e print $g->toString().’.".vert).

. qui est ape e e e e pel´e lors de la destruction d’une instance d’un objet.. ) { my $v3 = Vehicule->new(3. } Cette m´thode doit ˆtre d´finie dans le package de l’objet en question et e e e re¸oit en premier argument une r´f´rence vers l’objet qui va ˆtre d´truit. dont le nom est r´serv´. e e ee La ligne suivante. } La variable $v3 cesse d’exister a la fermeture de l’accolade du if.. . A print "($this->{NB_ROUES} $this->{COULEUR})\n".. par exemple. connexion e e e r´seau etc) qui ont ´t´ allou´es lors de la cr´ation de l’objet. Il s’agit de la m´thode e e DESTROY..Introduction a la programmation en Perl ` c sylvain@lhullier.. mais ce n’est pas e e e au programmeur de s’en occuper.. Il existe une m´thode tr`s sp´ciale. Cette m´thode sera appel´e (si elle existe dans la classe) par le gare e bage collector juste avant la lib´ration de la m´moire de l’objet.org 14. La mˆme chose a lieu dans le cas de la disparition d’une variable locale : e if( . e e sub DESTROY { my ($this) = @_.10 Destruction d’un objet Un objet est d´truit d`s qu’aucune r´f´rence ne pointe vers cet objet. print "` la casse Vehicule ! ". c ee e e Cette m´thode est tr`s utile pour lib´rer des ressources (fichier. e ee e e 156 . la m´moire sera donc automatiquement lib´r´e par le m´canisme e ee e du garbage collector. e e Cette lib´ration n’est peut-ˆtre pas faite en temps r´el..’jaune’). . Perl se rend compte que l’objet en question n’est plus accessible. L’objet ` qui a ´t´ cr´´ dans le bloc sera donc d´truit (sauf si on a fait en sorte qu’une e e ee e autre variable dont la visibilit´ d´passe ce bloc pointe aussi vers l’objet). ` A cet instant. lib`re la place m´moire occup´e par l’objet e e e Vehicule r´f´renc´ par $v2 : ee e $v2 = undef.

e D´finissons lui un constructeur : e sub new { my ($class. Ces objets ont en commun d’avoir un nombre de roues e et une couleur. my $this = $class->SUPER::new( 2. On signale le lien de filiation entre classes au moyen de la variable @ISA positionn´e a la valeur d’une liste contenant le nom de la classe m`re.$couleur. use strict. Ils ont des caract´ristiques suppl´mentaires qui leur sont e e propres . Imaginons qu’en plus de v´hicules. nous avons besoin de manipuler des e v´los et des voitures. Il h´rite e e e donc des champs et m´thodes de la classe Vehicule. Perl dispose e de tout ce qu’il faut pour le mettre en œuvre. un nombre de e si`ges. une seule est suffisante.. les v´los ont un nombre de vitesses et les voitures. e Voyons le cas de la classe Velo. ISA e ` e vient de l’anglais ”is a”. return bless($this.11 H´ritage e L’h´ritage est un des apports de la programmation objet..c sylvain@lhullier. our @ISA = qw(Vehicule). ici les m´thodes qui vont suivre e 1.$nbVitesses) = @_. les classes Velo e et Voiture ´tant des classes filles. $couleur ). Notez bien que je prends comme exemple e deux classes filles et qu’il n’est nullement n´cessaire d’avoir deux classes filles e pour mettre en œuvre l’h´ritage.pm qui e contient : package Velo. est un : on dit qu’un v´lo est un v´hicule. On dit alors que la classe Vehicule est la classe m`re .$class). # . } 157 .org Introduction a la programmation en Perl ` 14. e e c’est-`-dire qu’elles vont comporter tous les champs et les m´thodes de cette a e classe. $this->{NB_VITESSES} = $nbVitesses. Ces classes Velo et Voiture vont donc h´riter de la classe Vehicule. cr´ons pour cela un fichier Velo. use Vehicule.

$ici) = @_. Il ajoute un champ e NB_VITESSE et renvoie une r´f´rence b´nie en Velo. Il appelle le construce teur de la classe m`re (syntaxe $class->SUPER::new). e print "je p´dale avec $this->{NB_VITESSES} vitesses". $velo->pedale(’les bois’). je roule a 10. Les noms des champs devront ˆtre minutieusement choisis pour ne pas entrer en conflit e les uns avec les autres.18). $velo->roule(10). L’affie e e chage suivant est effectu´ : e Sur mon v´lo blanc je p´dale avec 18 vitesses dans les bois. e print " dans $ici. Nous laisserons le soin ` e a la classe Vehicule d’afficher le v´lo comme ´tant un v´hicule et nous ` e e e n’effectuerons dans la classe Velo que l’affichage de ce que nous avons ajout´ e a la classe m`re : ` e sub toString { my ($this) = @_. Le lecteur aura not´ que. ` Voyons a pr´sent comment afficher un tel objet. il n’y a pas moyen e e simple de faire de surcharge ou de masquage des champs. print "Sur mon v´lo $this->{COULEUR} ".Introduction a la programmation en Perl ` c sylvain@lhullier. comme les champs de la classe m`re et de la e e classe fille sont stock´s dans la mˆme table de hachage.org Ce constructeur prend donc deux param`tres. il faut le faire e e explicitement dans tous les cas. Un v´lo dispose de la m´thode roule car il est aussi un v´hicule. my $velo = Velo->new(’blanc’. 158 . } Utilisons maintenant tout cela dans notre script : use Velo.\n". Voyons a pr´sent comment ´crire une m´thode pour cet objet : ` e e e sub pedale { my ($this. e e Avec 2 roues. Notez bien qu’aucun ee e appel au constructeur de la classe m`re n’est fait par d´faut.

blanc)] Rien de plus simple ! Seule chose pas extrˆmement pratique. L’affichage suivant est effectu´ : e [Velo:18(Vehicule:2. La d´termination de la bonne m´thode a appeler est effectu´e dynae e ` e miquement par une recherche en profondeur dans l’arbre d’h´ritage. Nous pouvons maintenant l’appeler dans notre e script : print $velo->toString(). Je ne e m’´tendrai pas plus sur cette question de l’h´ritage multiple.= "]". e Pour faire de l’h´ritage multiple en Perl. e e 159 . $this->SUPER::DESTROY(). la m´thode DESTROY de la classe e e Vehicule ne sera pas appel´e.= $this->SUPER::toString(). elle peut donc contenir e e plusieurs noms de classe : package Voiture. $s . il faut alors l’appeler explicitement. } La syntaxe $this->SUPER::toString() correspond a l’appel de la m´thode ` e toString de la classe m`re. our @ISA = qw(Vehicule Danger Pollution). $s . Vous aurez e peut-ˆtre not´ que la variable @ISA est un tableau. rien de plus simple. "$this->{COULEUR})\n".c sylvain@lhullier. print "Bye bye Velo ! ". l’appel au destructeur s’arrˆte e e au premier destructeur rencontr´. Cela peut ˆtre gˆnant si des ressources impore e e tantes sont lib´r´es dans cette m´thode ."\n". print "($this->{NB_VITESSES} $this->{NB_ROUES} ".org Introduction a la programmation en Perl ` my $s = "[Velo:$this->{NB_VITESSES}". ee e Voici un exemple de m´thode DESTROY pour la classe Velo : e sub DESTROY { my ($this) = @_. Si dans notre exemple nous d´finissions e e une m´thode DESTROY pour la classe Velo. } La deuxi`me ligne de la m´thode fait un appel a la m´thode de la classe e e ` e m`re.

"Vehicule" ) ) { $r->roule( 40 ). if( isa( $r. } On teste ainsi si la variable $r est un objet de classe Vehicule. ` Souvenez-vous de l’op´rateur ref qui. e table de hachage etc). il renvoie la classe de l’objet : e` print ref($velo). appliqu´ a une r´f´rence.. L’affichage effectu´ est le suivant : e Velo Ouf. Par exemple. ` o ıtre si nous manipulons un tableau comportant des objets divers et vari´s et si e nous souhaitons y retrouver tous les objets de classe Vehicule pour appeler leur m´thode roule. il peut ˆtre utile de pouvoir tester l’appartenance de e e l’objet a une classe plutˆt que de connaˆ sa classe principale. print "Ouf. renvoie e e` ee le type de structure de donn´es vers laquelle elle pointe (scalaire. mais nous devons nous demander si l’objet est un objet de classe Vehicule (ce qui est vrai pour tout objet de classe Vehicule et ses sousclasses. La fonction isa du package UNIVERSAL va nous permettre de faire cela : use UNIVERSAL qw(isa).12 Classes d’un objet Dans cette partie nous allons voir comment connaˆ la classe d’un objet ıtre ainsi que tester l’appartenance a une classe pour un objet. 160 . Appliqu´ a un objet.org 14. } car les v´los ne seront pas s´lectionn´s. Sachant qu’un v´lo e est aussi un v´hicule. tout va bien ! Il s’agit donc de la classe ”principale” de l’objet. tableau. tout va bien !\n" if( ref($velo) eq "Velo" ). En fait la question que nous e e e devons ici nous poser n’est pas de savoir si la classe principale de l’objet est Vehicule.."\n". comme Velo et Voiture).Introduction a la programmation en Perl ` c sylvain@lhullier. nous ne pouvons pas ´crire e e if( ref($r) eq "Vehicule" ) { .

c sylvain@lhullier.org

Introduction a la programmation en Perl `

14.13

Champs et m´thodes statiques e

Un champ statique est un champ qui est commun a tous les objets d’une ` classe, c’est-`-dire qu’il n’est pas li´ a une instance particuli`re mais a une a e` e ` classe. C’est une sorte de variable globale (dont l’acc`s peut ´ventuellement e e ˆtre contrˆl´) qui est situ´e dans une classe. e oe e Pour faire cela en Perl, nous utiliserons des variables d´clar´es dans le e e package de la classe en question. package Vehicule; my $privateVar = 0; our $publicVar = "hello"; Avec le qualificateur my, nous d´clarons des variables priv´es (car visibles e e uniquement depuis l’int´rieur du package). Avec our, sont d´clar´es des e e e variables publiques (accessibles depuis n’importe quel package). Je rappelle que pour acc´der a la variable $publicVar du package e ` Vehicule, on doit ´crire $Vehicule::publicVar ; depuis les fonctions et e m´thodes de ce package, il est suffisant d’´crire $publicVar (sauf masquage e e par une variable locale). On pourrait par exemple compter le nombre de v´hicules cr´´s au moyen e ee d’une telle variable : package Vehicule; my $nbVehicules = 0; sub new { my ($class,$nbRoues,$couleur) = @_; my $this = {}; bless($this, $class); $this->{NB_ROUES} = $nbRoues; $this->{COULEUR} = $couleur; $nbVehicules++; # un v´hicule de plus e return $this; } ` A chaque appel au constructeur de cette classe, la variable $nbVehicules sera donc incr´ment´e. e e Maintenant, comment ´crire une m´thode statique ? Une m´thode stae e e tique (ou m´thode de classe) est une m´thode qui n’est pas appel´e sur une e e e instance de la classe (donc pas de variable $this) mais pour toute la classe. 161

Introduction a la programmation en Perl `

c sylvain@lhullier.org

Ce n’est ni plus ni moins qu’une brave fonction pr´sente dans le package. e Cette fonction pourra donc uniquement acc´der aux champs statiques de la e classe. Nous pourrions, par exemple, ´crire une m´thode statique qui renvoie le e e nombre de v´hicules cr´´s (variable $nbVehicules) : e ee sub getNbVehicules { my ($class) = @_; return $nbVehicules; } On notera que la m´thode prend en premier argument le nom de la classe. e Cela a pour cons´quence que l’appel a la m´thode ne se fait pas tout a fait e ` e ` comme pour une fonction d’un package (comme vu pour les modules), mais de la mani`re suivante : e print Vehicule->getNbVehicules()."\n"; Le nom de la classe est suivi d’une fl`che, du nom de la m´thode et des e e ´ventuels arguments entre parenth`ses. N’´crivez pas e e e Vehicule::getNbVehicules() car le nom de la classe n’est pas transmis et surtout car les m´canismes d’h´ritage ne sont pas mis en œuvre. S’il e e est possible d’´crire Velo->getNbVehicules(), il n’est pas permis d’´crire e e Velo::getNbVehicules(). Le lecteur notera que les constructeurs sont des m´thodes statiques. Ils e retournent des r´f´rences b´nies, mais n’ont rien de particulier par rapport ee e a d’autres m´thodes de classe. ` e Il est tout a fait possible d’appeler cette m´thode sur une instance de la ` e classe Vehicule print $v->getNbVehicules()."\n"; mais dans ce cas le premier argument re¸u n’est pas le nom de la classe c mais l’objet en question (c’est donc une m´thode d’instance et de classe ...). e Cela ne change rien pour notre m´thode getNbVehicules car elle n’utilise e pas son premier argument, mais le cas est gˆnant pour les constructeurs e qui ont a b´nir une r´f´rence. Pour cela, tout constructeur devrait commen` e ee cer par d´terminer s’il a en premier argument le nom de la classe ou une e r´f´rence. L’instruction qui suit place dans la variable $class la classe acee tuelle, que cette variable ait pour valeur initiale le nom de la classe ou une instance de la classe : 162

c sylvain@lhullier.org

Introduction a la programmation en Perl `

$class = ref($class) || $class; Il convient dor´navant d’´crire le constructeur ainsi : e e sub new { my ($class,$nbRoues,$couleur) = @_; $class = ref($class) || $class; my $this = {}; bless($this, $class); $this->{NB_ROUES} = $nbRoues; $this->{COULEUR} = $couleur; $nbVehicules++; # un v´hicule de plus e return $this; } Il est maintenant possible d’´crire la ligne suivante dans le script : e $v2 = $v->new( 1, "noir" ); Le constructeur est appel´ sur une instance de la classe plutˆt que sur la e o classe. On pourrait faire de mˆme pour toutes les m´thodes statiques (c’est e e mˆme plutˆt conseill´). e o e

14.14

Exemple complet

Voici le contenu exact des fichiers d’exemple bˆtis tout au long de cette a partie du document. Fichier Vehicule.pm : package Vehicule; use strict; my $nbVehicules = 0; sub new { my ($class,$nbRoues,$couleur) = @_; $class = ref($class) || $class; my $this = {}; bless($this, $class); $this->{NB_ROUES} = $nbRoues; 163

$nbVitesses) = @_. $class = ref($class) || $class. } sub DESTROY { my ($this) = @_.$vitesse) = @_. A Fichier Velo.Introduction a la programmation en Perl ` $this->{COULEUR} = $couleur. return "(Vehicule:$this->{NB_ROUES}.org } sub roule { my ($this. } sub getNbVehicules { my ($class) = @_.. $couleur ). $this->{NB_VITESSES} = $nbVitesses. return $nbVehicules. print "($this->{NB_ROUES} $this->{COULEUR})\n". sub new { my ($class. my $this = $class->SUPER::new( 2.\n". print "Avec $this->{NB_ROUES} roues.. 164 . je roule a $vitesse. use strict. $nbVehicules++. our @ISA = qw(Vehicule).pm : package Velo. print "Bye bye Vehicule ! ". # ` ne pas oublier. c sylvain@lhullier. # un v´hicule de plus e return $this. use Vehicule.$couleur. ` } sub toString { my ($this) = @_.$this->{COULEUR})". } 1. $class = ref($class) || $class.

} sub pedale { my ($this. print "($this->{NB_VITESSES} $this->{NB_ROUES} ". bless($this. $class).c sylvain@lhullier. $this->{VEHICULE} = []. e print " dans $ici. $this->{COULEUR})\n". print "Sur mon v´lo $this->{COULEUR} ".$places) = @_. my $s = "[Velo:$this->{NB_VITESSES}". } sub DESTROY { my ($this) = @_.$class). print "Bye bye Velo ! ". $class = ref($class) || $class. my $this = {}.$ici) = @_. $this->{PLACES} = $places. Fichier Garage.= "]". e print "je p´dale avec $this->{NB_VITESSES} vitesses".pm : package Garage. } sub toString { my ($this) = @_. $s . $s . use strict. } 1. sub new { my ($class. return $this.org Introduction a la programmation en Perl ` return bless($this.= $this->SUPER::toString(). $this->SUPER::DESTROY().\n". } 165 .

print Dumper($v).’jaune’). if( @{$this->{VEHICULE}} < $this->{PLACES} ) { push @{$this->{VEHICULE}}.Introduction a la programmation en Perl ` sub ajoute { my ($this."}". Fichier script.’."\n". } 166 c sylvain@lhullier. if( 1 ) { my $v3 = Vehicule->new(3. use Velo.= join( ’. my $v = Vehicule->new( 2. map( {$_->toString()} sort( {$a->{NB_ROUES} <=> $b->{NB_ROUES} } @{$this->{VEHICULE}} ) ) ). use Garage. $vehicule. } 1. $v2 = undef.".$vehicule) = @_. return 1. use Data::Dumper. my $s = "{Garage:$this->{PLACES}. } return 0. use UNIVERSAL qw(isa). "bleu" ). use Vehicule.pl : #!/usr/bin/perl -w use strict. $v->roule(30). "rouge" ). return $s. } sub toString { my ($this) = @_. my $v2 = Vehicule->new( 4.org . $s . print "$v\n".

print Vehicule->getNbVehicules().21). "jaune" ) ) place"). my $g = Garage->new(3). 167 place"). Vehicule->new(3. print "Ouf.’gris’). $velo->pedale(’les bois’). 4. print ref($velo)."\n".org Introduction a la programmation en Perl ` foreach my $k (keys %$v) { print "$k : $v->{$k}\n"."\n". } } my $velo = Velo->new(’blanc’. $g->ajoute( $v ) or die("ajoute: plus de $g->ajoute( Vehicule->new( or die("ajoute: plus de $g->ajoute( Vehicule->new( or die("ajoute: plus de print $g->toString(). $v2 = $v->new( 1. 1. . my @tab = ( Velo->new(’rose’. "hello". print Velo->getNbVehicules(). foreach my $r (@tab) { if( isa( $r.15). $velo->roule(10). print $v->getNbVehicules(). tout va bien !\n" if( ref($velo) eq "Velo" )."\n". } print $v->toString(). )."\n". Velo->new(’vert’. print $velo->toString()."\n".c sylvain@lhullier."\n"."\n". "Vehicule" ) ) { $r->roule( 40 ).18). "noir" ). "vert" ) ) place").

Introduction a la programmation en Perl ` c sylvain@lhullier.org 168 .

e N’oubliez pas que la documentation de Perl est tr`s bien faite et est dispoe nible sur votre ordinateur au moyen de la commande perldoc : perldoc perl vous donne acc`s a la liste des th`mes consultables avec perldoc.-) 169 . . Par e ` e exemple perldoc perldata vous explique les structures de donn´es en Perl. Vous avez maintenant en main la plupart des concepts et des notions pour ˆtre autonome en Perl. e vous trouverez vite votre mani`re de r´soudre un probl`me. Vous allez alors e e e commencer a faire connaissance avec Tim Towtdi (There is more than one ` way to do it). e Pour une fonction particuli`re. utilisez l’option -f : perldoc -f chomp Pour e un module particulier. Il n’est pas e forcement facile d’exprimer son besoin en termes directement exploitable dans un langage particulier. utilisez perldoc sans option : perldoc Data::Dumper Vous avez maintenant en main beaucoup de notions importantes de Perl. ` A vous de les mettre en œuvre pour vos propres probl`mes. mais en ayant un peu d’exp´rience de Perl.Conclusion Nous sommes ici au terme de ce cours introductif a la programmation en ` Perl.

org 170 .Introduction a la programmation en Perl ` c sylvain@lhullier.

leur soutien et les relectures effectu´es.linagora. Entre autres associations. e Il a d´velopp´ chez feue-Atrid des projets bˆtis en Perl (LogTrend. il est e e charg´ chaque ann´e d’un module complet d’enseignement en maˆ e e ıtrise informatique .fr/). CGI/Perl et consiste en dix semaines d’un cours en amphith´atre e et de trois travaux dirig´s. Apache. e Il a donn´ une conf´rence ”Perl : pour quoi faire ?” lors du salon Linuxe e Solutions de janvier 2004. Perl/Tk.com/) comme consule tant formateur et d´veloppeur . PHP.).net/). il est membre et administrateur de l’association ”Les Mongueurs de Perl” dont l’objet est de promouvoir le langage Perl en France par des r´unions.org/) chaque mois.mongueurs.org> http://sylvain.univ-mlv. ainsi qu’en un examen final et un projet. e 171 . Mioga) e e a et publi´s sous GPL. C++.L’auteur Sylvain Lhullier <sylvain@lhullier. Apache. e e Il y coordonne le groupe de travail ”Articles” dont le but est de publier un article dans la presse francophone technique.linuxmag-france. programmae tion syst`me. e Il a travaill´ pour Linagora (http://www. Java. ce module porte sur des sujets tels que Perl. Perl/DBI. MySQL. il intervenait principalement pour des projets e et prestations concernant le d´veloppement (Perl.org/ ` A l’Universit´ de Marne-la-Vall´e (http://www. L’auteur tient a remercier tr`s chaleuseusement les autres membres de l’as` e sociation pour leur aide. des conf´rences etc (http://www. notamment dans GNU/Linux & Hurd Magazine France (http://www. XML etc.lhullier.

You're Reading a Free Preview

Download
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->