.\" Automatically generated by Pod::Man 2.09 (Pod::Simple 3.04) .\" .\" Standard preamble: .\" ======================================================================== .de Sh \" Subsection heading .br .if t .Sp .ne 5 .PP \fB\\$1\fR .PP .. .de Sp \" Vertical space (when we can't use .PP) .if t .sp .5v .if n .sp .. .de Vb \" Begin verbatim text .ft CW .nf .ne \\$1 .. .de Ve \" End verbatim text .ft R .fi .. .\" Set up some character translations and predefined strings. \*(-- will .\" give an unbreakable dash, \*(PI will give pi, \*(L" will give a left .\" double quote, and \*(R" will give a right double quote. | will give a .\" real vertical bar. \*(C+ will give a nicer C++. Capital omega is used to .\" do unbreakable dashes and therefore won't be available. \*(C` and \*(C' .\" expand to `' in nroff, nothing in troff, for use with C<>. .tr \(*W-|\(bv\*(Tr .ds C+ C\v'-.1v'\h'-1p'\s-2+\h'-1p'+\s0\v'.1v'\h'-1p' .ie n \{\ . ds -- \(*W- . ds PI pi . if (\n(.H=4u)&(1m=24u) .ds -- \(*W\h'-12u'\(*W\h'-12u'-\" diablo 10 pitch . if (\n(.H=4u)&(1m=20u) .ds -- \(*W\h'-12u'\(*W\h'-8u'-\" diablo 12 pitch . ds L" "" . ds R" "" . ds C` "" . ds C' "" 'br\} .el\{\ . ds -- \|\(em\| . ds PI \(*p . ds L" `` . ds R" '' 'br\} .\" .\" If the F register is turned on, we'll generate index entries on stderr for .\" titles (.TH), headers (.SH), subsections (.Sh), items (.Ip), and index .\" entries marked with X<> in POD. Of course, you'll have to process the .\" output yourself in some meaningful fashion. .if \nF \{\ . de IX . tm Index:\\$1\t\\n%\t"\\$2" .. . nr % 0 . rr F .\} .\" .\" For nroff, turn off justification. Always turn off hyphenation; it makes .\" way too many mistakes in technical documents. .hy 0 .if n .na .\" .\" Accent mark definitions (@(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2). .\" Fear. Run. Save yourself. No user-serviceable parts. . \" fudge factors for nroff and troff .if n \{\ . ds #H 0 . ds #V .8m . ds #F .3m . ds #[ \f1 . ds #] \fP .\} .if t \{\ . ds #H ((1u-(\\\\n(.fu%2u))*.13m) . ds #V .6m . ds #F 0 . ds #[ \& . ds #] \& .\} . \" simple accents for nroff and troff .if n \{\ . ds ' \& . ds ` \& . ds ^ \& . ds , \& . ds ~ ~ . ds / .\} .if t \{\ . ds ' \\k:\h'-(\\n(.wu*8/10-\*(#H)'\'\h"|\\n:u" . ds ` \\k:\h'-(\\n(.wu*8/10-\*(#H)'\`\h'|\\n:u' . ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'^\h'|\\n:u' . ds , \\k:\h'-(\\n(.wu*8/10)',\h'|\\n:u' . ds ~ \\k:\h'-(\\n(.wu-\*(#H-.1m)'~\h'|\\n:u' . ds / \\k:\h'-(\\n(.wu*8/10-\*(#H)'\z\(sl\h'|\\n:u' .\} . \" troff and (daisy-wheel) nroff accents .ds : \\k:\h'-(\\n(.wu*8/10-\*(#H+.1m+\*(#F)'\v'-\*(#V'\z.\h'.2m+\*(#F'.\h'|\\n:u'\v'\*(#V' .ds 8 \h'\*(#H'\(*b\h'-\*(#H' .ds o \\k:\h'-(\\n(.wu+\w'\(de'u-\*(#H)/2u'\v'-.3n'\*(#[\z\(de\v'.3n'\h'|\\n:u'\*(#] .ds d- \h'\*(#H'\(pd\h'-\w'~'u'\v'-.25m'\f2\(hy\fP\v'.25m'\h'-\*(#H' .ds D- D\\k:\h'-\w'D'u'\v'-.11m'\z\(hy\v'.11m'\h'|\\n:u' .ds th \*(#[\v'.3m'\s+1I\s-1\v'-.3m'\h'-(\w'I'u*2/3)'\s-1o\s+1\*(#] .ds Th \*(#[\s+2I\s-2\h'-\w'I'u*3/5'\v'-.3m'o\v'.3m'\*(#] .ds ae a\h'-(\w'a'u*4/10)'e .ds Ae A\h'-(\w'A'u*4/10)'E . \" corrections for vroff .if v .ds ~ \\k:\h'-(\\n(.wu*9/10-\*(#H)'\s-2\u~\d\s+2\h'|\\n:u' .if v .ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'\v'-.4m'^\v'.4m'\h'|\\n:u' . \" for low resolution devices (crt and lpr) .if \n(.H>23 .if \n(.V>19 \ \{\ . ds : e . ds 8 ss . ds o a . ds d- d\h'-1'\(ga . ds D- D\h'-1'\(hy . ds th \o'bp' . ds Th \o'LP' . ds ae ae . ds Ae AE .\} .rm #[ #] #H #V #F C .\" ======================================================================== .\" .IX Title "PERLINTRO 1" .TH PERLINTRO 1 "2006-03-07" "DocFr" "User Contributed Perl Documentation" .SH "NAME/NOM" .IX Header "NAME/NOM" perlintro \- Bre\*`ve introduction et vue d'ensemble de Perl .SH "DESCRIPTION" .IX Header "DESCRIPTION" Ce document a\*` pour but de donner une vue d'ensemble du langage de programmation Perl tout en fournissant quelques pointeurs vers de la documentation comple\*'mentaire. Il est conc\*,u comme un guide de de\*'marrage destine\*' a\*` un public de novices. Il apporte juste assez d'informations pour permettre de lire des programmes Perl e\*'crits par d'autres et de comprendre approximativement ce qu'ils font, ou d'e\*'crire des scripts simples. .PP Ce document ne cherche pas a\*` e\*^tre complet. Il ne tente me\*^me pas d'e\*^tre parfaitement exact. Dans certains exemples la perfection a e\*'te\*' sacrifie\*'e dans le seul but de faire passer l'ide\*'e ge\*'ne\*'rale. Il vous est \fIfortement\fR recommande\*' de comple\*'ter cette introduction par la lecture du manuel de Perl, dont la table des matie\*`re peut e\*^tre trouve\*'e dans perltoc. .PP Tout au long de ce document vous de\*'couvrirez des re\*'fe\*'rences a\*` diffe\*'rentes parties de la documentation Perl. Vous pouvez lire cette documentation avec la commande \f(CW\*(C`perldoc\*(C'\fR ou toute autre me\*'thode, par exemple celle que vous utilisez pour lire le pre\*'sent document. .Sh "Qu'est\-ce que Perl\ ?" .IX Subsection "Qu'est-ce que Perl?" Perl est un langage de programmation ge\*'ne\*'raliste cre\*'e\*' a\*` l'origine pour la manipulation automatique de textes et de\*'sormais utilise\*' dans une large gamme de ta\*^ches, dont l'administration syste\*`me, le de\*'veloppement web, la programmation re\*'seau, la cre\*'ation d'interfaces graphiques et bien plus encore. .PP Le langage a pour but premier d'e\*^tre pratique (facile a\*` utiliser, efficace, complet) pluto\*^t que beau (compact, e\*'le\*'gant, minimaliste). Ses caracte\*'ristiques principales sont sa facilite\*' d'utilisation, le support du style de programmation impe\*'ratif (a\*` base de proce\*'dures) et du style oriente\*' objet (\s-1OO\s0), l'inte\*'gration de puissantes capacite\*'s de manipulation de textes, et enfin l'une des plus impressionnantes collections au monde de modules comple\*'mentaires. .PP Diverses de\*'finitions de Perl peuvent e\*^tre trouve\*'es dans perl, perlfaq1 et sans doute a\*` bien d'autres endroits. Nous pouvons en de\*'duire que diffe\*'rents groupes d'utilisateurs voient en Perl bien des choses diffe\*'rentes, mais surtout que pas mal de monde conside\*`re le sujet comme suffisamment inte\*'ressant pour en parler. .Sh "Exe\*'cuter des programmes Perl" .IX Subsection "Exe'cuter des programmes Perl" Pour exe\*'cuter un programme Perl depuis la ligne de commande Unix\ : .PP .Vb 1 \& perl progname.pl .Ve .PP Ou bien, placez la ligne suivante comme premie\*`re ligne de votre script\ : .PP .Vb 1 \& #!/usr/bin/env perl .Ve .PP \&...et exe\*'cutez le script en tapant \f(CW\*(C`/dossier/contenant/le/script.pl\*(C'\fR. Bien sur, il faut d'abord que vous l'ayez rendu exe\*'cutable, en tapant \f(CW\*(C`chmod 755 script.pl\*(C'\fR (sous Unix). .PP Pour plus d'informations, en particulier les instructions pour d'autres plates-formes comme Windows et Mac \s-1OS\s0, re\*'fe\*'rez vous a\*` perlrun. .Sh "Les bases de la syntaxe" .IX Subsection "Les bases de la syntaxe" Un programme ou un script Perl est constitue\*' d'une suite de \*(L"phrases\*(R". Ces phrases sont simplement saisies dans le script les unes a\*` la suite des autres dans l'ordre de\*'sire\*' de leur exe\*'cution, de la manie\*`re la plus directe possible. Inutile de cre\*'er une fonction \f(CW\*(C`main()\*(C'\fR ou quoi que ce soit de la sorte. .PP Principale diffe\*'rence avec les phrases franc\*,aises, une phrase Perl se termine par un point-virgule\ : .PP .Vb 1 \& print "Salut, la terre"; .Ve .PP Les commentaires de\*'butent par un symbole die\*`se et vont jusqu'a\*` la fin de la ligne. .PP .Vb 1 \& # Ceci est un commentaire .Ve .PP Les espaces ou passages a\*` la ligne sont ignore\*'s\ : .PP .Vb 3 \& print \& "Salut, la terre" \& ; .Ve .PP \&...sauf a\*` l'inte\*'rieur des chai\*^nes de caracte\*`res entre guillemets\ : .PP .Vb 3 \& # La phrase suivante passe a\*` la ligne en plein milieu du texte \& print "Salut \& la terre"; .Ve .PP Les chai\*^nes de caracte\*`res litte\*'rales peuvent e\*^tre de\*'limite\*'es par des guillemets doubles ou simples (apostrophes)\ : .PP .Vb 2 \& print "Salut, la terre"; \& print 'Salut, la terre'; .Ve .PP Il y a cependant une diffe\*'rence importante entre guillemets simple et doubles. Une chai\*^ne de caracte\*`re encadre\*'e par des apostrophes s'affiche telle qu'elle a e\*'te\*' saisie, tandis que dans les chai\*^nes entre guillemets doubles Perl remplace les variables et les caracte\*`res spe\*'ciaux (par exemple les fins de lignes \f(CW\*(C`\en\*(C'\fR) par leur valeur. On parle \*(L"d'interpolation\*(R" des variables. .PP .Vb 3 \& $nom = "toto"; \& print "Bonjour, $nom\en"; # Affiche : Bonjour, toto \& print 'Bonjour, $nom\en'; # Affiche litte\*'ralement : Bonjour, $name\en .Ve .PP Les nombres n'ont pas besoin d'e\*^tre encadre\*'s par des guillemets\ : .PP .Vb 1 \& print 42; .Ve .PP Vous pouvez utiliser ou non des parenthe\*`ses pour les arguments des fonctions selon vos gou\*^ts personnels. Elles ne sont ne\*'cessaires que de manie\*`re occasionnelle pour clarifier des proble\*`mes de priorite\*' d'ope\*'rateur. .PP .Vb 2 \& print("Salut, la terre\en"); \& print "Salut, la terre\en"; .Ve .PP Vous trouverez des informations plus de\*'taille\*'es sur la syntaxe de Perl dans perlsyn. .Sh "Types de variables Perl" .IX Subsection "Types de variables Perl" Perl propose trois types de variables\ : les scalaires, les tableaux et les tables de hachage. .IP "Scalaires" 4 .IX Item "Scalaires" Un scalaire repre\*'sente une valeur unique\ : .Sp .Vb 2 \& my $animal = "chameau"; \& my $reponse = 42; .Ve .Sp Les scalaires peuvent e\*^tre indiffe\*'remment des chai\*^nes de caracte\*`res, des entiers, des nombres en virgules flottante, des re\*'fe\*'rences (voir plus loin), plus quelques valeurs spe\*'ciales. Perl proce\*'dera automatiquement aux conversions ne\*'cessaires lorsque c'est cohe\*'rent (par exemple pour transformer en nombre une chai\*^ne de caracte\*`re repre\*'sentant un nombre). Il est inutile de de\*'clarer au pre\*'alable le type des variables. .Sp Les valeurs scalaires peuvent e\*^tre utilise\*'es de diffe\*'rentes manie\*`res\ : .Sp .Vb 5 \& my $animal = "chameau"; \& print $animal; \& print "L'animal est un $animal\en"; \& my $nombre = 42; \& print "Le carre\*' de $nombre est " . $nombre*$nombre . "\en"; .Ve .Sp Perl de\*'finit e\*'galement la valeur scalaire \f(CW\*(C`undef\*(C'\fR (valeur d'une variable dans laquelle on n'a encore rien range\*'), qu'on peut ge\*'ne\*'ralement conside\*'rer comme e\*'quivalente a\*` une chai\*^ne vide. .Sp En Perl, en plus des variables de\*'finies dans le programme il existe un certain nombre de scalaires \*(L"magiques\*(R" qui ressemblent a\*` des erreurs de ponctuation. Ces variables spe\*'ciales sont utilise\*'es pour toutes sortes de choses. Elles sont documente\*'es dans perlvar. Pour l'instant la seule dont vous devez vous pre\*'occuper est la variable \f(CW$_\fR. On l'appelle la variable \&\*(L"par de\*'faut\*(R". Elle est utilise\*'e comme argument par de\*'faut par quantite\*' de fonctions Perl et modifie\*'e implicitement par certaines structures de boucle. .Sp .Vb 1 \& print; # Affiche, par de\*'faut, le contenu de $_ .Ve .IP "Les tableaux" 4 .IX Item "Les tableaux" Un tableau (ou liste, il y a une diffe\*'rence mais dans la suite nous emploierons indiffe\*'remment les deux) repre\*'sente une liste de valeurs\ : .Sp .Vb 3 \& my @animaux = ("chameau", "lama", "hibou"); \& my @nombres = (23, 42, 69); \& my @melange = ("chameau", 42, 1.23); .Ve .Sp Le premier e\*'le\*'ment d'un tableau se trouve a\*` la position 0. Voici comment faire pour acce\*'der aux e\*'le\*'ments d'un tableau\ : .Sp .Vb 2 \& print $animaux[0]; # Affiche "chameau" \& print $animaux[1]; # Affiche "lama" .Ve .Sp La variable spe\*'ciale \f(CW$#tableau\fR donne l'index du dernier e\*'le\*'ment d'un tableau (c'est a\*` dire 1 de moins que le nombre d'e\*'le\*'ments puisque le tableau commence a\*` ze\*'ro)\ : .Sp .Vb 1 \& print $melange[$#melange]; # dernier e\*'le\*'ment, affiche 1.23 .Ve .Sp Vous pourriez e\*^tre tente\*' d'utiliser \f(CW\*(C`$#array + 1\*(C'\fR pour connai\*^tre le nombre d'e\*'le\*'ments contenus dans un tableau... mais il y a plus simple. Il suffit en fait d'utiliser \f(CW@array\fR a\*` un emplacement ou Perl attend une valeur scalaire (\*(L"dans un contexte scalaire\*(R") et vous obtenez directement le nombre d'e\*'le\*'ments du tableau. .Sp .Vb 1 \& if (@animaux < 5) { ... } .Ve .Sp Les lecteurs attentifs auront sans doute remarque\*'s que les e\*'le\*'ments du tableau auxquels nous acce\*'dons commencent par \f(CW\*(C`$\*(C'\fR. L'ide\*'e est qu'en acce\*'dant a\*` un e\*'le\*'ment nous demandons de retirer une seule valeur du tableau, on demande un scalaire, on obtient donc un scalaire. .Sp Extraire simultane\*'ment plusieurs valeurs d'un tableau\ : .Sp .Vb 3 \& @animaux[0,1]; # donne ("chameau", "lama"); \& @animaux[0..2]; # donne ("chameau", "lama", "Hibou"); \& @animaux[1..$#animaux]; # donne tous les e\*'le\*'ments sauf le premier .Ve .Sp C'est ce qu'on appelle une tranche de tableau. .Sp Vous pouvez re\*'aliser quantite\*' de choses utiles en manipulant des listes\ : .Sp .Vb 2 \& my @tri = sort @animaux; # tri \& my @sansdessusdessous = reverse @nombres; # inversion .Ve .Sp Comme pour les scalaire il existe quelques \*(L"tableaux magiques\*(R". Par exemple \&\f(CW@ARGV\fR (les arguments d'appel de votre script en ligne de commande) et \f(CW@_\fR (les arguments transmis a\*` un sous programme). Les tableaux spe\*'ciaux sont documente\*'s dans perlvar. .IP "Les tables de hachage" 4 .IX Item "Les tables de hachage" Une table de hachage (ou plus brie\*`vement \*(L"un hash\*(R") repre\*'sente un ensemble de paires cle\*'/valeur\ : .Sp .Vb 1 \& my %fruit_couleur = ("pomme", "rouge", "banane", "jaune"); .Ve .Sp Vous pouvez utiliser des espaces et l'ope\*'rateur \f(CW\*(C`=>\*(C'\fR pour pre\*'senter plus joliment le code pre\*'ce\*'dent. \f(CW\*(C`=>\*(C'\fR est un synonyme de la virgule posse\*'dant quelques proprie\*'te\*'s particulie\*`re, par exemple se passer des guillemets pour encadrer le mot qui le pre\*'ce\*`de. Cela donne\ : .Sp .Vb 4 \& my %fruit_couleur = ( \& pomme => "rouge", \& banane => "jaune", \& ); .Ve .Sp Pour acce\*'der aux e\*'le\*'ments d'un hash\ : .Sp .Vb 1 \& $fruit_couleur{"pomme"}; # donne "rouge" .Ve .Sp Vous avez aussi la possibilite\*' d'obtenir la liste de toutes les cle\*'s ou de toutes les valeurs du hash gra\*^ce aux fonctions \f(CW\*(C`keys()\*(C'\fR et \f(CW\*(C`values()\*(C'\fR. .Sp .Vb 2 \& my @fruits = keys %fruit_couleur; \& my @couleurs = values %fruit_couleur; .Ve .Sp Les tables de hachage n'ont pas d'ordre interne spe\*'cifique. Vous ne pouvez donc pas pre\*'voir dans quel ordre les listes \f(CW\*(C`keys()\*(C'\fR et \f(CW\*(C`values()\*(C'\fR renverront leurs e\*'le\*'ments (par contre vous pouvez e\*^tre sur qu'il s'agit du me\*^me ordre pour les deux). Si vous de\*'sirez acce\*'der aux e\*'le\*'ments d'un hash de manie\*`re trie\*'e, vous avez toujours la possibilite\*' de trier la liste \f(CW\*(C`keys\*(C'\fR et d'utiliser une boucle pour parcourir les e\*'le\*'ments. .Sp Vous l'aviez devine\*'\ : comme pour les scalaires et les tableaux, il existe e\*'galement quelques \*(L"hashs\*(R" spe\*'ciaux. Le plus connu est \f(CW%ENV\fR qui contient les variables d'environnement du syste\*`me. Pour tout savoir a\*` son sujet (et sur les autres variables spe\*'ciales), regardez perlvar. .PP Les scalaires, les tableaux et les hashs sont documente\*'s de manie\*`re plus comple\*`te dans perldata. .PP Il est possible de construire des types de donne\*'es plus complexes en utilisant les re\*'fe\*'rences qui permettent, par exemple, de construire des listes et des hashs a\*` l'inte\*'rieur de listes et de hashs. .PP Une re\*'fe\*'rence est une valeur scalaire qui (comme son nom l'indique) se re\*'fe\*`re a\*` n'importe quel autre type de donne\*'es Perl. Donc en conservant des re\*'fe\*'rences en tant qu'e\*'le\*'ment d'un tableau ou d'un hash, on peut facilement cre\*'er des listes et des hash a\*` l'inte\*'rieur de listes et de hashs. Pas de panique, c'est plus complique\*' a\*` de\*'crire qu'a\*` cre\*'er. L'exemple suivant montre comment construire un hash a\*` deux niveaux a\*` l'aide de re\*'fe\*'rences anonymes vers des hash. .PP .Vb 10 \& my $variables = { \& scalaire => { \& description => "e\*'le\*'ment isole\*'", \& prefix => '$', \& }, \& tableau => { \& description => "liste ordonne\*'e d'e\*'le\*'ments", \& prefix => '@', \& }, \& hash => { \& description => "paire cle\*'/valeur", \& prefix => '%', \& }, \& }; \& \& print "Les scalaires commencent par $variables\->{'scalaire'}\->{'prefix'}\en"; .Ve .PP Des informations exhaustives sur les re\*'fe\*'rences peuvent e\*^tre trouve\*'es dans perlreftut, perllol, perlref et perldsc. .Sh "Porte\*'e des variables" .IX Subsection "Porte'e des variables" Dans tout ce qui pre\*'ce\*`de, pour de\*'finir des variables nous avons utilise\*' sans l'expliquer la syntaxe\ : .PP .Vb 1 \& my $var = "valeur"; .Ve .PP Le mot cle\*' \f(CW\*(C`my\*(C'\fR est en re\*'alite\*' optionnel. Vous pourriez vous contenter d'e\*'crire\ : .PP .Vb 1 \& $var = "valeur"; .Ve .PP Toutefois, la seconde version va cre\*'er des variables globales connues dans tout le programme, ce qui est une mauvaise pratique de programmation. Le mot cle\*' \f(CW\*(C`my\*(C'\fR cre\*'e des variables a\*` porte\*'es lexicales, c'est\-a\*`\-dire qui ne sont connues qu'au sein du bloc (c.\-a\*`\-d. un paquet de phrases entoure\*' par des accolades) dans lequel elles sont de\*'finies. .PP .Vb 8 \& my $a = "foo"; \& if ($une_condition) { \& my $b = "bar"; \& print $a; # Affiche "foo" \& print $b; # Affiche "bar" \& } \& print $a; # Affiche "foo" \& print $b; # N'affiche rien; $b est hors de porte\*'e .Ve .PP De plus, en utilisant \f(CW\*(C`my\*(C'\fR en combinaison avec la phrase \f(CW\*(C`use strict;\*(C'\fR au de\*'but de vos scripts Perl, l'interpre\*'teur de\*'tectera un certain nombre d'erreurs de programmation communes. Dans l'exemple pre\*'ce\*'dant, la phrase finale \f(CW\*(C`print $b;\*(C'\fR provoquerait une erreur de compilation et vous interdirait d'exe\*'cuter le programme (ce qui est souhaitable car quand il y a une erreur il vaut mieux la de\*'tecter le plus to\*^t possible). Utiliser \f(CW\*(C`strict\*(C'\fR est tre\*`s fortement recommande\*'. .Sh "Structures conditionnelles et boucles" .IX Subsection "Structures conditionnelles et boucles" Perl dispose des structures d'exe\*'cution conditionnelles et des boucles usuelles des autres langages de programmation, a\*` l'exception de case/switch (mais si vous y tenez vraiment il existe un module Switch inte\*'gre\*' a\*` partir de Perl 5.8 et disponible sur \s-1CPAN\s0. Lisez ci-dessous la section consacre\*'e aux modules pour plus d'informations sur les modules et \s-1CPAN\s0). .PP Une condition peut e\*^tre n'importe quelle expression Perl. Elle est conside\*'re\*'e comme vraie ou fausse suivant sa valeur, 0 ou chai\*^ne vide signifiant \s-1FAUX\s0 et toute autre valeur signifiant \s-1VRAIE\s0. Voyez la liste des ope\*'rateurs dans la prochaine section pour savoir quels ope\*'rateurs logiques et boole\*'ens sont habituellement utilise\*'s dans les expressions conditionnelles. .IP "if" 4 .IX Item "if" .Vb 7 \& if ( condition ) { \& ... \& } elsif ( autre condition ) { \& ... \& } else { \& ... \& } .Ve .Sp Il existe e\*'galement une version ne\*'gative du if\ : .Sp .Vb 3 \& unless ( condition ) { \& ... \& } .Ve .Sp \&\f(CW\*(C`unless\*(C'\fR permet ainsi de disposer d'une version plus lisible de \f(CW\*(C`if (!\f(CIcondition\f(CW)\*(C'\fR. .Sp Notez que, contrairement aux pratiques d'autres langages, les accolades sont obligatoires en Perl me\*^me si le bloc conditionnel est re\*'duit a\*` une ligne. Il existe cependant un truc permettant de donner aux expressions conditionnelles d'une ligne un aspect plus proche de l'anglais courant\ : .Sp .Vb 7 \& # comme d'habitude \& if ($zippy) { \& print "Yahou!"; \& } \& unless ($bananes) { \& print "Y'a plus de bananes"; \& } \& \& # la post\-condition Perlienne \& print "Yahou!" if $zippy; \& print "Y'a plus de bananes" unless $bananes; .Ve .IP "while" 4 .IX Item "while" .Vb 3 \& while ( condition ) { \& ... \& } .Ve .Sp Il existe e\*'galement une version ne\*'gative de \f(CW\*(C`while\*(C'\fR\ : .Sp .Vb 3 \& until ( condition ) { \& ... \& } .Ve .Sp Vous pouvez aussi utiliser \f(CW\*(C`while\*(C'\fR dans une post-condition\ : .Sp .Vb 1 \& print "LA LA LA\en" while 1; # boucle infinie .Ve .IP "for" 4 .IX Item "for" La construction \f(CW\*(C`for\*(C'\fR fonctionne exactement comme en C\ : .Sp .Vb 3 \& for ($i=0; $i <= $max; $i++) { \& ... \& } .Ve .Sp La boucle \f(CW\*(C`for\*(C'\fR a\*` la mode C est toutefois rarement ne\*'cessaire en Perl dans la mesure ou\*` Perl fournit une alternative plus intuitive\ : la boucle de parcours de liste \f(CW\*(C`foreach\*(C'\fR. .IP "foreach" 4 .IX Item "foreach" .Vb 3 \& foreach (@array) { \& print "L'e\*'le\*'ment courant est $_\en"; \& } \& \& # Vous n'e\*^tes pas non plus oblige\*' d'utiliser $_ ... \& foreach my $cle (keys %hash) { \& print "La valeur de $cle est $hash{$cle}\en"; \& } .Ve .PP En pratique on peut substituer librement \f(CW\*(C`for\*(C'\fR a\*` \f(CW\*(C`foreach\*(C'\fR et inversement. Perl se charge de de\*'tecter la variante utilise\*'e. .PP Pour plus de de\*'tails sur les boucles (ainsi qu'un certain nombre de choses que nous n'avons pas mentionne\*'es ici) consultez perlsyn. .Sh "Ope\*'rateurs et fonctions internes" .IX Subsection "Ope'rateurs et fonctions internes" Perl dispose d'une large gamme de fonctions internes. Nous avons de\*'ja\*` vu quelques unes d'entre elles dans les exemples pre\*'ce\*'dents\ : \f(CW\*(C`print\*(C'\fR, \&\f(CW\*(C`sort\*(C'\fR et \f(CW\*(C`reverse\*(C'\fR. Pour avoir une liste des fonctions disponibles consultez perlfunc. Vous pouvez facilement acce\*'der a\*` la documentation de n'importe quelle fonction en utilisant \f(CW\*(C`perldoc \-f \f(CIfunctionname\f(CW\*(C'\fR. .PP Les ope\*'rateurs Perl sont entie\*`rement documente\*'s dans perlop. Voici de\*'ja\*` quelques-uns parmi les plus utilise\*'s\ : .IP "Arithme\*'tique" 4 .IX Item "Arithme'tique" .Vb 4 \& + addition \& \- soustraction \& * multiplication \& / division .Ve .IP "Comparaison nume\*'rique" 4 .IX Item "Comparaison nume'rique" .Vb 6 \& == e\*'galite\*' \& != ine\*'galite\*' \& < infe\*'rieur \& > supe\*'rieur \& <= infe\*'rieur ou e\*'gal \& >= supe\*'rieur ou e\*'gal .Ve .IP "Comparaison de chai\*^nes" 4 .IX Item "Comparaison de chai^nes" .Vb 6 \& eq e\*'galite\*' \& ne ine\*'galite\*' \& lt infe\*'rieur \& gt supe\*'rieur \& le infe\*'rieur ou e\*'gal \& ge supe\*'rieur ou e\*'gal .Ve .Sp Pourquoi Perl propose-t-il des ope\*'rateurs diffe\*'rents pour les comparaisons nume\*'riques et les comparaisons de chai\*^nes\ ? Parce qu'en Perl il n'existe pas de diffe\*'rence de type entre variables nume\*'riques ou chai\*^nes de caracte\*`res. Perl a donc besoin de savoir s'il faut comparer les e\*'le\*'ments suivants dans l'ordre nume\*'rique (ou 99 est infe\*'rieur a\*` 100) ou dans l'ordre alphabe\*'tique (ou\*` 100 vient avant 99). .IP "Logique boole\*'enne" 4 .IX Item "Logique boole'enne" .Vb 3 \& && and et \& || or ou \& ! not ne\*'gation .Ve .Sp \&\f(CW\*(C`and\*(C'\fR, \f(CW\*(C`or\*(C'\fR et \f(CW\*(C`not\*(C'\fR ne sont pas mentionne\*'s dans la table uniquement en tant que description des ope\*'rateurs symboliques correspondants \*(-- ils existent comme ope\*'rateurs en tant que tels. Leur raison d'e\*^tre n'est pas uniquement d'offrir une meilleure lisibilite\*' que leurs e\*'quivalent C. Ils ont surtout une priorite\*' diffe\*'rente de \f(CW\*(C`&&\*(C'\fR et consorts. Lisez perlop pour de plus amples de\*'tails. .IP "Divers" 4 .IX Item "Divers" .Vb 4 \& = affectation \& . concate\*'nation de chai\*^nes \& x multiplication de chai\*^nes \& .. ope\*'rateur d'intervalle (cre\*'e une liste de nombres) .Ve .PP De nombreux ope\*'rateurs peuvent e\*^tre combine\*'s avec un \f(CW\*(C`=\*(C'\fR .PP .Vb 3 \& $a += 1; # comme $a = $a + 1 \& $a \-= 1; # comme $a = $a \- 1 \& $a .= "\en"; # comme $a = $a . "\en"; .Ve .Sh "Fichiers et E/S (entre\*'es/sorties)" .IX Subsection "Fichiers et E/S (entre'es/sorties)" Vous pouvez ouvrir un fichier en entre\*'e ou en sortie gra\*^ce a\*` la fonction \&\f(CW\*(C`open()\*(C'\fR. Celle-ci est documente\*'e avec un luxe extravagant de de\*'tails dans perlfunc et perlopentut. Plus brie\*`vement\ : .PP .Vb 3 \& open(INFILE, "input.txt") or die "Impossible d'ouvrir input.txt en lecture : $!"; \& open(OUTFILE, ">output.txt") or die "Impossible d'ouvrir output.txt en e\*'criture : $!"; \& open(LOGFILE, ">>my.log") or die "Impossible d'ouvrir logfile en ajout : $!"; .Ve .PP Pour lire depuis un descripteur de fichier ouvert on utilise l'ope\*'rateur \f(CW\*(C`<>\*(C'\fR. Dans un contexte scalaire, cet ope\*'rateur lit une ligne du fichier associe\*'. Dans un contexte de liste, il lit l'inte\*'gralite\*' du fichier en rangeant chaque ligne dans un e\*'le\*'ment de la liste. .PP .Vb 2 \& my $ligne = ; \& my @lignes = ; .Ve .PP Lire un fichier entier en une seule fois se dit \*(L"slurper\*(R". Me\*^me si cela peut parfois s'ave\*'rer utile, c'est ge\*'ne\*'ralement un ga\*^chis de me\*'moire. La majorite\*' des traitements de ne\*'cessite pas de lire plus d'une ligne a\*` la fois en utilisant les structures de boucles de Perl. .PP L'ope\*'rateur \f(CW\*(C`<>\*(C'\fR apparai\*^t en ge\*'ne\*'ral dans une boucle \f(CW\*(C`while\*(C'\fR\ : .PP .Vb 3 \& while () { # chaque ligne est successivement affecte\*'e a\*` $_ \& print "Je viens de lire la ligne : $_"; \& } .Ve .PP Nous avons de\*'ja\*` vu comment e\*'crire sur la sortie standard en utilisant la fonction \f(CW\*(C`print()\*(C'\fR. Celle-ci peut e\*'galement prendre comme premier argument optionnel un descripteur de fichier, pre\*'cisant dans quel fichier l'e\*'criture doit avoir lieu\ : .PP .Vb 3 \& print STDERR "Dernier avertissement.\en"; \& print OUTFILE $record; \& print LOGFILE $logmessage; .Ve .PP Quand vous avez fini de travailler avec vos descripteurs de fichier, vous devez en principe les fermer a\*` l'aide de la fonction \f(CW\*(C`close()\*(C'\fR (quoique pour e\*^tre tout a\*` fait honne\*^tes, Perl se chargera de faire le me\*'nage si vous oubliez)\ : .PP .Vb 1 \& close INFILE; .Ve .Sh "Expressions re\*'gulie\*`res (ou rationnelles)" .IX Subsection "Expressions re'gulie`res (ou rationnelles)" Dans le jargon informatique on de\*'signe par \*(L"expressions re\*'gulie\*`res\*(R" (ou rationnelles) une syntaxe utilise\*'e pour de\*'finir des motifs recherche\*'s dans un texte ou une chai\*^ne de caracte\*`res. Le support par Perl des expressions re\*'gulie\*`res est a\*` la fois large et puissant et c'est le sujet d'une documentation tre\*`s comple\*`te\ : perlrequick, perlretut et autres. Nous allons les pre\*'senter brie\*`vement\ : .IP "De\*'tection de motifs simples" 4 .IX Item "De'tection de motifs simples" .Vb 2 \& if (/foo/) { ... } # vrai si $_ contient "foo" \& if ($a =~ /foo/) { ... } # vrai si $a contient "foo" .Ve .Sp L'ope\*'rateur \f(CW\*(C`//\*(C'\fR de de\*'tection de motif est documente\*' dans perlop. Par de\*'faut il travaille sur la variable \f(CW$_\fR ou peut e\*^tre applique\*' a\*` une autre variable en utilisant l'ope\*'rateur de liaison \f(CW\*(C`=~\*(C'\fR (lui aussi documente\*' dans perlop). .IP "Substitution simple" 4 .IX Item "Substitution simple" .Vb 3 \& s/foo/bar/; # remplace foo par bar dans $_ \& $a =~ s/foo/bar/; # remplace foo par bar dans $a \& $a =~ s/foo/bar/g; # remplace TOUTES LES INSTANCES de foo par bar dans $a .Ve .Sp L'ope\*'rateur de substitution \f(CW\*(C`s///\*(C'\fR est documente\*' a\*` la page perlop. .IP "Expressions re\*'gulie\*`res plus complexes" 4 .IX Item "Expressions re'gulie`res plus complexes" Vous n'e\*^tes pas limite\*' a\*` la de\*'tection de motifs fixes (si c'e\*'tait le cas, on ne parlerait d'ailleurs pas d'expressions re\*'gulie\*`res, regexp pour les intimes). En pratique il est possible de de\*'tecter pratiquement n'importe quel motif imaginable en utilisant des expressions re\*'gulie\*`res plus complexes. Celles-ci sont documente\*'es en profondeur dans perlre. Pour vous mettre en bouche voici de\*'ja\*` une petite antise\*`che\ : .Sp .Vb 10 \& . un caracte\*`re unique (n'importe lequel) \& \es un blanc (espace, tabulation, a\*` la ligne) \& \eS un caracte\*`re non\-blanc (le contraire du pre\*'ce\*'dent) \& \ed un chiffre (0\-9) \& \eD un non\-chiffre \& \ew un caracte\*`re alphanume\*'rique (a\-z, A\-Z, 0\-9, _) \& \eW un non\-alphanume\*'rique \& [aeiou] n'importe quel caracte\*`re de l'ensemble entre crochets \& [^aeiou] n'importe quel caracte\*`re sauf ceux de l'ensemble entre crochets \& (foo|bar|baz) n'importe laquelle des alternatives propose\*'es \& \& ^ le de\*'but d'une chai\*^ne de caracte\*`res \& $ la fin d'une chai\*^ne de caracte\*`res .Ve .Sp Des quantificateurs peuvent e\*^tre utilise\*'s pour indiquer combien des e\*'le\*'ments pre\*'ce\*'dents vous de\*'sirez, un e\*'le\*'ment de\*'signant aussi bien un caracte\*`re litte\*'ral qu'un des me\*'ta\-caracte\*`res e\*'nume\*'re\*'s plus haut, ou encore un groupe de caracte\*`res ou de me\*'ta\-caracte\*`res entre parenthe\*`ses. .Sp .Vb 6 \& * ze\*'ro ou plus \& + un ou plus \& ? ze\*'ro ou un \& {3} exactement 3 fois l'e\*'le\*'ment pre\*'ce\*'dent \& {3,6} entre 3 et 6 fois l'e\*'le\*'ment pre\*'ce\*'dent \& {3,} 3 ou plus des e\*'le\*'ments pre\*'ce\*'dents .Ve .Sp Quelques exemples rapides\ : .Sp .Vb 6 \& /^\ed+/ une chai\*^ne commenc\*,ant par un chiffre ou plus \& /^$/ une chai\*^ne vide (le de\*'but et la fin sont adjacents) \& /(\ed\es){3}/ un groupe de trois chiffres, chacun suivi par un blanc \& (par exemple "3 4 5 ") \& /(a.)+/ une chai\*^ne dont toutes les lettres impaires sont des a \& (par exemple "abacadaf") \& \& # La boucle suivante lit l'entre\*'e standard \& # et affiche toutes les lignes non vides : \& while (<>) { \& next if /^$/; \& print; \& } .Ve .IP "Capturer gra\*^ce aux parenthe\*`ses" 4 .IX Item "Capturer gra^ce aux parenthe`ses" En plus de cre\*'er un regroupement de caracte\*`res sur lequel utilise\*' un quantificateur, les parenthe\*`ses servent un second but. Elles peuvent e\*^tre utilise\*'es pour capturer les re\*'sultats d'une portion de regexp pour un usage ulte\*'rieur. Les re\*'sultats sont conserve\*'s dans les variables \f(CW$1\fR, \f(CW$2\fR et ainsi de suite. .Sp .Vb 1 \& # la me\*'thode du pauvre pour de\*'composer une adresse e\-mail \& \& if ($email =~ /([^@]+)@(.+)/) { \& print "Compte : $1\en"; \& print "Ho\*^te : $2\en"; \& } .Ve .IP "Autres possibilite\*'s des regexp" 4 .IX Item "Autres possibilite's des regexp" Les regexps de Perl supportent e\*'galement les re\*'fe\*'rences arrie\*`re, les re\*'fe\*'rences avant et toutes sortes d'autres constructions complexes. Pour tout savoir lisez perlrequick, perlretut et perlre. .Sh "E\*'criture de sous-programmes" .IX Subsection "E'criture de sous-programmes" Rien n'est plus facile que de de\*'clarer un sous-programme\ : .PP .Vb 4 \& sub log { \& my $logmessage = shift; \& print LOGFILE $logmessage; \& } .Ve .PP Que peut bien vouloir dire ce \f(CW\*(C`shift\*(C'\fR\ ? En re\*'alite\*', comme nous l'avions e\*'voque\*' plus haut, les parame\*`tres sont transmis aux sous-programmes a\*` travers le tableau magique \f(CW@_\fR (voir perlvar pour plus de de\*'tails). Il se trouve que la fonction \f(CW\*(C`shift\*(C'\fR, qui attend une liste, utilise \f(CW@_\fR comme argument par de\*'faut. Donc la ligne \f(CW\*(C`my $logmessage = shift;\*(C'\fR extrait le premier argument de la liste et le range dans \f(CW$logmessage\fR. .PP Il existe d'autre fac\*,ons de manipuler \f(CW@_\fR\ : .PP .Vb 2 \& my ($logmessage, $priority) = @_; # fre\*'quent \& my $logmessage = $_[0]; # plus rare .Ve .PP Les sous-programmes peuvent bien entendu retourner des re\*'sultats\ : .PP .Vb 5 \& sub square { \& my $num = shift; \& my $result = $num * $num; \& return $result; \& } .Ve .PP Le sujet est e\*'videmment beaucoup plus complexe. Pour plus d'informations sur l'e\*'criture de sous\-programmes, voyez perlsub. .Sh "Perl oriente\*' objet" .IX Subsection "Perl oriente' objet" Les possibilite\*'s objet de Perl sont relativement simples. Elles sont imple\*'mente\*'es en utilisant des re\*'fe\*'rences qui connaissent le type d'objet sur lesquelles elles pointent en se basant sur le concept de paquetage de Perl. La programmation objet en Perl de\*'passe largement le cadre de ce document. Lisez pluto\*^t perlboot, perltoot, perltooc et perlobj. .PP En tant que de\*'butant en Perl, vous utiliserez sans doute rapidement des modules tierces\-parties, dont l'utilisation est brie\*`vement de\*'crite ci\-dessous. .Sh "Utilisations de modules Perl" .IX Subsection "Utilisations de modules Perl" Les modules Perl fournissent quantite\*' de fonctionnalite\*'s qui vous e\*'viteront de re\*'inventer sans cesse la roue. Il suffit de les te\*'le\*'charger depuis le site \&\s-1CPAN\s0 (http://www.cpan.org/). Beaucoup de modules sont aussi inclus dans la distribution Perl elle\-me\*^me. .PP Les cate\*'gories de modules vont de la manipulation de texte aux protocoles re\*'seau, en passant par l'acce\*`s aux bases de donne\*'es ou au graphisme. \s-1CPAN\s0 pre\*'sente la liste des modules classe\*'s par cate\*'gorie. .PP Pour apprendre a\*` installer les modules te\*'le\*'charge\*'s depuis \s-1CPAN\s0, lisez perlmodinstall. .PP Pour apprendre a\*` utiliser un module particulier, utilisez \f(CW\*(C`perldoc \&\f(CIModule::Name\f(CW\*(C'\fR. Typiquement vous commencerez par un \f(CW\*(C`use \f(CIModule::Name\f(CW\*(C'\fR, qui vous donnera acce\*`s aux fonctions exporte\*'es ou a\*` l'interface oriente\*'e objet du module. .PP perlfaq contient une liste de questions et les solutions a\*` de nombreux proble\*`mes communs en Perl et propose souvent de bons modules \s-1CPAN\s0 a\*` utiliser. .PP perlmod de\*'crit les modules Perl modules de manie\*`re plus ge\*'ne\*'rale. perlmodlib e\*'nume\*`re les modules qui accompagnent votre installation Perl. .PP Si e\*'crire des modules Perl vous de\*'mange, perlnewmod vous donnera d'excellents conseils. .SH "AUTEUR" .IX Header "AUTEUR" Kirrily \*(L"Skud\*(R" Robert . .PP L'utilisation de l'image du chameau en association avec le langage Perl est une marque de\*'pose\*'e de O'Reilly & Associates (http://www.oreilly.com/). Utilise\*' avec permission. .SH "TRADUCTION" .IX Header "TRADUCTION" .Sh "Version" .IX Subsection "Version" Cette traduction franc\*,aise correspond a\*` la version anglaise distribue\*'e avec perl 5.8.8. Pour en savoir plus concernant ces traductions, consultez . .Sh "Traducteur" .IX Subsection "Traducteur" Christophe Grosjean .Sh "Relecture" .IX Subsection "Relecture" Paul Gaborit (Paul.Gaborit at enstimac.fr).