.\" 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 "PERLSYN 1" .TH PERLSYN 1 "2006-03-14" "DocFr" "User Contributed Perl Documentation" .SH "NAME/NOM" .IX Xref "syntaxe" .IX Header "NAME/NOM" perlsyn \- Syntaxe de Perl .SH "DESCRIPTION" .IX Header "DESCRIPTION" Un script Perl est constitue\*' d'une suite de de\*'clarations et d'instructions qui sont exe\*'cute\*'es de haut en bas. Les boucles, les sous-programmes et d'autres structures de contro\*^les vous permettent de vous de\*'placer dans le code. .PP Perl est un langage a\*` syntaxe libre. Vous pouvez donc le pre\*'senter et l'indenter comme bon vous semble. Les espaces ne servent qu'a\*` se\*'parer les e\*'le\*'ments syntaxiques contrairement a\*` des langages comme Python ou\*` ils font partie inte\*'grante de la syntaxe. .PP La plupart des e\*'le\*'ments syntaxiques de Perl sont \fBoptionnels\fR. Au lieu de vous obliger a\*` mettre des parenthe\*`ses pour chaque appel de fonction ou a\*` de\*'clarer toutes les variables, Perl vous laisse libre de le faire ou non et se de\*'brouille pour comprendre ce que vous voulez. Ceci s'appelle \fBFait Ce Que Je Pense\fR ou \fB\s-1FCQJP\s0\fR (NdT: en anglais \fBDo What I Mean\fR ou \fB\s-1DWIM\s0\fR). Le programmeur peut donc e\*^tre \&\fBparesseux\fR et peut coder dans le style qui lui plait. .PP Perl \fBemprunte sa syntaxe\fR et ses concepts a\*` de nombreux langages\ : awk, sed, C, Bourne Shell, Smalltalk, Lisp et me\*^me l'Anglais. D'autres langages ont emprunte\*' a\*` la syntaxe de Perl, en particulier ses extensions aux expressions rationnelles. Donc, si vous avez programme\*' avec d'autres langages, vous rencontrerez des constructions familie\*`res en Perl. Souvent elles fonctionnent de la me\*^me manie\*`re mais lisez tout de me\*^me perltrap pour savoir quand elles diffe\*`rent. .Sh "Declarations" .IX Xref "de\*'clarations undef inde\*'finie non initialise\*'" .IX Subsection "Declarations" Les seules choses que vous devez absolument de\*'clarer en Perl sont les formats de rapport et les sous-programmes (parfois ce n'est me\*^me pas ne\*'cessaire pour les sous\-programmes). Une variable contient la valeur inde\*'finie (\f(CW\*(C`undef\*(C'\fR) jusqu'a\*` ce qu'on lui affecte une valeur, qui est n'importe quoi autre que \f(CW\*(C`undef\*(C'\fR. Lorsqu'il est utilise\*' comme un nombre, \f(CW\*(C`undef\*(C'\fR est traite\*' comme \f(CW0\fR ; lorsqu'il est utilise\*' comme une chai\*^ne, il est traite\*' comme la chai\*^ne vide, \f(CW""\fR ; et lorsqu'il est utilise\*' comme une re\*'fe\*'rence qui n'a pas e\*'te\*' affecte\*'e, il est traite\*' comme une erreur. Si vous activez les avertissements, vous serez notifie\*' de l'utilisation d'une valeur non initialise\*'e chaque fois que vous traiterez \f(CW\*(C`undef\*(C'\fR comme une chai\*^ne ou un nombre. En tout cas, habituellement. Son utilisation dans un contexte boole\*'en, tel que\ : .PP .Vb 2 \& my $a; \& if ($a) {} .Ve .PP ne de\*'clenche pas d'avertissement (parce qu'on teste la ve\*'racite\*' et non la pre\*'sence d'une valeur de\*'finie). Les ope\*'rateurs tels que \f(CW\*(C`++\*(C'\fR, \&\f(CW\*(C`\-\-\*(C'\fR, \f(CW\*(C`+=\*(C'\fR, \f(CW\*(C`\-=\*(C'\fR et \f(CW\*(C`.=\*(C'\fR lorsqu'ils agissent sur une valeur inde\*'finies comme dans\ : .PP .Vb 2 \& my $a; \& $a++; .Ve .PP ne de\*'clenchent pas non plus de tels avertissements. .PP Une de\*'claration peut e\*^tre mise partout ou\*` une instruction peut trouver place, mais n'a pas d'effet sur l'exe\*'cution de la se\*'quence d'instructions principale \- les de\*'clarations prennent toutes effet au moment de la compilation. Typiquement, toutes les de\*'clarations sont place\*'es au de\*'but ou a\*` la fin du script. Toutefois, si vous utilisez des variables prive\*'es de porte\*'e lexicales cre\*'e\*'es avec \f(CW\*(C`my()\*(C'\fR, vous devrez vous assurez que la de\*'finition de votre format ou de votre sous-programme est a\*` l'inte\*'rieur du me\*^me bloc que le my si vous voulez pouvoir acce\*'der a\*` ces variables prive\*'es. .PP La de\*'claration d'un sous-programme permet a\*` un nom de sous-programme d'e\*^tre utilise\*' comme s'il e\*'tait un ope\*'rateur de liste a\*` partir de ce point dans le programme. Vous pouvez de\*'clarer un sous-programme sans le de\*'finir en disant \f(CW\*(C`sub name\*(C'\fR, ainsi\ : .IX Xref "sous-programme, de\*'claration" .PP .Vb 2 \& sub myname; \& $me = myname $0 or die "can't get myname"; .Ve .PP Notez que \fImyname()\fR fonctionne comme un ope\*'rateur de liste, et non comme un ope\*'rateur unaire ; faites donc attention a\*` utiliser \f(CW\*(C`or\*(C'\fR au lieu de \f(CW\*(C`||\*(C'\fR dans ce cas. Toutefois, si vous de\*'clariez le sous-programme avec \f(CW\*(C`sub myname ($)\*(C'\fR, alors \f(CW\*(C`myname\*(C'\fR fonctionnerait comme un ope\*'rateur unaire, donc \f(CW\*(C`or\*(C'\fR aussi bien que \f(CW\*(C`||\*(C'\fR feraient l'affaire. .PP Les de\*'clarations de sous-programmes peuvent aussi e\*^tre charge\*'es a\*` l'aide de l'instruction \f(CW\*(C`require\*(C'\fR ou bien a\*` la fois charge\*'es et importe\*'es dans votre espace de noms via l'instruction \f(CW\*(C`use\*(C'\fR. Voir perlmod pour plus de de\*'tails. .PP Une se\*'quence d'instructions peut contenir des de\*'clarations de variables de porte\*'e lexicale, mais a\*` part pour de\*'clarer un nom de variable, la de\*'claration fonctionne comme une instruction ordinaire, et est e\*'labore\*'e a\*` l'inte\*'rieur de la se\*'quence d'instructions en tant que telle. Cela signifie qu'elle a a\*` la fois un effet a\*` la compilation et lors de l'exe\*'cution. .Sh "Commentaires" .IX Xref "commentaire #" .IX Subsection "Commentaires" Dans une ligne, tout texte commenc\*,ant par le caracte\*`re \f(CW"#"\fR et jusqu'a\*` la fin de la ligne est conside\*'re\*' commme un commentaire et est donc ignore\*'. L'exception a\*` cette re\*`gle concerne les \f(CW"#"\fR pre\*'sents dans les chai\*^nes de caracte\*`res ou dans les expressions rationnelles. .Sh "Instructions simples" .IX Xref "instructions point-virgule expression ;" .IX Subsection "Instructions simples" Le seul type d'instruction simple est une expression e\*'value\*'e pour ses effets de bord. Chaque instruction simple doit e\*^tre termine\*'e par un point\-virgule, sauf si c'est la dernie\*`re instruction d'un bloc, auquel cas le point-virgule est optionnel. (Nous vous encourageons tout de me\*^me a\*` placer ce point-virgule si le bloc prend plus d'une ligne, car vous pourriez e\*'ventuellement ajouter une autre ligne). Notez qu'il existe des ope\*'rateurs comme \f(CW\*(C`eval {}\*(C'\fR et \f(CW\*(C`do {}\*(C'\fR qui ont l'air d'instructions compose\*'es, mais qui ne le sont pas (ce sont juste des \&\s-1TERMES\s0 dans une expression), et qui ont donc besoin d'une terminaison explicite s'ils sont utilise\*'s comme dernier e\*'le\*'ment d'une instruction. .Sh "Le vrai et le faux" .IX Xref "vrai faux ! not ne\*'gation 0" .IX Subsection "Le vrai et le faux" Le nombre 0, les chai\*^nes \f(CW'0'\fR et \f(CW''\fR, la liste vide \f(CW\*(C`()\*(C'\fR et \&\f(CW\*(C`undef\*(C'\fR sont conside\*'re\*'s comme faux dans un contexte boole\*'en. Tout autre valeur est conside\*'re\*'e comme vraie. La ne\*'gation d'une valeur vraie par les ope\*'rateurs \f(CW\*(C`!\*(C'\fR ou \f(CW\*(C`not\*(C'\fR retourne une valeur fausse spe\*'ciale. Lorsqu'elle est e\*'value\*'e en tant que chai\*^ne, elle vaut \f(CW''\fR mais e\*'value\*'e en tant que nombre, elle vaut 0. .Sh "Modificateurs d'instruction" .IX Xref "modificateur d'instruction modificateur if unless while until foreach for" .IX Subsection "Modificateurs d'instruction" Toute instruction simple peut e\*^tre suivie de fac\*,on optionelle par un \&\fI\s-1UNIQUE\s0\fR modificateur, juste avant le point-virgule de terminaison (ou la fin du bloc). Les modificateurs possibles sont\ : .PP .Vb 5 \& if EXPR \& unless EXPR \& while EXPR \& until EXPR \& foreach LISTE .Ve .PP L'expression \f(CW\*(C`EXPR\*(C'\fR qui suit le modificateur s'appelle la \&\*(L"condition\*(R". Sa ve\*'racite\*' ou sa faussete\*' de\*'termine le comportement du modificateur. .PP \&\f(CW\*(C`if\*(C'\fR exe\*'cute l'instruction une fois \fIsi et seulement si\fR la condition est vraie. \f(CW\*(C`unless\*(C'\fR fait le contraire\ : il exe\*'cute l'instruction \fIsauf\fR si la condition est vraie (autrement dit, si la condition est fausse). .PP .Vb 2 \& print "Les bassets ont de longues oreilles" if length $oreilles >= 10; \& aller_dehors() and jouer() unless $il_pleut; .Ve .PP Le modificateur \f(CW\*(C`foreach\*(C'\fR est un ite\*'rateur\ : il exe\*'cute l'instruction une fois pour chacun des items de \s-1LISTE\s0 (avec \f(CW$_\fR qui est un alias de l'item courant). .PP .Vb 1 \& print "Bonjour $_ !\en" foreach ("tout le monde", "Anne", "Maitresse"); .Ve .PP \&\f(CW\*(C`while\*(C'\fR re\*'pe\*`te l'instruction \fItant que\fR la condition est vraie. \f(CW\*(C`until\*(C'\fR fait le contraire\ : il re\*'pe\*`te l'instruction \fIjusqu'a\*`\fR ce que la condition soit vraie (ou, autrement dit, tant que la condition est fausse). .PP .Vb 3 \& # Dans les deux cas on compte de 0 a\*` 10 \& print $i++ while $i <= 10; \& print $j++ until $j > 10; .Ve .PP Les modificateurs \f(CW\*(C`while\*(C'\fR et \f(CW\*(C`until\*(C'\fR ont la se\*'mantique habituelle des "boucles \f(CW\*(C`while\*(C'\fR" (la condition est e\*'value\*'e en premier), sauf lorsqu'ils sont applique\*'s a\*` un \f(CW\*(C`do\*(C'\fR\-BLOC (ou a\*` la construction de\*'sapprouve\*'e \f(CW\*(C`do\*(C'\fR\-SOUS_PROGRAMME), auquel cas le bloc s'exe\*'cute une fois avant que la condition ne soit e\*'value\*'e. Ceci afin que vous puissiez e\*'crire des boucles telles que\ : .PP .Vb 4 \& do { \& $line = ; \& ... \& } until $line eq ".\en"; .Ve .PP Voir \*(L"do\*(R" in perlfunc. Notez aussi que l'instruction de contro\*^le de boucle de\*'crite plus tard \fIne\fR fonctionnera \fIpas\fR dans cette construction, car les modificateurs n'utilisent pas de labels de boucle. De\*'sole\*'. Vous pouvez toujours mettre un autre bloc a\*` l'inte\*'rieur (for \f(CW\*(C`next\*(C'\fR) ou autour (for \f(CW\*(C`last\*(C'\fR) pour re\*'aliser ce genre de choses. Pour \f(CW\*(C`next\*(C'\fR, il suffit de doubler les accolades\ : .IX Xref "next last redo" .PP .Vb 4 \& do {{ \& next if $x == $y; \& # faire quelque chose ici \& }} until $x++ > $z; .Ve .PP Pour \f(CW\*(C`last\*(C'\fR, vous devez faire quelque chose de plus e\*'labore\*'\ : .IX Xref "last" .PP .Vb 6 \& LOOP: { \& do { \& last if $x = $y**2; \& # faire quelque chose ici \& } while $x++ <= $z; \& } .Ve .PP \&\fB\s-1NOTE\s0\ :\fR le comportement d'une instruction \f(CW\*(C`my\*(C'\fR modifie\*' par un modificateur conditionnel ou une construction de boucle (par exemple \&\f(CW\*(C`my $x if ...\*(C'\fR) est \fBinde\*'fini\fR. La valeur de la variable peut e\*^tre \&\f(CW\*(C`undef\*(C'\fR, la valeur pre\*'ce\*'dement affecte\*'e ou n'importe quoi d'autre. Ne de\*'pendez pas d'un comportement particulier. Les prochaines versions de perl feront peut\-e\*^tre quelque chose de diffe\*'rents que celle que vous utilisez actuellement. .IX Xref "my" .Sh "Instructions compose\*'es" .IX Xref "compose\*'e, instruction bloc accolade { } if unless while until foreach for continue" .IX Subsection "Instructions compose'es" En Perl, une se\*'quence d'instructions qui de\*'finit une porte\*'e est appele\*'e un bloc. Un bloc est parfois de\*'limite\*' par le fichier qui le contient (dans le cas d'un fichier requis, ou dans celui du programme en entier), et parfois un bloc est de\*'limite\*' par la longueur d'une chai\*^ne (dans le cas d'un eval). .PP Mais ge\*'ne\*'ralement, un bloc est de\*'limite\*' par des accolades. Nous appellerons cette construction syntaxique un \s-1BLOC\s0. .PP Les instructions compose\*'es suivantes peuvent e\*^tre utilise\*'es pour contro\*^ler un flux\ : .PP .Vb 11 \& if (EXPR) BLOC \& if (EXPR) BLOC else BLOC \& if (EXPR) BLOC elsif (EXPR) BLOC ... else BLOC \& LABEL while (EXPR) BLOC \& LABEL while (EXPR) BLOC continue BLOC \& LABEL until (EXPR) BLOC \& LABEL until (EXPR) BLOC continue BLOC \& LABEL for (EXPR; EXPR; EXPR) BLOC \& LABEL foreach VAR (LIST) BLOC \& LABEL foreach VAR (LIST) BLOCK continue BLOCK \& LABEL BLOC continue BLOC .Ve .PP Notez que, contrairement au C et au Pascal, tout ceci est de\*'fini en termes de BLOCs, et non d'instructions. Ceci veut dire que les accolades sont \fIrequises\fR \- aucune instruction ne doit trai\*^ner. Si vous de\*'sirez e\*'crire des conditionnelles sans accolades, il existe plusieurs autres fac\*,ons de le faire. Les exemples suivants font tous la me\*^me chose\ : .PP .Vb 5 \& if (!open(FOO)) { die "Can't open $FOO: $!"; } \& die "Can't open $FOO: $!" unless open(FOO); \& open(FOO) or die "Can't open $FOO: $!"; # FOO or bust! \& open(FOO) ? 'hi mom' : die "Can't open $FOO: $!"; \& # ce dernier est un peu exotique .Ve .PP L'instruction \f(CW\*(C`if\*(C'\fR est directe. Puisque les BLOCs sont toujours entoure\*'s d'accolades, il n'y a jamais d'ambigui\*:te\*' pour savoir a\*` quel \&\f(CW\*(C`if\*(C'\fR correspond un \f(CW\*(C`else\*(C'\fR. Si vous utilisez \f(CW\*(C`unless\*(C'\fR a\*` la place de \&\f(CW\*(C`if\*(C'\fR, le sens du test est inverse\*'. .PP L'instruction \f(CW\*(C`while\*(C'\fR exe\*'cute le bloc tant que l'expression est vraie (son e\*'valuation ne renvoie pas une chai\*^ne nulle (\f(CW""\fR) ou \f(CW0\fR ou \&\f(CW\*(C`"0")\*(C'\fR. L'instruction \f(CW\*(C`until\*(C'\fR exe\*'cute le bloc tant que l'expression est fausse. Le \s-1LABEL\s0 est optionnel, et s'il est pre\*'sent, il est constitue\*' d'un identifiant suivi de deux points. Le \s-1LABEL\s0 identifie la boucle pour les instructions de contro\*^le de boucle \f(CW\*(C`next\*(C'\fR, \&\f(CW\*(C`last\*(C'\fR, et \f(CW\*(C`redo\*(C'\fR. Si le \s-1LABEL\s0 est omis, l'instruction de contro\*^le de boucle se re\*'fe\*`re a\*` la boucle incluse dans toutes les autres. Ceci peut amener une recherche dynamique dans votre pile au moment de l'exe\*'cution pour trouver le \s-1LABEL\s0. Un comportement aussi de\*'sespe\*'rant provoquera un avertissement si vous utilisez le pragma \f(CW\*(C`use warnings\*(C'\fR ou l'option \fB\-w\fR. .PP S'il existe un \s-1BLOC\s0 \f(CW\*(C`continue\*(C'\fR, il est toujours exe\*'cute\*' juste avant que la condition ne soit a\*` nouveau e\*'value\*'e. Ce bloc peut donc e\*^tre utilise\*' pour incre\*'menter une variable de boucle, me\*^me lorsque la boucle a e\*'te\*' continue\*'e via l'instruction \f(CW\*(C`next\*(C'\fR. .Sh "Contro\*^le de boucle" .IX Xref "contro\*^le de boucle boucle, contro\*^le next last redo continue" .IX Subsection "Contro^le de boucle" La commande \f(CW\*(C`next\*(C'\fR de\*'marre la prochaine ite\*'ration de la boucle\ : .PP .Vb 4 \& LINE: while () { \& next LINE if /^#/; # elimine les commentaires \& ... \& } .Ve .PP La commande \f(CW\*(C`last\*(C'\fR sort imme\*'diatement de la boucle en question. Le bloc \f(CW\*(C`continue\*(C'\fR, s'il existe, n'est pas exe\*'cute\*'\ : .PP .Vb 4 \& LINE: while () { \& last LINE if /^$/; # sort quand on en a fini avec l'en\-tete \& ... \& } .Ve .PP La commande \f(CW\*(C`redo\*(C'\fR rede\*'marre le bloc de la boucle sans re\*'e\*'valuer la condition. Le bloc \f(CW\*(C`continue\*(C'\fR, s'il existe, n'est \fIpas\fR exe\*'cute\*'. Cette commande est normalement utilise\*'e par les programmes qui veulent se mentir a\*` eux\-me\*^mes au sujet de ce qui vient de leur e\*^tre fourni en entre\*'e. .PP Par exemple, lors du traitement d'un fichier comme \fI/etc/termcap\fR. Si vos lignes en entre\*'e sont susceptibles de se terminer par un antislash pour indiquer leur continuation, vous pouvez vouloir poursuivre et re\*'cupe\*'rer l'enregistrement suivant. .PP .Vb 8 \& while (<>) { \& chomp; \& if (s/\e\e$//) { \& $_ .= <>; \& redo unless eof(); \& } \& # on traite $_ \& } .Ve .PP qui est le raccourci Perl pour la version plus explicite\ : .PP .Vb 8 \& LINE: while (defined($line = )) { \& chomp($line); \& if ($line =~ s/\e\e$//) { \& $line .= ; \& redo LINE unless eof(); # pas eof(ARGV)! \& } \& # on traite $line \& } .Ve .PP Notez que s'il y avait un bloc \f(CW\*(C`continue\*(C'\fR dans le code ci\-dessus, il ne serait exe\*'cute\*' que pour les lignes rejete\*'es par l'expression rationnelle (puisque redo saut le bloc continue). Un bloc \f(CW\*(C`continue\*(C'\fR est souvent utilise\*' pour re\*'initialiser les compteurs de lignes ou les recherches de motifs \f(CW\*(C`?pat?\*(C'\fR qui ne correspondent qu'une fois\ : .PP .Vb 10 \& # inspire par :1,$g/fred/s//WILMA/ \& while (<>) { \& ?(fred)? && s//WILMA $1 WILMA/; \& ?(barney)? && s//BETTY $1 BETTY/; \& ?(homer)? && s//MARGE $1 MARGE/; \& } continue { \& print "$ARGV $.: $_"; \& close ARGV if eof(); # reinitialise $. \& reset if eof(); # reinitialise ?pat? \& } .Ve .PP Si le mot \f(CW\*(C`while\*(C'\fR est remplace\*' par le mot \f(CW\*(C`until\*(C'\fR, le sens du test est inverse\*', mais la condition est toujours teste\*'e avant la premie\*`re ite\*'ration. .PP Les instructions de contro\*^le de boucle ne fonctionnent pas dans un \&\f(CW\*(C`if\*(C'\fR ou dans un \f(CW\*(C`unless\*(C'\fR, puisque ce ne sont pas des boucles. Vous pouvez toutefois doubler les accolades pour qu'elles le deviennent. .PP .Vb 5 \& if (/pattern/) {{ \& last if /fred/; \& next if /barney/; # me\*^me effet que "last", mais en moins compre\*'hensible \& # mettre quelque chose ici \& }} .Ve .PP Ceci est du au fait qu'un bloc est conside\*'re\*' comme une boucle qui ne s'exe\*'cute qu'une fois. Voir \*(L"BLOCs de base et instruction switch\*(R". .PP La forme \f(CW\*(C`while/if BLOC BLOC\*(C'\fR, disponible en Perl 4, ne l'est plus. Remplacez toutes les occurrences de \f(CW\*(C`if BLOC\*(C'\fR par \f(CW\*(C`if (do BLOC)\*(C'\fR. .Sh "Boucles for" .IX Xref "for foreach" .IX Subsection "Boucles for" Les boucles \f(CW\*(C`for\*(C'\fR de Perl dans le style de C fonctionnent de la me\*^me fac\*,on que les boucles \f(CW\*(C`while\*(C'\fR correspondantes ; cela signifie que ceci\ : .PP .Vb 3 \& for ($i = 1; $i < 10; $i++) { \& ... \& } .Ve .PP est la me\*^me chose que c\*,a\ : .PP .Vb 6 \& $i = 1; \& while ($i < 10) { \& ... \& } continue { \& $i++; \& } .Ve .PP Il existe une diffe\*'rence mineure\ : si des variables sont de\*'clare\*'es par \&\f(CW\*(C`my\*(C'\fR dans la section d'initialisation d'un \f(CW\*(C`for\*(C'\fR, la porte\*'e lexicale de ces variables est limite\*'e a\*` la boucle \f(CW\*(C`for\*(C'\fR (le corps de la boucle et sa section de contro\*^le). .IX Xref "my" .PP En plus du bouclage classique dans les indices d'un tableau, \f(CW\*(C`for\*(C'\fR peut se pre\*^ter a\*` de nombreuses autres applications inte\*'ressantes. En voici une qui e\*'vite le proble\*`me que vous rencontrez si vous testez explicitement la fin d'un fichier sur un descripteur de fichier interactif, ce qui donne l'impression que votre programme se ge\*`le. .IX Xref "eof end-of-file fin de fichier" .PP .Vb 5 \& $on_a_tty = \-t STDIN && \-t STDOUT; \& sub prompt { print "yes? " if $on_a_tty } \& for ( prompt(); ; prompt() ) { \& # faire quelque chose ici \& } .Ve .PP Utiliser \f(CW\*(C`readline\*(C'\fR (ou sous sa forme d'ope\*'rateur, \f(CW\*(C`\*(C'\fR) comme condition d'un \f(CW\*(C`for\*(C'\fR est un raccourci d'e\*'criture pour ce qui suit. Ce comportement est le me\*^me pour la condition d'une boucle \&\f(CW\*(C`while\*(C'\fR. .IX Xref "readline <>" .PP .Vb 3 \& for ( prompt(); defined( $_ = ); prompt() ) { \& # faire quelque chose \& } .Ve .Sh "Boucles foreach" .IX Xref "for foreach" .IX Subsection "Boucles foreach" La boucle \f(CW\*(C`foreach\*(C'\fR ite\*`re sur une liste de valeurs normale et fixe la variable \s-1VAR\s0 a\*` chacune de ces valeurs successivement. Si la variable est pre\*'ce\*'de\*'e du mot\-cle\*' \f(CW\*(C`my\*(C'\fR, alors elle a une porte\*'e limite\*'e du point de vue lexical, et n'est par conse\*'quent visible qu'a\*` l'inte\*'rieur de la boucle. Autrement, la variable est implicitement locale a\*` la boucle et reprend sa valeur pre\*'ce\*'dente a\*` la sortie de la boucle. Si la variable e\*'tait pre\*'ce\*'demment de\*'clare\*' par \f(CW\*(C`my\*(C'\fR, elle utilise cette variable au lieu de celle qui est globale, mais elle est toujours locale a\*` la boucle. .IX Xref "my local" .PP Le mot\-cle\*' \f(CW\*(C`foreach\*(C'\fR est en fait un synonyme du mot\-cle\*' \f(CW\*(C`for\*(C'\fR, vous pouvez donc utiliser \f(CW\*(C`foreach\*(C'\fR pour sa lisibilite\*' ou \f(CW\*(C`for\*(C'\fR pour sa concision (Ou parce que le Bourne shell vous est plus familier que \&\fIcsh\fR, vous rendant l'utilisation de \f(CW\*(C`for\*(C'\fR plus naturelle). Si \s-1VAR\s0 est omis, \f(CW$_\fR est fixe\*'e a\*` chaque valeur. .IX Xref "$_" .PP Si un e\*'le\*'ment de \s-1LIST\s0 est une lvalue (une valeur modifiable), vous pouvez la modifier en modifiant \s-1VAR\s0 a\*` l'inte\*'rieur de la boucle. A\*` l'inverse, si un e\*'le\*'ment de \s-1LIST\s0 n'est pas une lvalue (c'est une constante), toute tentative de modification de cet e\*'le\*'ment e\*'chouera. En d'autres termes, la variable d'index de la boucle \&\f(CW\*(C`foreach\*(C'\fR est un alias implicite de chaque e\*'le\*'ment de la liste sur laquelle vous bouclez. .IX Xref "alias" .PP Si une partie de \s-1LIST\s0 est un tableau, \f(CW\*(C`foreach\*(C'\fR sera tre\*`s trouble\*' dans le cas ou\*` vous lui ajouteriez ou retireriez des e\*'le\*'ments a\*` l'inte\*'rieur de la boucle, par exemple a\*` l'aide de \f(CW\*(C`splice\*(C'\fR. Ne faites donc pas cela. .IX Xref "splice" .PP \&\f(CW\*(C`foreach\*(C'\fR ne fera probablement pas ce que vous de\*'sirez si \s-1VAR\s0 est une variable lie\*'e ou une autre variable spe\*'ciale. Ne faites pas cela non plus. .PP Exemples\ : .PP .Vb 1 \& for (@ary) { s/foo/bar/ } \& \& for my $elem (@elements) { \& $elem *= 2; \& } \& \& for $count (10,9,8,7,6,5,4,3,2,1,'BOOM') { \& print $count, "\en"; sleep(1); \& } \& \& for (1..15) { print "Merry Christmas\en"; } \& \& foreach $item (split(/:[\e\e\en:]*/, $ENV{TERMCAP})) { \& print "Item: $item\en"; \& } .Ve .PP Voici comment un programmeur C pourrait coder un algorithme en Perl\ : .PP .Vb 9 \& for (my $i = 0; $i < @ary1; $i++) { \& for (my $j = 0; $j < @ary2; $j++) { \& if ($ary1[$i] > $ary2[$j]) { \& last; # ne peut pas sortir totalement :\-( \& } \& $ary1[$i] += $ary2[$j]; \& } \& # voici l'endroit ou ce last m'emmene \& } .Ve .PP Tandis que voici comment un programmeur Perl plus a\*` l'aise avec l'idiome pourrait le faire\ : .PP .Vb 6 \& OUTER: for my $wid (@ary1) { \& INNER: for my $jet (@ary2) { \& next OUTER if $wid > $jet; \& $wid += $jet; \& } \& } .Ve .PP Vous voyez a\*` quel point c'est plus facile ? C'est plus propre, plus su\*^r, et plus rapide. C'est plus propre parce qu'il y a moins de bruit. C'est plus su\*^r car si du code est ajoute\*' entre les deux boucles par la suite, le nouveau code ne sera pas exe\*'cute\*' accidentellement. Le \&\f(CW\*(C`next\*(C'\fR ite\*`re de fac\*,on explicite sur l'autre boucle pluto\*^t que de simplement terminer celle qui est a\*` l'inte\*'rieur. Et c'est plus rapide parce que Perl exe\*'cute une instruction \f(CW\*(C`foreach\*(C'\fR plus rapidement qu'une boucle \f(CW\*(C`for\*(C'\fR e\*'quivalente. .Sh "BLOCs de base et instruction switch" .IX Subsection "BLOCs de base et instruction switch" .IX Xref "switch bloc choix" .PP Un \s-1BLOC\s0 en lui\-me\*^me (avec ou sans label) est d'un point de vue se\*'mantique, e\*'quivalent a\*` une boucle qui s'exe\*'cute une fois. Vous pouvez donc y utilisez n'importe quelle instruction de contro\*^le de boucle pour en sortir ou le recommencer (Notez que ce n'est \fI\s-1PAS\s0\fR vrai pour les blocs \f(CW\*(C`eval{}\*(C'\fR, \f(CW\*(C`sub{}\*(C'\fR, ou \f(CW\*(C`do{}\*(C'\fR contrairement a\*` la croyance populaire, qui \fI\s-1NE\s0\fR comptent \fI\s-1PAS\s0\fR pour des boucles). Le bloc \f(CW\*(C`continue\*(C'\fR est optionnel. .PP La construction de \s-1BLOC\s0 est particulie\*`rement e\*'le\*'gante pour cre\*'er des structures de choix. .PP .Vb 6 \& SWITCH: { \& if (/^abc/) { $abc = 1; last SWITCH; } \& if (/^def/) { $def = 1; last SWITCH; } \& if (/^xyz/) { $xyz = 1; last SWITCH; } \& $nothing = 1; \& } .Ve .PP Il n'y a pas d'instruction \f(CW\*(C`switch\*(C'\fR officielle en Perl, car il existe de\*'ja\*` plusieurs fac\*,ons d'e\*'crire quelque chose d'e\*'quivalent. .PP En revanche, depuis Perl 5.8 pour obtenir les instructions switch et case, ceux qui le souhaitent peuvent faire appel a\*` l'extension Switch en e\*'crivant\ : .PP .Vb 1 \& use Switch; .Ve .PP A\*` partir de la\*`, les nouvelles instructions seront disponibles. Ce n'est pas aussi rapide que cela pourrait l'e\*^tre puisque elles ne font pas re\*'ellement partie du langage (elles sont re\*'alise\*'es via un filtrage des sources) mais elles sont disponibles et utilisables. .PP Vous pourriez e\*'crire a\*` la place du bloc pre\*'ce\*'dent\ : .PP .Vb 6 \& SWITCH: { \& $abc = 1, last SWITCH if /^abc/; \& $def = 1, last SWITCH if /^def/; \& $xyz = 1, last SWITCH if /^xyz/; \& $nothing = 1; \& } .Ve .PP (Ce n'est pas aussi e\*'trange que cela en a l'air une fois que vous avez re\*'alise\*' que vous pouvez utiliser des \*(L"ope\*'rateurs\*(R" de contro\*^le de boucle a\*` l'inte\*'rieur d'une expression, c'est juste l'ope\*'rateur binaire virgule normal utilise\*' dans un contexte scalaire. Voir \&\*(L"Ope\*'rateur virgule\*(R" in perlop.) .PP ou .PP .Vb 6 \& SWITCH: { \& /^abc/ && do { $abc = 1; last SWITCH; }; \& /^def/ && do { $def = 1; last SWITCH; }; \& /^xyz/ && do { $xyz = 1; last SWITCH; }; \& $nothing = 1; \& } .Ve .PP ou formate\*' de fac\*,on a\*` avoir un peu plus l'air d'une instruction \&\f(CW\*(C`switch\*(C'\fR \*(L"convenable\*(R"\ : .PP .Vb 5 \& SWITCH: { \& /^abc/ && do { \& $abc = 1; \& last SWITCH; \& }; \& \& /^def/ && do { \& $def = 1; \& last SWITCH; \& }; \& \& /^xyz/ && do { \& $xyz = 1; \& last SWITCH; \& }; \& $nothing = 1; \& } .Ve .PP ou .PP .Vb 6 \& SWITCH: { \& /^abc/ and $abc = 1, last SWITCH; \& /^def/ and $def = 1, last SWITCH; \& /^xyz/ and $xyz = 1, last SWITCH; \& $nothing = 1; \& } .Ve .PP or me\*^me, horreur, .PP .Vb 8 \& if (/^abc/) \& { $abc = 1 } \& elsif (/^def/) \& { $def = 1 } \& elsif (/^xyz/) \& { $xyz = 1 } \& else \& { $nothing = 1 } .Ve .PP Un idiome courant pour une instruction \f(CW\*(C`switch\*(C'\fR est d'utiliser l'aliasing de \f(CW\*(C`foreach\*(C'\fR pour effectuer une affectation temporaire de \&\f(CW$_\fR pour une reconnaissance pratique des cas\ : .PP .Vb 6 \& SWITCH: for ($where) { \& /In Card Names/ && do { push @flags, '\-e'; last; }; \& /Anywhere/ && do { push @flags, '\-h'; last; }; \& /In Rulings/ && do { last; }; \& die "unknown value for form variable where: `$where'"; \& } .Ve .PP Une autre approche inte\*'ressante de l'instruction switch est de s'arranger pour qu'un bloc \f(CW\*(C`do\*(C'\fR renvoie la valeur correcte\ : .PP .Vb 8 \& $amode = do { \& if ($flag & O_RDONLY) { "r" } # XXX : n'est\-ce pas 0? \& elsif ($flag & O_WRONLY) { ($flag & O_APPEND) ? "a" : "w" } \& elsif ($flag & O_RDWR) { \& if ($flag & O_CREAT) { "w+" } \& else { ($flag & O_APPEND) ? "a+" : "r+" } \& } \& }; .Ve .PP ou .PP .Vb 5 \& print do { \& ($flags & O_WRONLY) ? "write\-only" : \& ($flags & O_RDWR) ? "read\-write" : \& "read\-only"; \& }; .Ve .PP Ou si vous e\*^tes certain que toutes les clauses \f(CW\*(C`&&\*(C'\fR sont vraies, vous pouvez utiliser quelque chose comme ceci, qui \*(L"switche\*(R" sur la valeur de la variable d'environnement \f(CW\*(C`HTTP_USER_AGENT\*(C'\fR. .PP .Vb 10 \& #!/usr/bin/perl \& # choisir une page du jargon file selon le browser \& $dir = 'http://www.wins.uva.nl/~mes/jargon'; \& for ($ENV{HTTP_USER_AGENT}) { \& $page = /Mac/ && 'm/Macintrash.html' \& || /Win(dows )?NT/ && 'e/evilandrude.html' \& || /Win|MSIE|WebTV/ && 'm/MicroslothWindows.html' \& || /Linux/ && 'l/Linux.html' \& || /HP\-UX/ && 'h/HP\-SUX.html' \& || /SunOS/ && 's/ScumOS.html' \& || 'a/AppendixB.html'; \& } \& print "Location: $dir/$page\e015\e012\e015\e012"; .Ve .PP Ce type d'instruction switch ne fonctionne que lorsque vous savez que les clauses \f(CW\*(C`&&\*(C'\fR seront vraies. Si vous ne le savez pas, l'exemple pre\*'ce\*'dent utilisant \f(CW\*(C`?:\*(C'\fR devrait e\*^tre utilise\*'. .PP Vous pourriez aussi envisager d'e\*'crire un hachage de re\*'fe\*'rences de sous-programmes au lieu de synthe\*'tiser une instruction \f(CW\*(C`switch\*(C'\fR. .Sh "Goto" .IX Xref "goto" .IX Subsection "Goto" Bien que cela ne soit pas destine\*' aux a\*^mes sensibles, Perl supporte une instruction \f(CW\*(C`goto\*(C'\fR. Il en existe trois formes\ : \f(CW\*(C`goto\*(C'\fR\-LABEL, \&\f(CW\*(C`goto\*(C'\fR\-EXPR, et \f(CW\*(C`goto\*(C'\fR\-&NAME. Un \s-1LABEL\s0 de boucle n'est pas en ve\*'rite\*' une cible valide pour un \f(CW\*(C`goto\*(C'\fR ; c'est juste le nom de la boucle. .PP La forme \f(CW\*(C`goto\*(C'\fR\-LABEL trouve l'instruction marque\*'e par \s-1LABEL\s0 et reprend l'exe\*'cution a\*` cet endroit. Elle ne peut pas e\*^tre utilise\*'e pour aller dans une structure qui ne\*'cessite une initialisation, comme un sous-programme ou une boucle \f(CW\*(C`foreach\*(C'\fR. Elle ne peut pas non plus e\*^tre utilise\*'e pour aller dans une structure tre\*`s optimise\*'e. Elle peut e\*^tre employe\*'e pour aller presque n'importe ou\*` ailleurs a\*` l'inte\*'rieur de la porte\*'e dynamique, y compris hors des sous\-programmes, mais il est habituellement pre\*'fe\*'rable d'utiliser une autre construction comme \&\f(CW\*(C`last\*(C'\fR ou \f(CW\*(C`die\*(C'\fR. L'auteur de Perl n'a jamais ressenti le besoin d'utiliser cette forme de \f(CW\*(C`goto\*(C'\fR (en Perl, a\*` vrai dire \- C est une toute autre question). .PP La forme \f(CW\*(C`goto\*(C'\fR\-EXPR attend un nom de label, dont la porte\*'e sera re\*'solue dynamiquement. Ceci permet des \f(CW\*(C`goto\*(C'\fRs calcule\*'s a\*` la mode de \&\s-1FORTRAN\s0, mais ce n'est pas ne\*'cessairement recommande\*' si vous optimisez la maintenance du code\ : .PP .Vb 1 \& goto(("FOO", "BAR", "GLARCH")[$i]); .Ve .PP La forme \f(CW\*(C`goto\*(C'\fR\-&NAME est hautement magique, et substitue au sous-programme en cours d'exe\*'cution un appel au sous-programme nomme\*'. C'est utilise\*' par les sous-programmes \f(CW\*(C`AUTOLOAD()\*(C'\fR qui veulent charger une autre routine et pre\*'tendre que cette autre routine a e\*'te\*' appele\*'e a\*` leur place (sauf que toute modification de \f(CW@_\fR dans le sous-programme en cours est propage\*'e a\*` l'autre routine). Apre\*`s le \&\f(CW\*(C`goto\*(C'\fR, me\*^me \f(CW\*(C`caller()\*(C'\fR ne pourra pas dire que cette routine n'a pas e\*'te\*' appele\*'e en premier. .PP Dans presque tous les cas similaires, une bien, bien meilleure ide\*'e est d'utiliser les me\*'canismes de contro\*^le de flux structure\*'s comme \&\f(CW\*(C`next\*(C'\fR, \f(CW\*(C`last\*(C'\fR, ou \f(CW\*(C`redo\*(C'\fR au lieu de s'en remettre a\*` un \&\f(CW\*(C`goto\*(C'\fR. Pour certaines applications, la paire \f(CW\*(C`eval{}\*(C'\fR \- \fIdie()\fR pour le traitement des exceptions peut aussi e\*^tre une approche prudente. .Sh "\s-1POD\s0\ : documentation inte\*'gre\*'e" .IX Xref "POD documentation" .IX Subsection "POD: documentation inte'gre'e" Perl dispose d'un me\*'canisme pour me\*'langer de la documentation avec le code source. Lorsqu'il attend le de\*'but d'une nouvelle instruction, si le compilateur rencontre une ligne commenc\*,ant par un signe e\*'gal et un mot, comme ceci .PP .Vb 1 \& =head1 Here There Be Pods! .Ve .PP Alors ce texte et tout ce qui suit jusqu'a\*` et y compris une ligne commenc\*,ant par \f(CW\*(C`=cut\*(C'\fR sera ignore\*'. Le format du texte en faisant partie est de\*'crit dans perlpod. .PP Ceci vous permet de me\*'langer librement votre code source et votre documentation, comme dans .PP .Vb 1 \& =item snazzle($) \& \& La fonction snazzle() se comportera de la facon la plus \& spectaculaire que vous pouvez imaginer, y compris la pyrotechnie \& cybernetique. \& \& =cut retour au compilateur, nuff of this pod stuff! \& \& sub snazzle($) { \& my $thingie = shift; \& ......... \& } .Ve .PP Notez que les traducteurs pod ne devraient traiter que les paragraphes de\*'butant par une directive pod (cela rend leur analyse plus simple), tandis que le compilateur sait en re\*'alite\*' chercher des se\*'quences pod me\*^me au milieu d'un paragraphe. Cela signifie que le bout de code secret qui suit sera ignore\*' a\*` la fois par le compilateur et les traducteurs. .PP .Vb 5 \& $a=3; \& =truc secret \& warn "Neither POD nor CODE!?" \& =cut back \& print "got $a\en"; .Ve .PP Vous ne devriez probablement pas vous reposer sur le fait que le \&\f(CW\*(C`warn()\*(C'\fR sera ignore\*' pour toujours. Les traducteurs pod ne sont pas tous bien e\*'leve\*'s de ce point de vue, et le compilateur deviendra peut\-e\*^tre plus regardant. .PP On peut aussi utiliser des directives pod pour mettre rapidement une partie de code en commentaire. .Sh "Bons Vieux Commentaires (Non !)" .IX Xref "commentaire ligne # pre\*'processeur eval" .IX Subsection "Bons Vieux Commentaires (Non !)" Perl peut traiter des directives de ligne, a\*` la manie\*`re du pre\*'processeur C. Avec cela, on peut contro\*^ler l'ide\*'e que Perl se fait des noms de fichiers et des nume\*'ros de ligne dans les messages d'erreur ou dans les avertissements (en particulier pour les chai\*^nes traite\*'es par \f(CW\*(C`eval()\*(C'\fR). La syntaxe de ce me\*'canisme est la me\*^me que pour pour la plupart des pre\*'processeurs C\ : elle reconnai\*^t l'expression re\*'gulie\*`re\ : .PP .Vb 5 \& # example: '# line 42 "new_filename.plx"' \& /^\e# \es* \& line \es+ (\ed+) \es* \& (?:\es("?)([^"]+)\e2)? \es* \& $/x .Ve .PP avec \f(CW$1\fR uqi est le nume\*'ro de ligne pour la ligne suivante et \f(CW$3\fR qui est le nom optionnel du fichier (avec ou sans guillemets). .PP Voici quelques exemples que vous devriez pouvoir taper dans votre interpre\*'teur de commandes\ : .PP .Vb 6 \& % perl \& # line 200 "bzzzt" \& # the `#' on the previous line must be the first char on line \& die 'foo'; \& _\|_END_\|_ \& foo at bzzzt line 201. \& \& % perl \& # line 200 "bzzzt" \& eval qq[\en#line 2001 ""\endie 'foo']; print $@; \& _\|_END_\|_ \& foo at \- line 2001. \& \& % perl \& eval qq[\en#line 200 "foo bar"\endie 'foo']; print $@; \& _\|_END_\|_ \& foo at foo bar line 200. \& \& % perl \& # line 345 "goop" \& eval "\en#line " . _\|_LINE_\|_ . ' "' . _\|_FILE_\|_ ."\e"\endie 'foo'"; \& print $@; \& _\|_END_\|_ \& foo at goop line 345. .Ve .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" Traduction initiale\ : Roland Trique <\fIroland.trique@free.fr\fR>. Mise a\*` jour\ : Paul Gaborit . .Sh "\s-1RELECTURE\s0" .IX Subsection "RELECTURE" Re\*'gis Julie\*' <\fIRegis.Julie@cetelem.fr\fR>, Etienne Gauthier <\fIegauthie@capgemini.fr\fR>