.\" 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 "PERLFAQ7 1" .TH PERLFAQ7 1 "2006-03-26" "DocFr" "User Contributed Perl Documentation" .SH "NAME/NOM" .IX Header "NAME/NOM" perlfaq7 \- Questions ge\*'ne\*'rales sur le langage Perl ($Revision: 1.28 $, \f(CW$Date:\fR 2005/12/31 00:54:37 $) .SH "DESCRIPTION" .IX Header "DESCRIPTION" Cette section traite des questions ge\*'ne\*'rales sur le langage Perl qui ne trouvent leur place dans aucune autre section. .Sh "Puis-je avoir une BNF/yacc/RE pour le langage Perl\ ?" .IX Subsection "Puis-je avoir une BNF/yacc/RE pour le langage Perl?" Il n'y a pas de \s-1BNF\s0, mais vous pouvez vous frayer un chemin dans la grammaire de yacc dans perly.y au sein de la distribution source si vous e\*^tes particulie\*`rement brave. La grammaire repose sur un code de mots\-cle\*'s complexe, pre\*'parez\-vous donc a\*` vous aventurer aussi dans toke.c. .PP Selon les termes de Chaim Frenkel\ : \*(L"La grammaire de Perl ne peut pas e\*^tre re\*'duite a\*` une \s-1BNF\s0. Le travail d'analyse de perl est distribue\*' entre yacc, l'analyser lexical, de la fume\*'e et des miroirs\*(R". .Sh "Quels sont tous ces $@%&* de signes de ponctuation, et comment savoir quand les utiliser\ ?" .IX Subsection "Quels sont tous ces $@%&* de signes de ponctuation, et comment savoir quand les utiliser?" Ce sont des spe\*'cificateurs, comme de\*'taille\*' dans perldata\ : .PP .Vb 9 \& $ pour les valeurs scalaires (nombres, chai\*^nes ou re\*'fe\*'rences) \& @ pour les tableaux \& % pour les hachages (tableaux associatifs) \& & pour les sous\-programmes (alias les fonctions, les proce\*'dures, \& les me\*'thodes) \& * pour tous les types de la table des noms courante. Dans la \& version 4, vous les utilisiez comme des pointeurs, mais dans les \& versions modernes de perl, vous pouvez utiliser simplement les \& re\*'fe\*'rences. .Ve .PP Les trois autres symboles que vous risquez fortement de rencontrer sans qu'ils soient ve\*'ritablement des spe\*'cificateurs de type sont\ : .PP .Vb 3 \& <> utilise\*'s pour re\*'cupe\*'rer un enregistrement depuis un \& filehandle. \& \e prend une re\*'fe\*'rence a\*` quelque chose. .Ve .PP Notez que <\s-1FICHIER\s0> n'est \fIni\fR le spe\*'cificateur de type pour les fichiers \fIni\fR le nom du handle. C'est l'ope\*'rateur \f(CW\*(C`<>\*(C'\fR applique\*' au handle \s-1FICHIER\s0. Il lit une ligne (en fait un enregistrement \*(-- voir \&\*(L"$/\*(R" in perlvar) depuis le handle \s-1FICHIER\s0 dans un contexte scalaire, ou \fItoutes\fR les lignes dans un contexte de liste. Lorsqu'on ouvre, ferme ou re\*'alise n'importe quelle autre ope\*'ration a\*` part \&\f(CW\*(C`<>\*(C'\fR sur des fichiers, ou me\*^me si l'on parle du handle, n'utilisez \&\fIpas\fR les crochets. Ces expressions sont correctes\ : \f(CW\*(C`eof(FH)\*(C'\fR, \&\f(CW\*(C`seek(FH, 0, 2)\*(C'\fR et \*(L"copie de \s-1STDIN\s0 vers \s-1FICHIER\s0\*(R". .Sh "Dois-je toujours/jamais mettre mes chai\*^nes entre guillemets ou utiliser les points-virgules et les virgules\ ?" .IX Subsection "Dois-je toujours/jamais mettre mes chai^nes entre guillemets ou utiliser les points-virgules et les virgules?" Normalement, un bareword n'a pas besoin d'e\*^tre mis entre guillemets, mais dans la plupart des cas, il le devrait probablement (et doit l'e\*^tre sous \f(CW\*(C`use strict\*(C'\fR). Mais une cle\*' de hachage constitue\*'e d'un simple mot (qui ne soit pas le nom d'un sous\-programme) et l'ope\*'rande de gauche de l'ope\*'rateur \f(CW\*(C`=>\*(C'\fR, comptent tous les deux comme s'ils e\*'taient entre guillemets\ : .PP .Vb 4 \& Ceci e\*'quivaut a\*` ceci \& \-\-\-\-\-\-\-\-\-\-\-\- \-\-\-\-\-\-\-\-\-\-\-\-\-\-\- \& $foo{line} $foo{'line'} \& bar => stuff 'bar' => stuff .Ve .PP Le point-virgule final dans un bloc est optionnel, tout comme la virgule finale dans une liste. Un bon style (voir perlstyle) pre\*'conise de les mettre sauf dans les expressions d'une seule ligne\ : .PP .Vb 2 \& if ($whoops) { exit 1 } \& @nums = (1, 2, 3); \& \& if ($whoops) { \& exit 1; \& } \& @lines = ( \& "There Beren came from mountains cold", \& "And lost he wandered under leaves", \& ); .Ve .Sh "Comment ignorer certaines valeurs de retour\ ?" .IX Subsection "Comment ignorer certaines valeurs de retour?" Une fac\*,on est de traiter les valeurs de retour comme une liste et de les indexer\ : .PP .Vb 1 \& $dir = (getpwnam($user))[7]; .Ve .PP Une autre fac\*,on est d'utiliser undef comme un e\*'le\*'ment de la partie gauche\ : .PP .Vb 1 \& ($dev, $ino, undef, undef, $uid, $gid) = stat($file); .Ve .PP Vous pouvez aussi utiliser une tranche de liste pour se\*'lectionner uniquement les e\*'le\*'ments ne\*'cessaires\ : .PP .Vb 1 \& ($dev, $ino, $uid, $gid) = ( stat($file) )[0,1,4,5]; .Ve .Sh "Comment bloquer temporairement les avertissements\ ?" .IX Subsection "Comment bloquer temporairement les avertissements?" Si vous utilisez Perl 5.6.0 ou supe\*'rieur, le pragma \f(CW\*(C`use warnings\*(C'\fR vous permet un contro\*^le fin des avertissements qui sont ge\*'ne\*'re\*'s. Voir perllexwarn pour plus de de\*'tails. .PP .Vb 4 \& { \& no warnings; # de\*'sactive temporairement les avertissements \& $a = $b + $c; # je sais qu'elles peuvent e\*^tre inde\*'finies \& } .Ve .PP De plus, vous pouvez activer ou de\*'sactiver les avertissements par cate\*'gories. Vous de\*'sactivez les cate\*'gories que vous sohaitez ignorer tout en conservant les autres cate\*'gories d'avertissements. Voir perllexwarn pour tous les de\*'tails dont les noms des cate\*'gories et leur hie\*'rarchie. .PP .Vb 4 \& { \& no warnings 'uninitialized'; \& $a = $b + $c; \& } .Ve .PP Si vous avez une version plus ancienne de Perl, la variable \f(CW$^W\fR (documente\*'e dans perlvar) contro\*^le les avertissements lors de l'exe\*'cution d'un bloc\ : .PP .Vb 6 \& { \& local $^W = 0; # supprimer temporairement les \& avertissements \& $a = $b + $c; # je sais que ces variables sont \& peut\-e\*^tre inde\*'finies \& } .Ve .PP Notez que comme toutes les variables de ponctuation, vous ne pouvez pas utiliser \fImy()\fR sur \f(CW$^W\fR, uniquement \fIlocal()\fR. .Sh "Qu'est\-ce qu'une extension\ ?" .IX Subsection "Qu'est-ce qu'une extension?" Une extensions est une fac\*,on d'appeler depuis Perl du code C compile\*'. Lire perlxstut est une bonne fac\*,on d'en apprendre plus sur les extensions. .Sh "Pourquoi les ope\*'rateurs de Perl ont-ils une pre\*'ce\*'dence diffe\*'rente de celle des ope\*'rateurs en C\ ?" .IX Subsection "Pourquoi les ope'rateurs de Perl ont-ils une pre'ce'dence diffe'rente de celle des ope'rateurs en C?" En fait, ce n'est pas le cas. Tous les ope\*'rateurs C que Perl copie ont la me\*^me pre\*'ce\*'dence en Perl qu'en C. Le proble\*`me est avec les ope\*'rateurs que C ne posse\*`de pas, en particulier les fonctions qui donnent un contexte de liste a\*` tout ce qui se trouve a\*` leur droite, par exemple print, chmod, exec et ainsi de suite. De telles fonctions sont appele\*'es des \*(L"ope\*'rateurs de liste\*(R" et apparaissent en tant que tels dans la table de pre\*'ce\*'dence de perlop. .PP Une erreur commune est d'e\*'crire\ : .PP .Vb 1 \& unlink $file || die "snafu"; .Ve .PP Qui est interpre\*'te\*' ainsi\ : .PP .Vb 1 \& unlink ($file || die "snafu"); .Ve .PP Pour e\*'viter ce proble\*`me, placez soit des parenthe\*`ses supple\*'mentaires ou utilisez l'ope\*'rateur de pre\*'ce\*'dence super basse \f(CW\*(C`or\*(C'\fR\ : .PP .Vb 2 \& (unlink $file) || die "snafu"; \& unlink $file or die "snafu"; .Ve .PP Les ope\*'rateurs \*(L"anglais\*(R" (\f(CW\*(C`and\*(C'\fR, \f(CW\*(C`or\*(C'\fR, \f(CW\*(C`xor\*(C'\fR, et \f(CW\*(C`not\*(C'\fR) ont une pre\*'ce\*'dence de\*'libe\*'re\*'ment plus basse que celle des ope\*'rateurs de liste juste pour des situations telles que ci\-dessus. .PP Un autre ope\*'rateur ayant une pre\*'ce\*'dence surprenante est l'exponentiation. Il se lie encore plus e\*'troitement que me\*^me le moins unaire, faisant du produit \f(CW\*(C`\-2**2\*(C'\fR un quatre ne\*'gatif et non pas positif. Il s'associe aussi a\*` droite, ce qui signifie que \f(CW\*(C`2**3**2\*(C'\fR vaut deux a\*` la puissance neuvie\*`me, et non pas huit au carre\*'. .PP Bien qu'il ait la me\*^me pre\*'ce\*'dence qu'en C, l'ope\*'rateur \f(CW\*(C`?:\*(C'\fR de Perl produit une lvalue. Ce qui suit affecte \f(CW$x\fR soit a\*` \f(CW$a\fR soit a\*` \f(CW$b\fR, selon la valeur de ve\*'rite\*' de \f(CW$maybe\fR\ : .PP .Vb 1 \& ($maybe ? $a : $b) = $x; .Ve .Sh "Comment de\*'clarer/cre\*'er une structure\ ?" .IX Subsection "Comment de'clarer/cre'er une structure?" En ge\*'ne\*'ral, vous ne \*(L"de\*'clarez\*(R" pas une structure. Utilisez juste une re\*'fe\*'rence de hachage (probablement anonyme). Voir perlref et perldsc pour plus de de\*'tails. Voici un exemple\ : .PP .Vb 3 \& $person = {}; # nouveau hachage anonyme \& $person\->{AGE} = 24; # fixe le champ AGE a\*` 24 \& $person\->{NAME} = "Nat"; # fixe le champ NAME a\*` "Nat" .Ve .PP Si vous recherchez quelque chose d'un peu plus rigoureux, essayez perltoot. .Sh "Comment cre\*'er un module\ ?" .IX Subsection "Comment cre'er un module?" (contribution de brian d foy) .PP perlmod, perlmodlib et perlmodstyle expliquent les modules dans tous leurs de\*'tails. perlnewmod fournit un bref aperc\*,u de la manie\*`re de proce\*'der avec quelques suggestions de style. .PP Si vous avez besoin d'inclure du code C ou une interface vers une bibliothe\*`que C dans votre module, vous aurez besoin de h2xs. h2xs cre\*'era pour vous la structure de distribution de votre module et les fichiers d'interface initiaux dont vous aurez besoin. perlxs et perlxstut donnent tous les de\*'tails. .PP Si vous n'avez pas besoin de code C, d'autres outils comme ExtUtils::ModuleMaker et Module::Starter peuvent vous aider a\*` cre\*'er le squelette de distribution de votre module. .PP Vous pouvez aussi lire \*(L"Writing Perl Modules! for \s-1CPAN\s0\*(R" () par Sam Tregar qui est le meilleur guide pour cre\*'er une distribution de module. .Sh "Comment cre\*'er une classe\ ?" .IX Subsection "Comment cre'er une classe?" Voir perltoot pour une introduction aux classes et aux objets, ainsi que perlobj et perlbot. .Sh "Comment de\*'terminer si une variable est souille\*'e\ ?" .IX Subsection "Comment de'terminer si une variable est souille'e?" Vous pouvez utiliser la fonction \fItainted()\fR du module Scalar::Util disponible sur \s-1CPAN\s0 (et inclus dans la distribution Perl depuis la version 5.8.0). Voir aussi \*(L"Blanchiement et de\*'tection des donne\*'es souille\*'es\*(R" in perlsec. .Sh "Qu'est\-ce qu'une fermeture\ ?" .IX Subsection "Qu'est-ce qu'une fermeture?" Les fermetures sont documente\*'es dans perlref. .PP La \fIFermeture\fR est un terme d'informatique ayant un sens pre\*'cis mais difficile a\*` expliquer. Les fermetures sont imple\*'mente\*'es en Perl par des sous-programmes anonymes ayant des re\*'fe\*'rences a\*` des variables lexicales qui persistent hors de leur propre porte\*'es. Ces lexicaux se re\*'fe\*`rent de fac\*,on magique aux variables qui se trouvaient dans le coin lorsque le sous-programme a e\*'te\*' de\*'fini (deep binding). .PP Les fermetures ont un sens dans tous les langages de programmation ou\*` la valeur de retour d'une fonction peut e\*^tre une fonction, comme c'est le cas en Perl. Notez que certains langages fournissent des fonctions anonymes sans e\*^tre capables de fournir des fermetures proprement dites\ ; le langage Python, par exemple. Pour plus d'informations sur les fermetures, regardez dans un livre sur la programmation fonctionnelle. Scheme est un langage qui non seulement supporte mais aussi encourage les fermetures. .PP Voici une fonction classique de ge\*'ne\*'ration de fonctions\ : .PP .Vb 3 \& sub add_function_generator { \& return sub { shift() + shift() }; \& } \& \& $add_sub = add_function_generator(); \& $sum = $add_sub\->(4,5); # $sum vaut maintenant 9. .Ve .PP La fermeture fonctionne comme un \fImode\*`le de fonction\fR ayant des possibilite\*'s de personnalisation qui seront de\*'finies plus tard. Le sous-programme anonyme retourne\*' par \fIadd_function_generator()\fR n'est pas techniquement une fermeture car il ne se re\*'fe\*`re a\*` aucun lexical hors de sa propre porte\*'e. .PP Comparez cela a\*` la fonction suivante, \fImake_adder()\fR, dans laquelle la fonction anonyme retourne\*'e contient une re\*'fe\*'rence a\*` une variable lexicale se trouvant hors de la porte\*'e de la fonction elle\-me\*^eme. Une telle re\*'fe\*'rence ne\*'cessite que Perl renvoie une fermeture proprement dite, verrouillant ainsi pour toujours la valeur que le lexical avait lorsque la fonction fut cre\*'e\*'. .PP .Vb 4 \& sub make_adder { \& my $addpiece = shift; \& return sub { shift() + $addpiece }; \& } \& \& $f1 = make_adder(20); \& $f2 = make_adder(555); .Ve .PP Maintenant \f(CW\*(C`&$f1($n)\*(C'\fR vaut toujours 20 plus la valeur de \f(CW$n\fR que vous lui passez, tandis que \f(CW\*(C`&$f2($n)\*(C'\fR vaut toujours 555 plus ce qui se trouve dans \f(CW$n\fR. La variable \f(CW$addpiece\fR dans la fermeture persiste. .PP Les fermetures sont souvent utilise\*'es pour des motifs moins e\*'sote\*'riques. Par exemple, lorsque vous de\*'sirez passer un morceau de code a\*` une fonction\ : .PP .Vb 2 \& my $line; \& timeout( 30, sub { $line = } ); .Ve .PP Si le code a\*` exe\*'cuter a e\*'te\*' passe\*' en tant que chai\*^ne, \f(CW'$line = '\fR, la fonction hypothe\*'tique \fItimeout()\fR n'aurait aucun moyen d'acce\*'der a\*` la variable lexicale \f(CW$line\fR dans la porte\*'e de son appelant. .Sh "Qu'est\-ce que le suicide de variable et comment le pre\*'venir\ ?" .IX Subsection "Qu'est-ce que le suicide de variable et comment le pre'venir?" Ce proble\*`me a e\*'te\*' corrige\*' dans perl 5.004_05. Donc la pre\*'vention passe par la mise a\*` jour de perl. ;) .PP Le suicide de variable se produit lorsque vous perdez la valeur d'une variable (temporairement ou de fac\*,on permanente). Il est cause\*' par les interactions entre la porte\*'e de\*'finie par \fImy()\fR et \fIlocal()\fR et soit des fermetures soit des variables d'ite\*'ration \fIforeach()\fR aliase\*'es et des arguments de sous-programme (Note au relecteur\ : un peu borde\*'lique, cette phrase). Il a e\*'te\*' facile de perdre par inadvertance la valeur d'une variable de cette fac\*,on, mais de\*'sormais c'est bien plus difficile. Conside\*'rez ce code\ : .PP .Vb 6 \& my $f = 'foo'; \& sub T { \& while ($i++ < 3) { my $f = $f; $f .= $i; print $f, "\en" } \& } \& T; \& print "Finally $f\en"; .Ve .PP Si vous constatez un suicide de variable, c'est que \f(CW\*(C`my $f\*(C'\fR dans le sous-programme ne re\*'cupe\*`re pas une nouvelle copie de \f(CW$f\fR dont la valeur est \f(CW\*(C`foo\*(C'\fR. La sortie suivante montre qu'a\*` l'inte\*'rieur du sous-programme la valeur de \f(CW$f\fR est perdue alors qu'elle ne devrait pas : .PP .Vb 4 \& foobar \& foobarbar \& foobarbarbar \& Finally foo .Ve .PP Le \f(CW$f\fR qui se voit ajouter \*(L"bar\*(R" par trois fois devrait e\*^tre un nouveau \&\f(CW$f\fR. \f(CW\*(C`my $f\*(C'\fR devrait cre\*'er une nouvelle variable locale chaque fois que la boucle est parcourue. La sortie normale est : .PP .Vb 4 \& foobar \& foobar \& foobar \& Finally foo .Ve .Sh "Comment passer/renvoyer {une fonction, un handle de fichier, un tableau, un hachage, une me\*'thode, une expression rationnelle}\ ?" .IX Subsection "Comment passer/renvoyer {une fonction, un handle de fichier, un tableau, un hachage, une me'thode, une expression rationnelle}?" A\*` l'exception des expressions rationnelles, vous devez passer des re\*'fe\*'rences a\*` ces objets. Voir \*(L"Passage par Re\*'fe\*'rence\*(R" in perlsub pour cette question particulie\*`re, et perlref pour plus d'informations sur les re\*'fe\*'rences. .PP Voir \*(L"Passer des expressions rationnelles\*(R", plus bas, pour le passage des expressions rationnelles. .IP "Passer des variables et des fonctions" 4 .IX Item "Passer des variables et des fonctions" Les variables normales et les fonctions sont faciles a\*` passer\ : passez juste une re\*'fe\*'rence a\*` une variable ou une fonction, existante ou anonyme\ : .Sp .Vb 1 \& func( \e$some_scalar ); \& \& func( \e@some_array ); \& func( [ 1 .. 10 ] ); \& \& func( \e%some_hash ); \& func( { this => 10, that => 20 } ); \& \& func( \e&some_func ); \& func( sub { $_[0] ** $_[1] } ); .Ve .IP "Passer des handles de fichiers" 4 .IX Item "Passer des handles de fichiers" Depuis Perl 5.6, vous pouvez repre\*'senter les handles de fichiers par de simples variables scalaires qui se traitent donc comme tous les autres scalaires. .Sp .Vb 2 \& open my $fh, $filename or die "Cannot open $filename! $!"; \& func( $fh ); \& \& sub func { \& my $passed_fh = shift; \& \& my $line = <$passed_fh>; \& } .Ve .Sp Avant Perl 5.6, vous devez utiliser les notations \f(CW*FH\fR ou \&\f(CW\*(C`\e*FH\*(C'\fR. Ce sont des \*(L"typeglobs\*(R" \- voir \*(L"Typeglobs et handles de fichiers\*(R" in perldata et en particulier \*(L"Passage par re\*'fe\*'rence\*(R" in perlsub pour plus d'information. .IP "Passer des expressions rationnelles" 4 .IX Item "Passer des expressions rationnelles" Pour passer des expressions rationnelles, vous devrez utiliser une version de Perl suffisamment re\*'cente pour supporter la construction \&\f(CW\*(C`qr//\*(C'\fR, passer des chai\*^nes et utiliser un eval capturant les exceptions, soit encore vous montrer tre\*`s tre\*`s intelligent. .Sp Voici un exemple montrant comment passer une chai\*^ne devant e\*^tre compare\*'e comme expression rationnelle\ : .Sp .Vb 6 \& sub compare($$) { \& my ($val1, $regex) = @_; \& my $retval = $val1 =~ /$regex/; \& return $retval; \& } \& $match = compare("old McDonald", qr/d.*D/i); .Ve .Sp Notez comment \f(CW\*(C`qr//\*(C'\fR autorise les drapeaux terminaux. Ce motif a e\*'te\*' compile\*' a\*` la compilation, me\*^me s'il n'a e\*'te\*' exe\*'cute\*' que plus tard. La sympathique notation \f(CW\*(C`qr//\*(C'\fR n'a pas e\*'te\*' introduite avant la version 5.005. Auparavant, vous deviez approcher ce proble\*`me bien moins intuitivement. La revoici par exemple si vous n'avez pas \f(CW\*(C`qr//\*(C'\fR\ : .Sp .Vb 6 \& sub compare($$) { \& my ($val1, $regex) = @_; \& my $retval = eval { $val1 =~ /$regex/ }; \& die if $@; \& return $retval; \& } \& \& $match = compare("old McDonald", q/($?i)d.*D/); .Ve .Sp Assurez-vous de ne jamais dire quelque chose comme ceci\ : .Sp .Vb 1 \& return eval "\e$val =~ /$regex/"; # FAUX .Ve .Sp ou quelqu'un pourrait glisser des se\*'quences d'e\*'chappement du shell dans l'expressions rationnelle a\*` cause de la double interpolation de l'eval et de la chai\*^ne doublement mise entre guillemets. Par exemple\ : .Sp .Vb 1 \& $pattern_of_evil = 'danger ${ system("rm \-rf * &") } danger'; \& \& eval "\e$string =~ /$pattern_of_evil/"; .Ve .Sp Ceux qui pre\*'fe\*`rent e\*^tre tre\*`s tre\*`s intelligents peuvent voir le livre O'Reilly \&\fIMastering Regular Expressions\fR, par Jeffrey Friedl. La fonction \&\fIBuild_MatchMany_Function()\fR a\*` la page 273 est particulie\*`rement inte\*'ressante. Une citation comple\*`te de ce livre est donne\*'e dans perlfaq2. .IP "Passer des Me\*'thodes" 4 .IX Item "Passer des Me'thodes" Pour passer une me\*'thode objet a\*` un sous\-programme, vous pouvez faire ceci\ : .Sp .Vb 7 \& call_a_lot(10, $some_obj, "methname") \& sub call_a_lot { \& my ($count, $widget, $trick) = @_; \& for (my $i = 0; $i < $count; $i++) { \& $widget\->$trick(); \& } \& } .Ve .Sp Ou bien vous pouvez utiliser une fermeture pour encapsuler l'objet, son appel de me\*'thode et ses arguments\ : .Sp .Vb 6 \& my $whatnot = sub { $some_obj\->obfuscate(@args) }; \& func($whatnot); \& sub func { \& my $code = shift; \& &$code(); \& } .Ve .Sp Vous pourriez aussi e\*'tudier la me\*'thode \fIcan()\fR de la classe \s-1UNIVERSAL\s0 (qui fait partie de la distribution standard de perl). .Sh "Comment cre\*'er une variable statique\ ?" .IX Subsection "Comment cre'er une variable statique?" (contribution de brian d foy) .PP Perl n'a pas de variable \*(L"statique\*(R" qui ne serait accessible que dans la fonction ou\*` elle serait de\*'clare\*'e. Mais vous pouvez obtenir le me\*^me effet en utilisant des variables lexicales. .PP Vous pouvez simuler une variable statique en utilisant une variable lexicale qui se met hors de porte\*'e. Dans l'exemple ci\-dessous, nous de\*'finissons un sous-programme \f(CW\*(C`compteur\*(C'\fR qui utiliser la variable lexicale \f(CW$compte\fR. Puisque tout cela se fait dans un bloc \s-1BEGIN\s0, non seulement \f(CW$compte\fR est de\*'fini lors de la compilation mais aussi elle se met hors de porte\*'e a\*` la fin du bloc \s-1BEGIN\s0. Le bloc \s-1BEGIN\s0 garantit que le sous-programme et la valeur qu'il utilise sont de\*'finis lors de la compilation et donc le sous-programme est utilisable comme n'importe quel autre sous\-programme, et vous pouvez placer ce bout de code aux me\*^mes endroits qu'un sous-programme classique (en fin de programme par exemple). Le sous-programme \f(CW\*(C`compteur\*(C'\fR conserve une re\*'fe\*'rence a\*` la donne\*'e et c'est le seul moyen que vous avez d'acce\*'der a\*` cette valeur (et a\*` chaque fois que vous le faites, vous incre\*'mentez la valeur). La donne\*'e de\*'finie par \f(CW$compte\fR est donc une donne\*'e prive\*'e de \&\f(CW\*(C`compteur\*(C'\fR. .PP .Vb 4 \& BEGIN { \& my $compte = 1; \& sub compteur { $compte++ } \& } \& \& my $debut = compteur(); \& \& .... # du code qui appelle compteur(); \& \& my $fin = compteur(); .Ve .PP Dans l'exemple pre\*'ce\*'dent, nous avons cre\*'er une variable prive\*'e visible d'une seule fonction. Nous pourrions de\*'finir plusieurs fonctions tant que la variable reste visible et toutes ces fonctions partageraient la me\*^me variable \*(L"prive\*'e\*(R". Ce n'est plus re\*'ellement \*(L"statique\*(R" puisque plusieurs fonctions acce\*`dent a\*` la me\*^me variable. Dans l'exemple suivant, \f(CW\*(C`incremente_compteur\*(C'\fR et \f(CW\*(C`donne_compteur\*(C'\fR partage la variable. La premie\*`re fonction ajoute 1 a\*` la valeur alors que la seconde ne fait que retourner la valeur. Toutes deux peuvent acce\*'der a\*` la valeur et il n'existe pas d'autres moyen de le faire. .PP .Vb 5 \& BEGIN { \& my $compte = 1; \& sub incremente_compteur { $compte++ } \& sub donne_compteur { $compte } \& } .Ve .PP Pour de\*'clarer une variable prive\*'e d'un fichier, vous pouvez encore utiliser une variable lexicale. La porte\*'e d'une variable lexicale se limite a\*` son contenant (un bloc ou un fichier) et donc une variable lexicale de\*'clare\*'e dans un fichier est invisible depuis un autre fichier. .PP Voir \*(L"Variables prive\*'es persistantes\*(R" in perlsub pour plus de de\*'tails. Tout ce qui est pre\*'sente\*' dans perlref concernant les fermetures peut aussi vous aider me\*^me si nous n'utilisons pas de sous-programmes anonymes dans cette re\*'ponse. .Sh "Quelle est la diffe\*'rence entre la porte\*'e dynamique et lexicale (statique)\ ? Entre \fIlocal()\fP et \fImy()\fP\ ?" .IX Subsection "Quelle est la diffe'rence entre la porte'e dynamique et lexicale (statique)? Entre local() et my()?" \&\f(CW\*(C`local($x)\*(C'\fR sauvegarde l'ancienne valeur de la variable globale \f(CW$x\fR et lui affecte une nouvelle valeur pour la dure\*'e du sous\-programme, \&\fIvaleur qui est visible dans les autres fonctions appele\*'es depuis ce sous-programme\fR. C'est fait lors de l'exe\*'cution et donc cela s'appelle une porte\*'e dynamique. \fIlocal()\fR affecte toujours les variables globales, aussi appele\*'es variables de paquetage ou variables dynamiques. .PP \&\f(CW\*(C`my($x)\*(C'\fR cre\*'e une nouvelle variable qui n'est visible que dans le sous\-programme. C'est fait lors de la compilation et donc cela s'appelle une porte\*'e lexicale ou statique. \fImy()\fR affecte toujours les variables prive\*'es, aussi appele\*'es variables lexicales ou (de fac\*,on impropre) variables (de porte\*'e) statique. .PP Par exemple\ : .PP .Vb 3 \& sub visible { \& print "var has value $var\en"; \& } \& \& sub dynamic { \& local $var = 'local'; # nouvelle valeur temporaire pour la \& visible(); # variable toujours globale appele\*'e $var \& } \& \& sub lexical { \& my $var = 'private'; # nouvelle variable prive\*'e, $var \& visible(); # (invisible hors de la porte\*'e de la routine) \& } \& \& $var = 'global'; \& \& visible(); # affiche global \& dynamic(); # affiche local \& lexical(); # affiche global .Ve .PP Notez que, comme a\*` aucun moment la valeur \*(L"private\*(R" n'est affiche\*'e. C'est parce que \f(CW$var\fR n'a cette valeur qu'a\*` l'inte\*'rieur du bloc de la fonction \fIlexical()\fR, et est cache\*'e des sous-programmes appele\*'s. .PP En re\*'sume\*', \fIlocal()\fR ne cre\*'e pas comme vous pourriez le penser des variables locales, prive\*'es. Il donne seulement a\*` une variable globale une valeur temporaire. \fImy()\fR est ce que vous recherchez si vous voulez des variables prive\*'es. .PP Voir \*(L"Variables prive\*'es via \fImy()\fR\*(R" in perlsub et \*(L"Valeurs temporaires via \fIlocal()\fR\*(R" in perlsub pour plus de de\*'tails. .Sh "Comment puis-je acce\*'der a\*` une variable dynamique lorsqu'un lexical de me\*^me nom est a\*` porte\*'e\ ?" .IX Subsection "Comment puis-je acce'der a` une variable dynamique lorsqu'un lexical de me^me nom est a` porte'e?" Si vous connaissez le nom du paquetage, vous pouvez tout simplement le mentionner explicitement comme dans \f(CW$Un_paquetage::var\fR. Notez que la notation \f(CW$::var\fR ne signifie \fBpas\fR la variable dynamique \f(CW$var\fR du paquetage courant mais celle du paquetage \*(L"main\*(R" exactement comme si vous aviez e\*'crit \f(CW$main::var\fR. .PP .Vb 3 \& use vars '$var'; \& local $var = "global"; \& my $var = "lexical"; \& \& print "lexical is $var\en"; \& print "global is $main::var\en"; .Ve .PP Vous pouvez aussi utiliser la directive \fIour()\fR du compilateur pour amener un vars dynamique a\*` porte\*'e. .PP .Vb 2 \& require 5.006; # our() n'existait avant 5.6 \& use vars '$var'; \& \& local $var = "global"; \& my $var = "lexical"; \& \& print "lexical is $var\en"; \& \& { \& our $var; \& print "global is $var\en"; \& } .Ve .Sh "Quelle est la diffe\*'rence entre les liaisons profondes et superficielles\ ?" .IX Subsection "Quelle est la diffe'rence entre les liaisons profondes et superficielles?" Dans la liaison profonde, les variables lexicales mentionne\*'es dans les sous-programmes anonymes sont les me\*^mes que celles qui e\*'taient dans la porte\*'e lorsque le sous-programme fut cre\*'e\*'. Dans la liaison superficielle, ce sont les variables, quelles qu'elles soient, ayant le me\*^me nom et s'e\*'tant trouve\*' dans la porte\*'e lorsque le sous-programme est appele\*'. Perl utilise toujours la liaison profonde des variables lexicales (i.e., celles cre\*'e\*'es avec \fImy()\fR). Toutefois, les variables dynamiques (aussi appele\*'es globales, locales ou variables de paquetage) sont effectivement lie\*'es superficiellement. Conside\*'rez ceci comme simplement une raison de plus de ne pas les utiliser. Voir la re\*'ponse a\*` \*(L"Qu'est\-ce qu'une fermeture\ ?\*(R". .ie n .Sh "Pourquoi ""my($foo) = <\s-1FICHIER\s0>;"" ne marche pas\ ?" .el .Sh "Pourquoi ``my($foo) = <\s-1FICHIER\s0>;'' ne marche pas\ ?" .IX Subsection "Pourquoi my($foo) = ; ne marche pas?" \&\f(CW\*(C`my()\*(C'\fR et \f(CW\*(C`local()\*(C'\fR donnent un contexte de liste a\*` la partie droite de \f(CW\*(C`=\*(C'\fR. L'ope\*'ration de lecture <\s-1FH\s0>, comme tant d'autres fonctions et ope\*'rateurs de Perl, peut de\*'terminer dans quel contexte elle a e\*'te\*' appele\*'e pour se comporter de fac\*,on approprie\*'e. En ge\*'ne\*'ral, la fonction \&\fIscalar()\fR peut aider. Cette fonction ne fait rien aux donne\*'es elles\-me\*^mes (contrairement au mythe populaire) mais dit seulement a\*` ses arguments de se comporter a\*` sa propre manie\*`re scalaire. Si cette fonction n'a pas de comportement scalaire de\*'fini, ceci ne vous aidera visiblement pas (tout comme avec \fIsort()\fR). .PP Pour forcer un contexte scalaire dans ce cas particulier, toutefois, vous devez tout simplement omettre les parenthe\*`ses\ : .PP .Vb 3 \& local($foo) = ; # FAUX \& local($foo) = scalar(); # ok \& local $foo = ; # bien .Ve .PP Vous devriez probablement utiliser des variables lexicales de toute fac\*,on, me\*^me si le re\*'sultat est le me\*^me ici\ : .PP .Vb 2 \& my($foo) = ; # FAUX \& my $foo = ; # bien .Ve .Sh "Comment rede\*'finir une fonction, un ope\*'rateur ou une me\*'thode pre\*'de\*'fini\ ?" .IX Subsection "Comment rede'finir une fonction, un ope'rateur ou une me'thode pre'de'fini?" Pourquoi donc voulez-vous faire cela\ ? .PP Si vous voulez surcharger une fonction pre\*'de\*'finie, telle qu'\fIopen()\fR, alors vous devrez importer la nouvelle de\*'finition depuis un module diffe\*'rent. Voir \*(L"Surcharge des Fonctions Pre\*'de\*'finies\*(R" in perlsub. Il y a aussi un exemple dans \*(L"Class::Template\*(R" in perltoot. .PP Si vous voulez surcharger un ope\*'rateur de Perl, tel que \f(CW\*(C`+\*(C'\fR ou \f(CW\*(C`**\*(C'\fR, alors vous voudrez utiliser le pragma \f(CW\*(C`use overload\*(C'\fR, documente\*'e dans overload. .PP Si vous parlez d'obscurcir les appels de me\*'thode dans les classes parent, voyez \*(L"Polymorphisme\*(R" in perltoot. .Sh "Quelle est la diffe\*'rence entre l'appel d'une fonction par &foo et par \fIfoo()\fP\ ?" .IX Subsection "Quelle est la diffe'rence entre l'appel d'une fonction par &foo et par foo()?" Quand vous appelez une fonction par \f(CW&foo\fR, vous permettez a\*` cette fonction d'acce\*'der a\*` vos valeurs \f(CW@_\fR courantes, et vous court-circuitez les prototypes. Cela signifie que la fonction ne re\*'cupe\*`re pas un \f(CW@_\fR vide, mais le vo\*^tre\ ! Me\*^me si l'on ne peut pas exactement parler d'un bug (c'est documente\*' de cette fac\*,on dans perlsub), il serait difficile de conside\*'rer cela comme une caracte\*'ristique dans la plupart des cas. .PP Quand vous appelez votre fonction par \f(CW\*(C`&foo()\*(C'\fR, alors vous obtenez \&\fIeffectivement\fR une nouvelle \f(CW@_\fR, mais le prototypage est toujours court\-circuite\*'. .PP Normalement, vous pre\*'fe\*'rerez appeler une fonction en utilisant \&\f(CW\*(C`foo()\*(C'\fR. Vous ne pouvez omettre les parenthe\*`ses que si la fonction est de\*'ja\*` connue par le compilateur parce qu'il a de\*'ja\*` vu sa de\*'finition (\f(CW\*(C`use\*(C'\fR mais pas \f(CW\*(C`require\*(C'\fR), ou via une re\*'fe\*'rence en avant ou une de\*'claration \f(CW\*(C`use subs\*(C'\fR. Me\*^me dans ce cas, vous obtenez une \f(CW@_\fR propre sans aucune des vieilles valeurs suintant la\*` ou\*` elles ne devraient pas. .Sh "Comment cre\*'er une instruction switch ou case\ ?" .IX Subsection "Comment cre'er une instruction switch ou case?" C'est explique\*' plus en profondeur dans perlsyn. En bref, il n'existe pas d'instruction case officielle, a\*` cause de la varie\*'te\*' des tests possibles en Perl (comparaison nume\*'rique, comparaison de chai\*^nes, comparaison de glob, appariement d'expression rationnelle, comparaisons surcharge\*'es...). Larry ne pouvait pas se de\*'cider sur la meilleure fac\*,on de faire cela, il a donc laisse\*' tomber et c'est reste\*' sur la liste des voeux pieux depuis perl1. .PP Depuis Perl 5.8, pour avoir les instruction switch et case, vous pouvez utiliser le module Switch en disant\ : .PP .Vb 1 \& use Switch; .Ve .PP Ce n'est pas aussi rapide que cela pourrait l'e\*^tre puisque ce n'est pas vraiment inte\*'gre\*' au langage (c'est fait par du filtrage des sources) mais c\*,a existe et c'est pratique. .PP Si vous pre\*'fe\*'rez utiliser du Perl pur, la re\*'ponse ge\*'ne\*'rale est d'e\*'crire une construction comme celle-ci\ : .PP .Vb 6 \& for ($variable_to_test) { \& if (/pat1/) { } # faire quelque chose \& elsif (/pat2/) { } # faire quelque chose d'autre \& elsif (/pat3/) { } # faire quelque chose d'autre \& else { } # de\*'faut \& } .Ve .PP Voici un exemple simple de switch base\*' sur un appariement de motif, cette fois mis en page de fac\*,on a\*` le faire ressembler un peu plus a\*` une instruction switch. Nous allons cre\*'er un choix multiple base\*' sur le type de re\*'fe\*'rence stocke\*'e dans \f(CW$whatchamacallit\fR\ : .PP .Vb 1 \& SWITCH: for (ref $whatchamacallit) { \& \& /^$/ && die "not a reference"; \& \& /SCALAR/ && do { \& print_scalar($$ref); \& last SWITCH; \& }; \& \& /ARRAY/ && do { \& print_array(@$ref); \& last SWITCH; \& }; \& \& /HASH/ && do { \& print_hash(%$ref); \& last SWITCH; \& }; \& \& /CODE/ && do { \& warn "can't print function ref"; \& last SWITCH; \& }; \& \& # DEFAULT \& \& warn "User defined type skipped"; \& \& } .Ve .PP Voir \f(CW\*(C`perlsyn/"BLOCs de base et instruction switch"\*(C'\fR pour d'autres exemples dans ce style. .PP Vous devrez parfois e\*'changer les positions de la constante et de la variable. Par exemple, disons que vous voulez tester une re\*'ponse parmi de nombreuses vous ayant e\*'te\*' donne\*'es, mais d'une fac\*,on insensible a\*` la casse qui permette aussi les abre\*'viations. Vous pouvez utiliser la technique suivante si les chai\*^nes commencent toutes par des caracte\*`res diffe\*'rents ou si vous de\*'sirez arranger les correspondances de fac\*,on que l'une ait la pre\*'ce\*'dence sur une autre, tout comme \f(CW"SEND"\fR a la pre\*'ce\*'dence sur \f(CW"STOP"\fR ici\ : .PP .Vb 6 \& chomp($answer = <>); \& if ("SEND" =~ /^\eQ$answer/i) { print "Action is send\en" } \& elsif ("STOP" =~ /^\eQ$answer/i) { print "Action is stop\en" } \& elsif ("ABORT" =~ /^\eQ$answer/i) { print "Action is abort\en" } \& elsif ("LIST" =~ /^\eQ$answer/i) { print "Action is list\en" } \& elsif ("EDIT" =~ /^\eQ$answer/i) { print "Action is edit\en" } .Ve .PP Une approche totalement diffe\*'rente est de cre\*'er une re\*'fe\*'rence de hachage ou de fonction. .PP .Vb 6 \& my %commands = ( \& "happy" => \e&joy, \& "sad", => \e&sullen, \& "done" => sub { die "See ya!" }, \& "mad" => \e&angry, \& ); \& \& print "How are you? "; \& chomp($string = ); \& if ($commands{$string}) { \& $commands{$string}\->(); \& } else { \& print "No such command: $string\en"; \& } .Ve .Sh "Comment intercepter les acce\*`s aux variables, aux fonctions, aux me\*'thodes inde\*'finies\ ?" .IX Subsection "Comment intercepter les acce`s aux variables, aux fonctions, aux me'thodes inde'finies?" La me\*'thode \s-1AUTOLOAD\s0, dont il est question dans \&\*(L"Autochargement\*(R" in perlsub et \*(L"\s-1AUTOLOAD\s0\ : les me\*'thodes mandataires\*(R" in perltoot, vous permet de capturer les appels aux fonctions et aux me\*'thodes inde\*'finies. .PP Quant aux variables inde\*'finies qui provoqueraient un avertissement si \&\f(CW\*(C`use warnings\*(C'\fR est actif, il vous suffit de transformer l'avertissement en erreur. .PP .Vb 1 \& use warnings FATAL => qw(uninitialized); .Ve .Sh "Pourquoi une me\*'thode incluse dans ce me\*^me fichier ne peut-elle pas e\*^tre trouve\*'e\ ?" .IX Subsection "Pourquoi une me'thode incluse dans ce me^me fichier ne peut-elle pas e^tre trouve'e?" Quelques raisons possibles\ : votre he\*'ritage se trouble, vous avez fait une faute de frappe dans le nom de la me\*'thode, ou l'objet est d'un mauvais type. Regardez dans perltoot pour des de\*'tails la\*`\-dessus. Vous pourriez aussi utiliser \f(CW\*(C`print ref($object)\*(C'\fR pour de\*'terminer par quelle classe \f(CW$object\fR a e\*'te\*' consacre\*'. .PP Une autre raison possible de proble\*`mes est que vous avez utilise\*' la syntaxe d'objet indirect (eg, \f(CW\*(C`find Guru "Samy"\*(C'\fR) sur le nom d'une classe avant que Perl n'ait vu qu'un tel paquetage existe. Il est plus sage de s'assurer que vos paquetages sont tous de\*'finis avant de commencer a\*` les utiliser, ce qui sera fait si vous utilisez l'instruction \f(CW\*(C`use\*(C'\fR au lieu de \f(CW\*(C`require\*(C'\fR. Sinon, assurez-vous d'utiliser la notation fle\*'che\*'e a\*` la place (eg, \&\f(CW\*(C`Guru\->find("Samy")\*(C'\fR). La notation d'objet est explique\*'e dans perlobj. .PP Assurez-vous de vous renseigner sur la cre\*'ation des modules en lisant perlmod et les pe\*'rils des objets indirects dans \*(L"Appel de me\*'thodes\*(R" in perlobj. .Sh "Comment de\*'terminer mon paquetage courant\ ?" .IX Subsection "Comment de'terminer mon paquetage courant?" Si vous e\*^tes juste un programme pris au hasard, vous pouvez faire ceci pour de\*'couvrir quel est le paquetage compile\*' sur le moment\ : .PP .Vb 1 \& my $packname = _\|_PACKAGE_\|_; .Ve .PP Mais si vous e\*^tes une me\*'thode et que vous voulez afficher un message d'erreur qui inclut le genre d'objet sur lequel vous avez e\*'te\*' appele\*'e (qui n'est pas ne\*'cessairement le me\*^me que celui dans lequel vous avez e\*'te\*' compile\*'e)\ : .PP .Vb 5 \& sub amethod { \& my $self = shift; \& my $class = ref($self) || $self; \& warn "called me from a $class object"; \& } .Ve .Sh "Comment commenter un grand bloc de code perl\ ?" .IX Subsection "Comment commenter un grand bloc de code perl?" Vous pouvez utiliser \s-1POD\s0 pour le de\*'sactiver. Entourer le bloc a\*` commenter de marqueurs \s-1POD\s0. La directive \f(CW\*(C`=begin\*(C'\fR marque le de\*'but d'une section pour un formateur particulier. Utilisez le format \&\f(CW\*(C`comment\*(C'\fR, qu'aucun formateur ne risque de comprendre (par convention). Marquer la fin du bloc par \f(CW\*(C`=end\*(C'\fR. .PP .Vb 1 \& # le programme est ici \& \& =begin comment \& \& tout ce truc \& \& ici sera ignore\*' \& par tout le monde \& \& =end commentaire \& \& =cut \& \& # le programme continue .Ve .PP Les directives \s-1POD\s0 ne se placent pas n'importe ou\*`. Vous devez mettre une directive \s-1POD\s0 la\*` ou\*` l'analyseur syntaxique attend une nouvelle instruction, pas juste au milieu d'une expression ou d'un autre e\*'le\*'ment grammaticale quelconque. .PP Voir perlpod pour plus de de\*'tails. .Sh "Comment supprimer un paquetage\ ?" .IX Subsection "Comment supprimer un paquetage?" Utilisez ce code, fourni par Mark-Jason Dominus: .PP .Vb 10 \& sub scrub_package { \& no strict 'refs'; \& my $pack = shift; \& die "Shouldn't delete main package" \& if $pack eq "" || $pack eq "main"; \& my $stash = *{$pack . '::'}{HASH}; \& my $name; \& foreach $name (keys %$stash) { \& my $fullname = $pack . '::' . $name; \& # Get rid of everything with that name. \& undef $$fullname; \& undef @$fullname; \& undef %$fullname; \& undef &$fullname; \& undef *$fullname; \& } \& } .Ve .PP Ou, si vous utilisez une version re\*'cente de Perl, vous pouvez juste utiliser a\*` la place la fonction \fISymbol::delete_package()\fR. .Sh "Comment utiliser une variable comme nom de variable\ ?" .IX Subsection "Comment utiliser une variable comme nom de variable?" Les de\*'butants pensent souvent qu'ils veulent qu'une variable contienne le nom d'une variable. .PP .Vb 3 \& $fred = 23; \& $varname = "fred"; \& ++$$varname; # $fred vaut maintenant 24 .Ve .PP Ceci marche \fIparfois\fR, mais c'est une tre\*`s mauvaise ide\*'e pour deux raisons. .PP La premie\*`re raison est que cela \fIne marche que pour les variables globales\fR. Cela signifie que si \f(CW$fred\fR e\*'tait une variable lexicale cre\*'e\*'e avec \fImy()\fR dans le code ci\-dessus, alors le code ne marcherait pas du tout\ : vous acce\*'deriez accidentellement a\*` la variable globale et passeriez comple\*`tement par-dessus le lexical prive\*'. Les variables globales sont mauvaises car elles peuvent facilement entrer en collision accidentellement et produisent en ge\*'ne\*'ral un code non-extensible et confus. .PP Les re\*'fe\*'rences symboliques sont interdites sous le pragma \f(CW\*(C`use strict\*(C'\fR. Ce ne sont pas de vraies re\*'fe\*'rences et par conse\*'quent elles ne sont pas compte\*'es dans les re\*'fe\*'rences ni traite\*'es par le ramasse\-miettes. .PP La seconde raison qui rend mauvaise l'utilisation d'une variable pour contenir le nom d'une autre variable est que, souvent, le besoin provient d'un manque de compre\*'hension des structures de donne\*'es de Perl, en particulier des hachages. En utilisant des re\*'fe\*'rences symboliques, vous utilisez juste le hachage de la table de symboles du paquetage (comme \f(CW%main::\fR) a\*` la place d'un hachage de\*'fini par l'utilisateur. La solution est d'utiliser a\*` la place votre propre hachage ou une vraie re\*'fe\*'rence. .PP .Vb 3 \& $USER_VARS{"fred"} = 23; \& $varname = "fred"; \& $USER_VARS{$varname}++; # ce n'est pas $$varname++ .Ve .PP Ici nous utilisons le hachage \f(CW%USER_VARS\fR a\*` la place de re\*'fe\*'rences symboliques. Parfois, cela est ne\*'cessaire quand on lit des chai\*^nes aupre\*`s de l'utilisateur avec des re\*'fe\*'rences de variable et qu'on veut les e\*'tendre aux valeurs des variables du programme perl. C'est aussi une mauvaise ide\*'e car cela fait entrer en conflit l'espace de noms adressable par le programme et celui adressable par l'utilisateur. Au lieu de lire une chai\*^ne et de la de\*'velopper pour obtenir le contenu des variables de votre programme\ : .PP .Vb 2 \& $str = 'this has a $fred and $barney in it'; \& $str =~ s/(\e$\ew+)/$1/eeg; # besoin d'un double eval .Ve .PP Il serait meilleur de conserver un hachage comme \f(CW%USER_VARS\fR et d'avoir des re\*'fe\*'rences de variable pointant effectivement vers des entre\*'es de ce hachage\ : .PP .Vb 1 \& $str =~ s/\e$(\ew+)/$USER_VARS{$1}/g; # pas de /e du tout ici .Ve .PP C'est plus rapide, plus propre, et plus su\*^r que l'approche pre\*'ce\*'dente. Bien su\*^r, vous n'avez pas besoin d'utiliser un dollar. Vous pourriez utiliser votre propre caracte\*`re pour rendre le tout moins confus, comme des symboles de pourcents, etc. .PP .Vb 2 \& $str = 'this has a %fred% and %barney% in it'; \& $str =~ s/%(\ew+)%/$USER_VARS{$1}/g; # pas de /e du tout ici .Ve .PP Une autre raison qui ame\*`ne les gens a\*` croire qu'ils ont besoin qu'une variable contienne le nom d'une autre variable est qu'ils ne savent pas comment construire des structures de donne\*'es correctes en utilisant des hachages. Par exemple, supposons qu'ils aient voulu deux hachages dans leur programme\ : \f(CW%fred\fR et \f(CW%barney\fR, et veuillent utiliser une autre variable scalaire pour s'y re\*'fe\*'rer par leurs noms. .PP .Vb 2 \& $name = "fred"; \& $$name{WIFE} = "wilma"; # de\*'finit %fred \& \& $name = "barney"; \& $$name{WIFE} = "betty"; # de\*'finit %barney .Ve .PP C'est toujours une re\*'fe\*'rence symbolique, avec toujours les proble\*`mes e\*'nume\*'re\*'s ci-dessus sur les bras. Il serait bien meilleur d'e\*'crire\ : .PP .Vb 2 \& $folks{"fred"}{WIFE} = "wilma"; \& $folks{"barney"}{WIFE} = "betty"; .Ve .PP Et de simplement utiliser un hachage multiniveau pour commencer. .PP La seule occasion ou\*` vous \fIdevez\fR absolument utiliser des re\*'fe\*'rences symboliques est lorsque vous devez re\*'ellement vous re\*'fe\*'rer a\*` la table de symboles. Cela peut se produire parce qu'il s'agit de quelque chose dont on ne peut pas prendre une vraie re\*'fe\*'rence, tel qu'un nom de format. Faire cela peut aussi e\*^tre important pour les appels de me\*'thodes, puisqu'ils passent toujours par la table de symboles pour leur re\*'solution. .PP Dans ces cas, vous devrez supprimer temporairement les \f(CW\*(C`strict \&'refs'\*(C'\fR de fac\*,on a\*` pouvoir jouer avec la table de symboles. Par exemple\ : .PP .Vb 5 \& @colors = qw(red blue green yellow orange purple violet); \& for my $name (@colors) { \& no strict 'refs'; # renege for the block \& *$name = sub { "@_" }; \& } .Ve .PP Toutes ces fonctions (\fIred()\fR, \fIblue()\fR, \fIgreen()\fR, etc.) apparaissent comme diffe\*'rentes, mais le vrai code dans la fermeture n'a effectivement e\*'te\*' compile\*' qu'une fois. .PP Vous voudrez donc parfois utiliser les re\*'fe\*'rences symboliques pour manipuler directement la table de symboles. Cela n'a pas d'importance pour les formats, les handles, et les sous\-programmes, car ils sont toujours globaux \*(-- vous ne pouvez pas utiliser \fImy()\fR sur eux. Mais pour les scalaires, les tableaux et les hachages \*(-- et habituellement pour les sous-programmes \*(-- vous pre\*'fe\*'rerez probablement n'utiliser que de vraies re\*'fe\*'rences (les re\*'fe\*'rences dures). .ie n .Sh "Que signifie ""bad interpreter""\ ?" .el .Sh "Que signifie ``bad interpreter''\ ?" .IX Subsection "Que signifie bad interpreter?" (contribution de brian d foy) .PP Le message \*(L"bad interpreter\*(R" provient du shel et non de perl. Le message exact de\*'pend de votre pleteforme, du shell utilise\*' et de re\*`glage des locale. .PP Si vous voyez \*(L"bad interpreter \- no such file or directory\*(R", c'est que la premie\*`re ligne de votre script (la ligne \*(L"shebang\*(R") ne contient pas un chemin correcte vers perl (ou n'import quel programme capable de comprendre le script). Parfois cela arrive lorsque vous passez un script d'une machine a\*` une autre dont le perl est installe\*' diffe\*'rement \&\*(-- /usr/bin/perl au lieu de /usr/local/bin/perl par exemple. Cela peut aussi indiquer que le fichier source contient \s-1CRLF\s0 comme fin de lignes alors que la machine s'attend uniquement a\*` \s-1LF\s0 : le shell cherche /usr/bin/perl<\s-1CR\s0> qu'il ne trouve e\*'videmment pas. .PP Si vous voyez \*(L"bad interpreter: permission denied\*(R", il vous faut rendre votre script exe\*'cutable. .PP Dans tous les cas, vous devriez pouvoir faire exe\*'cuter explicitement le script par perl\ : .PP .Vb 1 \& % perl script.pl .Ve .PP Si vous obtenez un message du genre \*(L"perl: command not found\*(R", alors perl n'est pas dans votre \s-1PATH\s0 ce qui signifie que perl n'est pas la\*` ou\*` vous l'attendez et qu'il vous faudra corriger la ligne de \&\*(L"shebang\*(R". .SH "AUTEUR ET COPYRIGHT" .IX Header "AUTEUR ET COPYRIGHT" Copyright (c) 1997\-2006 Tom Christiansen, Nathan Torkington et autres auteurs sus\-cite\*'s. Tous droits re\*'serve\*'s. .PP Cette documentation est libre ; vous pouvez la redistribuer et/ou la modifier sous les me\*^mes conditions que Perl lui\-me\*^me. .PP Contrairement a\*` sa distribution, tous les exemples de code de ce fichier sont place\*'s par le pre\*'sent acte dans le domaine public. Vous avez l'autorisation et e\*^tes encourage\*'s a\*` utiliser ce code dans vos propres programmes pour vous amuser ou pour gagner de l'argent selon votre humeur. Un simple commentaire dans le code cre\*'ditant les auteurs serait courtois mais n'est pas requis. .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 "Relecture" .IX Subsection "Relecture" Re\*'gis Julie\*' <\fIRegis.Julie@cetelem.fr\fR>, Ge\*'rard Delafond.