.\" 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 "PERLREF 1"
.TH PERLREF 1 "2006-03-19" "DocFr" "User Contributed Perl Documentation"
.SH "NAME/NOM"
.IX Xref "re\*'fe\*'rence pointeur structure de donne\*'es structure struct"
.IX Header "NAME/NOM"
perlref \- Re\*'fe\*'rences et structures de donne\*'es imbrique\*'es en Perl
.SH "NOTE"
.IX Header "NOTE"
Ce deocument est la documentation comple\*`te abordant tous les aspects
des re\*'fe\*'rences. Pour une introduction n'abordant que les
fonctionnalite\*'s essentielles et donc plus courte et surtout plus
pe\*'dagogique, voir perlreftut.
.SH "DESCRIPTION"
.IX Header "DESCRIPTION"
Avant la version\ 5 de Perl, il e\*'tait difficile de repre\*'senter des
structures de donne\*'es complexes car toutes les re\*'fe\*'rences devaient
e\*^tre symboliques (et me\*^me dans ce cas, il e\*'tait difficile de
re\*'fe\*'rencer une variable a\*` la place d'une entre\*'e symbolique de
tableau). Desormais, non seulement Perl facilite l'utilisation de
re\*'fe\*'rences symboliques a\*` des variables, mais il vous laisse en plus la
possibilite\*' d'avoir des re\*'fe\*'rences \*(L"dures\*(R" a\*` tout morceau de donne\*'es
ou de code. N'importe quel scalaire peut contenir une re\*'fe\*'rence
dure. Comme les tableaux et les tables de hachage contiennent des
scalaires, vous pouvez de\*'sormais construire facilement des tableaux de
tableaux, des tableaux de tables de hachage, des tables de hachage de
tableau, des tableaux de tables de hachage de fonctions, etc.
.PP
Les re\*'fe\*'rences dures sont intelligentes\ : elles conservent la trace
du nombre de re\*'fe\*'rences pour vous, libe\*'rant automatiquement la
structure re\*'fe\*'rence\*'e quand son compteur de re\*'fe\*'rences atteint
ze\*'ro. (Le compteur de re\*'fe\*'rences pour des valeurs dans des structures
de donne\*'es auto\-re\*'fe\*'rence\*'es ou cycliques ne pourra pas atteindre ze\*'ro
sans un petit coup de pouce. Cf. \*(L"Ramasse\-miettes a\*` deux
phases\*(R" in perlobj pour une explication de\*'taille\*'e.) Si cette structure s'ave\*`re
e\*^tre un objet, celui-ci est de\*'truit. Cf. perlobj pour de plus
amples renseignements sur les objets. (Dans un certain sens, tout est
objet en Perl, mais d'habitude nous re\*'servons ce mot pour les
re\*'fe\*'rences a\*` des structures qui ont e\*'te\*' officiellement \*(L"be\*'nies\*(R" dans
un paquetage de classes.
.PP
Les re\*'fe\*'rences symboliques sont des noms de variables ou d'autres
objets, tout comme un lien symbolique dans un syste\*`me de fichiers Unix
ne contient a peu de choses pre\*`s que le nom d'un fichier. La notation
\&\f(CW*glob\fR est un type de re\*'fe\*'rence symbolique. (Les re\*'fe\*'rences
symboliques sont parfois appele\*'es \*(L"re\*'fe\*'rences douces\*(R" mais e\*'vitez de
les appeler ainsi\ ; les re\*'fe\*'rences sont de\*'ja\*` suffisamment confuses
sans ces synonymes inutiles.)
.IX Xref "re\*'fe\*'rence, symbolique symbolique re\*'fe\*'rence re\*'fe\*'rence, douce re\*'fe\*'rence douce"
.PP
Au contraire, les re\*'fe\*'rences dures ressemblent plus aux liens durs
dans un syste\*`me de fichiers Unix\ : elles sont utilise\*'es pour
acce\*'der a\*` un objet sous-jacent sans se pre\*'occuper de son (autre)
nom. Quand le mot \*(L"re\*'fe\*'rence\*(R" est utilise\*' sans adjectif, comme dans le
paragraphe suivant, il est habituellement question d'une re\*'fe\*'rence dure.
.IX Xref "re\*'fe\*'rence, dure re\*'fe\*'rence dure"
.PP
Les re\*'fe\*'rences sont faciles a\*` utiliser en Perl. Il n'existe qu'un
principe majeur\ : Perl ne re\*'fe\*'rence et ne de\*'re\*'fe\*'rence jamais de
fac\*,on implicite. Quand un scalaire contient une re\*'fe\*'rence, il se
comporte toujours comme un simple scalaire. Il ne devient pas
magiquement un tableau, une table de hachage ou une routine. Vous
devez le lui pre\*'ciser explicitement, en le de\*'re\*'fe\*'renc\*,ant.
.Sh "Cre\*'er des re\*'fe\*'rences"
.IX Xref "re\*'fe\*'rence, cre\*'ation cre\*'ation de re\*'fe\*'rence re\*'fe\*'rencement"
.IX Subsection "Cre'er des re'fe'rences"
Les re\*'fe\*'rences peuvent e\*^tre cre\*'e\*'es de plusieurs fac\*,ons.
.IP "1." 4
.IX Xref "\e backslash barre oblique inverse"
.IX Item "1."
En utilisant l'ope\*'rateur \*(L"backslash\*(R" [barre oblique inverse, ndt] sur
une variable, une routine ou une valeur. (Cela fonctionne pluto\*^t comme
l'ope\*'rateur\ & (addresse de), du C.) Notez bien que cela cre\*'er
typiquement une \fI\s-1AUTRE\s0\fR re\*'fe\*'rence a\*` la variable, parce qu'il existe
de\*'ja\*` une telle re\*'fe\*'rence dans la table des symboles. Mais me\*^me si la
re\*'fe\*'rence de la table des symboles disparait, vous aurez toujours la
re\*'fe\*'rence que la backslash a retourne\*'e. Voici quelques exemples\ :
.Sp
.Vb 5
\& $scalarref = \e$foo;
\& $arrayref = \e@ARGV;
\& $hashref = \e%ENV;
\& $coderef = \e&handler;
\& $globref = \e*foo;
.Ve
.Sp
Il est impossible de cre\*'er une ve\*'ritable re\*'fe\*'rence a\*` un descripteur
d'E/S (descripteur de fichier ou de re\*'pertoire) en utilisant
l'ope\*'rateur backslash. Le mieux que vous puissiez obtenir est une
re\*'fe\*'rence a\*` un typeglob, qui est en fait une entre\*'e comple\*`te de la
table des symboles. Voir l'explication de la syntaxe \f(CW*foo{THING}\fR
ci\-dessous. Quoi qu'il en soit, vous pouvez toujours utiliser les
typeglobs et les globrefs comme s'il e\*'taient des descripteur d'E/S.
.IP "2." 4
.IX Xref "tableau anonyme [] crochet re\*'fe\*'rence a\*` un tableau tableau, re\*'fe\*'rence a\*` un"
.IX Item "2."
Une re\*'fe\*'rence a\*` un tableau anonyme peut e\*^tre cre\*'e\*'e en utilisant des
crochets\ :
.Sp
.Vb 1
\& $arrayref = [1, 2, ['a', 'b', 'c']];
.Ve
.Sp
Ici, nous avons cre\*'e\*' une re\*'fe\*'rence a\*` un tableau anonyme de trois
e\*'le\*'ments, dont le dernier est lui\-me\*^me une re\*'fe\*'rence a\*` un autre
tableau anonyme de trois e\*'le\*'ments. (La syntaxe multidimensionnelle
de\*'crite plus loin peut e\*^tre utilise\*'e pour y acce\*'der. Par exemple,
apre\*`s le code ci\-dessus, \f(CW\*(C`$arrayref\->[2][1]\*(C'\fR aura la
valeur \*(L"b\*(R".)
.Sp
Prendre une re\*'fe\*'rence a\*` une liste enume\*'re\*'e n'est pas la me\*^me chose que
d'utiliser des crochets (c'est pluto\*^t la me\*^me chose que cre\*'er une
liste de re\*'fe\*'rences\ !)
.Sp
.Vb 2
\& @list = (\e$a, \e@b, \e%c);
\& @list = \e($a, @b, %c); # identique !
.Ve
.Sp
A\*` l'exception de \f(CW\*(C`\e(@foo)\*(C'\fR qui retourne une liste de re\*'fe\*'rences au
contenu de \f(CW@foo\fR, et non pas une re\*'fe\*'rence a\*` \f(CW@foo\fR lui\-me\*^me. Il
en est de me\*^me pour \f(CW%foo\fR sauf e\*'videmment pour les cle\*'s elle\-me\*^mes
qui seront simplement recopie\*'es (puisque les cle\*'s sont justes des
chai\*^nes de caracte\*`res et non des scalaires au sens large).
.IP "3." 4
.IX Xref "table de hachage anonyme {} accolade re\*'fe\*'rence a\*` une table de hachage table de hachage, re\*'fe\*'rence a\*` une"
.IX Item "3."
Une re\*'fe\*'rence a\*` une table de hachage anonyme peut e\*^tre cre\*'e\*'e en
utilisant des accolades\ :
.Sp
.Vb 4
\& $hashref = {
\& 'Adam' => 'Eve',
\& 'Clyde' => 'Bonnie',
\& };
.Ve
.Sp
Les composants de table de hachage et de tableau comme ceux-ci peuvent
e\*^tre librement me\*'lange\*'s pour produire une structure aussi complexe que
vous le souhaitez. La syntaxe multidimensionnelle de\*'crite ci-dessous
fonctionne pour ces deux cas. Les valeurs ci-dessus sont litte\*'rales
mais des variables et expressions fonctionneraient de la me\*^me manie\*`re,
car l'ope\*'rateur d'affectation en Perl (me\*^me a\*` l'inte\*'rieur d'un
\&\fIlocal()\fR ou d'un \fImy()\fR) sont des
instructions exe\*'cutables et non pas des de\*'clarations a\*` la compilation.
.Sp
Comme les accolades sont utilise\*'es pour bien d'autres choses, y
compris les BLOCs, vous pourriez e\*^tre amene\*' a\*` devoir expliciter les
accolades au de\*'but d'une instruction en ajoutant un \f(CW\*(C`+\*(C'\fR ou un
\&\f(CW\*(C`return\*(C'\fR devant, de telle sorte que Perl comprenne que l'accolade
ouvrante n'est pas le commencement d'un \s-1BLOC\s0. Les e\*'conomies re\*'alise\*'es
et la valeur mne\*'motechnique des accolades valent bien cet
embarrassement supple\*'mentaire.
.Sp
Par exemple, si vous de\*'sirez une fonction qui cre\*'e une nouvelle table
de hachage et retourne une re\*'fe\*'rence a\*` celle\-ci, vous avez ces
possibilite\*'s\ :
.Sp
.Vb 3
\& sub hashem { { @_ } } # silencieusement faux
\& sub hashem { +{ @_ } } # correct
\& sub hashem { return { @_ } } # correct
.Ve
.Sp
D'un autre co\*^te\*', si vous souhaitez l'autre signification, vous pouvez
faire ceci\ :
.Sp
.Vb 4
\& sub showem { { @_ } } # ambigu (correct pour le moment
\& # mais pourrait changer)
\& sub showem { {; @_ } } # correct
\& sub showem { { return @_ } } # correct
.Ve
.Sp
Les \f(CW\*(C`+{\*(C'\fR et \f(CW\*(C`{;\*(C'\fR en de\*'but servent a\*` diffe\*'rencier de manie\*`re
explicite soit une re\*'fe\*'rence a\*` un \s-1TABLE\s0 \s-1DE\s0 \s-1HACHAGE\s0 soit un \s-1BLOC\s0.
.IP "4." 4
.IX Xref "subroutine anonyme sous-programme anonyme re\*'fe\*'rence a\*` un sous-programme sous-programme, re\*'fe\*'rence a\*` un re\*'fe\*'rence a\*` une subroutine subroutine, re\*'fe\*'rence a\*` une porte\*'e lexicale fermeture lexical lexical, porte\*'e"
.IX Item "4."
Une re\*'fe\*'rence a\*` une routine anonyme peut e\*^tre cre\*'e\*'e en utilisant
\&\f(CW\*(C`sub\*(C'\fR sans nom de routine\ :
.Sp
.Vb 1
\& $coderef = sub { print "Boink!\en" };
.Ve
.Sp
Notez la pre\*'sence du point\-virgule. A\*` part le fait que le code a\*`
l'inte\*'rieur n'est pas exe\*'cute\*' imme\*'diatement, un \f(CW\*(C`sub {}\*(C'\fR n'est ni
plus ni moins qu'une de\*'claration comme ope\*'rateur, tout comme \f(CW\*(C`do{}\*(C'\fR
ou \f(CW\*(C`eval{}\*(C'\fR. (Peu importe le nombre de fois que vous allez exe\*'cuter
cette ligne particulie\*`re \*(-- a\*` moins que vous soyez dans un
\&\f(CW\*(C`eval("...")\*(C'\fR \*(-- \f(CW$coderef\fR fera toujours re\*'fe\*'rence a\*` la \fIME\*^ME\fR
routine anonyme.)
.Sp
Les routines anonymes fonctionnent comme les fermetures, en respectant
les variables \fImy()\fR, c'est\-a\*`\-dire les variables lexicalement visibles
dans la porte\*'e actuelle. La fermeture est une notion provenant de
l'univers Lisp qui indique que, si vous de\*'finissez une fonction
anonyme dans un contexte lexical particulier, elle essaiera de
fonctionner dans ce contexte, me\*^me quand elle est appele\*'e en-dehors de
ce contexte.
.Sp
En termes plus humains, c'est une fac\*,on amusante de passer des
arguments a\*` une routine, aussi bien lorsque vous la de\*'finissez que
lorsque vous l'appelez. C'est tre\*`s utile pour mettre au point des
petits morceaux de code a\*` exe\*'cuter plus tard, comme les
callbacks. Vous pouvez me\*^me faire de l'oriente\*' objet avec c\*,a bien que
Perl fournisse de\*'ja\*` un autre me\*'canisme pour le faire (voir
perlobj).
.Sp
Vous pouvez aussi conside\*'rer la fermeture comme une fac\*,on d'e\*'crire un
mode\*`le de routine sans utiliser \fIeval()\fR. Voici un petit exemple de
fonctionnement des fermetures\ :
.Sp
.Vb 6
\& sub newprint {
\& my $x = shift;
\& return sub { my $y = shift; print "$x, $y !\en"; };
\& }
\& $h = newprint("Bonjour");
\& $g = newprint("Salutations");
\&
\& # Un ange passe...
\&
\& &$h("monde");
\& &$g("humains");
.Ve
.Sp
Ce qui affiche
.Sp
.Vb 2
\& Bonjour, monde !
\& Salutations, humains !
.Ve
.Sp
Notez en particulier que \f(CW$x\fR continue a\*` re\*'fe\*'rencer la valeur passe\*'e a\*`
\&\fInewprint()\fR \fIbien que\fR le \*(L"my \f(CW$x\fR\*(R" semble e\*^tre hors de la porte\*'e au
moment ou\*` la routine anonyme est exe\*'cute\*'e. Voici donc ce qu'est la
fermeture.
.Sp
A\*` propos, ceci ne s'applique qu'aux variables lexicales. Les variables
dynamiques continuent de fonctionner comme elle l'ont toujours
fait. La fermeture n'est pas une chose dont la plupart des
programmeurs Perl ont besoin de s'embarraser pour commencer.
.IP "5." 4
.IX Xref "constructeur new"
.IX Item "5."
Les re\*'fe\*'rences sont souvent retourne\*'es par des routines spe\*'ciales
appele\*'es constructeurs. Les objets Perl sont juste des re\*'fe\*'rences a\*` un
type particulier d'objet qui s'ave\*`re capable de connai\*^tre quel
paquetage y est associe\*'. Les constructeurs sont juste des routines
particulie\*`res qui savent comment cre\*'er cette association. Ils le font
en commenc\*,ant par une re\*'fe\*'rence ordinaire qui reste telle quelle me\*^me
si c'est un objet. Les constructeurs sont souvent nomme\*'s \fInew()\fR et
appele\*'s indirectement\ :
.Sp
.Vb 1
\& $objref = new Doggie (Tail => 'short', Ears => 'long');
.Ve
.Sp
Mais il n'est pas ne\*'cessaire d'avoir\ :
.Sp
.Vb 1
\& $objref = Doggie\->new(Tail => 'short', Ears => 'long');
\&
\& use Term::Cap;
\& $terminal = Term::Cap\->Tgetent( { OSPEED => 9600 });
\&
\& use Tk;
\& $main = MainWindow\->new();
\& $menubar = $main\->Frame(\-relief => "raised",
\& \-borderwidth => 2)
.Ve
.IP "6." 4
.IX Xref "autovivification"
.IX Item "6."
Des re\*'fe\*'rences de type approprie\*' peuvent venir a exister si vous les
de\*'re\*'fe\*'rencez dans un contexte qui suppose qu'elles existent. Comme
nous n'avons pas encore parle\*' du de\*'re\*'fe\*'rencement, nous ne pouvons
toujorus pas vous montrer d'exemples.
.IP "7." 4
.IX Xref "*foo{THING} *"
.IX Item "7."
Une re\*'fe\*'rence peut e\*^tre cre\*'e\*'e en utilisant une syntaxe particulie\*`re,
sentimentalement connue comme la syntaxe *foo{\s-1THING\s0}. *foo{\s-1THING\s0}
retourne une re\*'fe\*'rence a\*` l'emplacement \s-1THING\s0 dans *foo (qui est
l'entre\*'e de la table des symboles contenant tout ce qui est connu en
tant que \*(L"foo\*(R").
.Sp
.Vb 7
\& $scalarref = *foo{SCALAR};
\& $arrayref = *ARGV{ARRAY};
\& $hashref = *ENV{HASH};
\& $coderef = *handler{CODE};
\& $ioref = *STDIN{IO};
\& $globref = *foo{GLOB};
\& $formatref = *foo{FORMAT};
.Ve
.Sp
Tout ceci s'explique de lui\-me\*^me, a\*` part \f(CW*foo{IO}\fR. Il retourne le
descripteur d'E/S utilise\*' pour les descripteurs de fichiers
(\*(L"open\*(R" in perlfunc), de sockets (\*(L"socket\*(R" in perlfunc et
\&\*(L"socketpair\*(R" in perlfunc) et de re\*'pertoires (\*(L"opendir\*(R" in perlfunc). Pour
des raisons de compatibilite\*'s avec les versions pre\*'ce\*'dentes de Perl,
*foo{\s-1FILEHANDLE\s0} est un synonyme de *foo{\s-1IO\s0}. Si les avertissements
sont actifs, l'utilisation de ce synonyme affichera un message.
.Sp
\&\f(CW*foo{TURC}\fR retourne un inde\*'fini si ce \s-1TRUC\s0 particulier n'a pas e\*'te\*'
utilise\*' auparavant, sauf dans le cas des scalaires. *foo{\s-1SCALAR\s0}
retourne une re\*'fe\*'rence a\*` un scalaire anonyme si \f(CW$foo\fR n'a pas encore
e\*'te\*' utilise\*'. Ceci pourrait changer dans une prochaine version.
.Sp
\&\f(CW*foo{IO}\fR est une autre manie\*`re d'acce\*'der au me\*'canisme \e*HANDLE
indique\*' dans \*(L"Typeglobs et Handles de Fichiers\*(R" in perldata pour
passer des descripteurs de fichiers comme arguments ou comme valeur de
retour de routines, ou pour les stocker dans des structures de donne\*'es
plus grandes. L'inconve\*'nient, c'est qu'il ne cre\*'e pas de nouveau
descripteur de fichier pour vous. L'avantage, c'est qu'il y a moins de
risque d'aller au\-dela\*` de ce que vous souhaitez qu'avec une affection
de typeglob (il passe tout de me\*^me les descripteurs de fichier et de
re\*'pertoire). Ceci e\*'tant, si vous l'affectez a\*` un scalaire au lieu d'un
typeglob comme dans l'exemple ci\-dessous, vous e\*^tes couvert dans tous
les cas.
.Sp
.Vb 3
\& splutter(*STDOUT); # passe tout le glob
\& splutter(*STDOUT{IO}); # ne passe que le descripteur
\& # de fichier et de re\*'pertoire
\&
\& sub splutter {
\& my $fh = shift;
\& print $fh "her um well a hmmm\en";
\& }
\&
\& $rec = get_rec(*STDIN); # passe tout le glob
\& $rec = get_rec(*STDIN{IO}); # ne passe que le descripteur
\& # de fichier et de re\*'pertoire
\&
\& sub get_rec {
\& my $fh = shift;
\& return scalar <$fh>;
\& }
.Ve
.Sh "Utiliser des re\*'fe\*'rences"
.IX Xref "re\*'fe\*'rences, utilisation de de\*'re\*'fe\*'rencement de\*'re\*'fe\*'rence"
.IX Subsection "Utiliser des re'fe'rences"
C'est tout pour la cre\*'ation de re\*'fe\*'rences. Maintenant, vous devez
su\*^rement mourir d'envie de savoir comment utiliser ces re\*'fe\*'rences pour
en revenir a\*` vos donne\*'es perdues depuis longtemps. Il existe
plusieurs me\*'thodes de base.
.IP "1." 4
Ou\*` que vous mettiez un identifiant (ou une chai\*^ne
d'identifiants) comme partie d'une variable ou d'une nom de
routine, vous pouvez remplacer cet identifiant par une simple variable
scalaire contenant une re\*'fe\*'rence de type correct\ :
.Sp
.Vb 6
\& $bar = $$scalarref;
\& push(@$arrayref, $filename);
\& $$arrayref[0] = "January";
\& $$hashref{"KEY"} = "VALUE";
\& &$coderef(1,2,3);
\& print $globref "output\en";
.Ve
.Sp
Il est important de comprendre qu'ici, nous ne de\*'re\*'fe\*'renc\*,ons \fIpas\fR en
particulier \f(CW$arrayref[0]\fR ou \f(CW$hashref{"KEY"}\fR. Le de\*'re\*'fe\*'rencement
de la variable scalaire a lieu \fIavant\fR toute recherche de cle\*'. Tout
ce qui est plus complexe qu'une simple variable scalaire doit utiliser
les me\*'thodes\ 2 et\ 3 ci\-dessous. un \*(L"simple scalaire\*(R" inclut
toutefois un identifiant qui utilise lui\-me\*^me la me\*'thode\ 1 de fac\*,on
re\*'cursive. Le code suivant imprime par conse\*'quent \*(L"howdy\*(R".
.Sp
.Vb 2
\& $refrefref = \e\e\e"howdy";
\& print $$$$refrefref;
.Ve
.IP "2." 4
2.
.IX Xref "${} @{} %{}"
.Sp
Ou\*` que vous mettiez un identifiant (ou une chai\*^ne d'identifiants)
comme partie d'une variable ou d'une nom de routine, vous pouvez
remplacer cet identifiant par un \s-1BLOC\s0 retournant une re\*'fe\*'rence de type
correct. En d'autres mots, les exemples pre\*'ce\*'dents auraient pu e\*^tre
e\*'crits ainsi\ :
.Sp
.Vb 6
\& $bar = ${$scalarref};
\& push(@{$arrayref}, $filename);
\& ${$arrayref}[0] = "January";
\& ${$hashref}{"KEY"} = "VALUE";
\& &{$coderef}(1,2,3);
\& $globref\->print("output\en"); # ssi IO::Handle est charge\*'
.Ve
.Sp
Il est vrai que c'est un peu idiot d'utiliser des accolades dans ce cas\-la\*`,
mais le \s-1BLOC\s0 peut contenir n'importe quelle expression, en particulier une
expression subscript telle que celle-ci\ :
.Sp
.Vb 1
\& &{ $dispatch{$index} }(1,2,3); # appel la routine correcte
.Ve
.Sp
Comme il est possible d'omettre les accolades dans le cas simple de
\&\f(CW$$x\fR, les gens font souvent l'erreur de conside\*'rer le
de\*'re\*'fe\*'rencement comme des ope\*'rateurs propres et se posent des questions a\*`
propos de leur pre\*'ce\*'dence. Mais s'ils en e\*'taient, vous pourriez
utiliser des parenthe\*`ses a\*` la place des accolades. Ce qui n'est pas le
cas. Remarquez la diffe\*'rence ci\-dessous. Le cas\ 0 est un
raccourci du cas\ 1 mais \fIpas\fR du cas\ 2.
.Sp
.Vb 4
\& $$hashref{"KEY"} = "VALUE"; # CAS 0
\& ${$hashref}{"KEY"} = "VALUE"; # CAS 1
\& ${$hashref{"KEY"}} = "VALUE"; # CAS 2
\& ${$hashref\->{"KEY"}} = "VALUE"; # CAS 3
.Ve
.Sp
Le cas\ 2 est aussi de\*'cevant dans le sens que vous acce\*'dez a\*` une
variable appele\*'e \f(CW%hashref\fR, sans de\*'re\*'fe\*'rencer par \f(CW$hashref\fR
la table de hachage qu'il re\*'fe\*'rence probablement. Ceci correspond au
cas\ 3.
.IP "3." 4
3.
.IX Xref "autovivification -> fle\*`che"
.Sp
Les appels de routines et les recherches d'e\*'le\*'ments individuels de
tableaux sont tellement courants qu'il devient pe\*'nible d'utiliser la
me\*'thode\ 2. En forme de sucre syntaxique, les exemples de la
me\*'thode\ 2 peuvent e\*^tre e\*'crits ainsi\ :
.Sp
.Vb 3
\& $arrayref\->[0] = "January"; # E\*'le\*'ment de tableau
\& $hashref\->{"KEY"} = "VALUE"; # E\*'le\*'ment de table de hachage
\& $coderef\->(1,2,3); # Appel d'une routine
.Ve
.Sp
La partie gauche de la fle\*`che peut e\*^tre n'importe quelle expression
retournant une re\*'fe\*'rence, y compris un de\*'re\*'fe\*'rencement
pre\*'ce\*'dent. Notez que \f(CW$array[$x]\fR n'est \fIpas\fR ici la me\*^me chose que
\&\f(CW\*(C`$array\->[$x]\*(C'\fR\ :
.Sp
.Vb 1
\& $array[$x]\->{"foo"}\->[0] = "January";
.Ve
.Sp
C'est un des cas que nous avons mentionne\*'s plus to\*^t et dans lequel les
re\*'fe\*'rences peuvent venir a\*` exister dans un contexte lvalue. Avant
cette instruction, \f(CW$array[$x]\fR peut avoir e\*'te\*' inde\*'fini. Dans ce cas,
il est automatiquement de\*'fini avec une re\*'fe\*'rence de table de hachage,
de telle sorte que nous puissions rechercher \f(CW\*(C`{"foo"}\*(C'\fR dedans. De la
me\*^me manie\*`re, \f(CW\*(C`$array[$x]\->{"foo"}\*(C'\fR sera automatiquement de\*'fini
avec une re\*'fe\*'rence de tableau, de telle fac\*,on que nous puissions
rechercher dedans. Ce processus est appele\*' \fIautovivification\fR.
.Sp
Encore une petite chose ici\ : la fle\*`che est facultative \fIentre\fR
les crochets subscripts. Vous pouvez donc abbre\*'ger le code ci-dessus
en\ :
.Sp
.Vb 1
\& $array[$x]{"foo"}[0] = "January";
.Ve
.Sp
Ce qui, dans le cas de\*'ge\*'ne\*'re\*' de la seule utilisation de tableaux
ordinaires, vous donne des tableaux multidimensionnels tout comme en
C\ :
.Sp
.Vb 1
\& $score[$x][$y][$z] += 42;
.Ve
.Sp
Bon, d'accord, pas comple\*`tement comme en C, en fait. Le C ne sait pas
comment aggrandir ses tableaux a\*` la
demande. Perl le sait.
.IP "4." 4
4.
.IX Xref "encapsulation"
.Sp
Si une re\*'fe\*'rence se re\*'ve\*`le e\*^tre une re\*'fe\*'rence a\*` un objet, il existe
alors probablement des me\*'thodes pour acce\*'der aux choses re\*'fe\*'rence\*'es,
et vous devriez vous cantonner a\*` ces me\*'thodes a\*` moins que vous ne
soyez dans le paquetage de classes qui de\*'finit justement les me\*'thodes
de cet objet. En d'autres termes, soyez sages et ne violez pas
l'encapsulation des objets sans d'excellentes raisons. Perl ne
renforce pas l'encapsulation. Nous ne sommes pas totalitaires. En
renvanche, nous attendons un minimum de politesse.
.PP
L'utilisation d'un nombre ou d'une chai\*^ne en tant que re\*'fe\*'rence en
fait une re\*'fe\*'rence symbolique comme explique\*' plus haut. L'utilisation
d'une re\*'fe\*'rence en tant que nombre la transforme en un entier
repre\*'sentant son emplacement en me\*'moire. Le seul usage inte\*'ressant est
la comparaison nume\*'rique de deux re\*'fe\*'rences pour savoir si elles se
re\*'fe\*`rent au me\*^me emplacement.
.IX Xref "re\*'fe\*'rence, contexte nume\*'rique"
.PP
.Vb 3
\& if ($ref1 == $ref2) {
\& print "refs 1 et 2 font re\*'fe\*'rence a\*` la me\*^me chose\en";
\& }
.Ve
.PP
L'utilisation d'une re\*'fe\*'rence en tant que chai\*^ne produit a\*` la fois le
type d'objet qu'elle re\*'fe\*'rence en incluant le nom du paquetage l'ayant
e\*'ventuellement consacre\*' (par \fIbless()\fR) comme explique\*' dans perlobj,
et aussi son adresse me\*'moire nume\*'rique en hexade\*'cimal. L'ope\*'rateur
\&\fIref()\fR produit juste le type d'objet lie\*' a\*` la re\*'fe\*'rence, sans
l'adresse. Voir \*(L"ref\*(R" in perlfunc pour plus de de\*'tails et des exemples
d'utilisation.
.IX Xref "re\*'fe\*'rence, contexte de chai\*^ne"
.PP
L'ope\*'rateur \fIbless()\fR peut e\*^tre utilise\*' pour associer l'objet, sur
lequel pointe une re\*'fe\*'rence, avec un paquetage fonctionnant comme une
classe d'objets. Cf. perlobj.
.PP
Un typeglob peut e\*^tre de\*'re\*'fe\*'rence\*' de la me\*^me fac\*,on qu'une re\*'fe\*'rence,
car la syntaxe de de\*'re\*'fe\*'rencement indique toujours le type de
re\*'fe\*'rence souhaite\*'. Par conse\*'quent, \f(CW\*(C`${*foo}\*(C'\fR et \f(CW\*(C`${\e$foo}\*(C'\fR indique
tous les deux la me\*^me variable scalaire.
.PP
Voici un truc pour interpoler l'appel d'une routine dans une chaine de
caracte\*`res\ :
.PP
.Vb 1
\& print "My sub returned @{[mysub(1,2,3)]} that time.\en";
.Ve
.PP
La fac\*,on dont c\*,a marche, c'est que lorsque le \f(CW\*(C`@{...}\*(C'\fR est aperc\*,u a\*`
l'inte\*'rieur des guillemets de la chai\*^ne de caracte\*`res, il est e\*'value\*'
comme un bloc. Le bloc cre\*'e une re\*'fe\*'rence a\*` une tableau anonyme
contenant le re\*'sultat de l'appel a\*` \f(CW\*(C`mysub(1,2,3)\*(C'\fR. Le bloc entier
retourne ainsi une re\*'fe\*'rence a\*` un tableau, qui est alors de\*'re\*'fe\*'rence\*'
par \f(CW\*(C`@{...}\*(C'\fR et inse\*'re\*' dans la chai\*^ne de caracte\*`res entre
guillemets. Cette chipotterie est aussi utile pour des expressions
arbitraires\ :
.PP
.Vb 1
\& print "That yields @{[$n + 5]} widgets\en";
.Ve
.Sh "Re\*'fe\*'rences symboliques"
.IX Xref "re\*'fe\*'rence symbolique symbolique, re\*'fe\*'rence"
.IX Subsection "Re'fe'rences symboliques"
Nous avons de\*'ja\*` explique\*' que, quand c'est ne\*'cessaire, les re\*'fe\*'rences
devenaient existantes si elles sont de\*'finies, mais nous n'avons pas
dit ce qui arrivait lorsqu'une valeur utilise\*'e comme re\*'fe\*'rence est
de\*'ja\*` de\*'finie mais n'est \fIpas\fR une re\*'fe\*'rence dure. Si vous l'utilisez
comme re\*'fe\*'rence dans ce cas\-la\*`, elle sera traite\*'e comme une re\*'fe\*'rence
symbolique. C'est\-a\*`\-dire que la valeur du scalaire est conside\*'re\*'e
comme le \fInom\fR d'une variable, pluto\*^t que comme un lien direct vers
une (e\*'ventuelle) valeur anonyme.
.PP
En ge\*'ne\*'ral, les gens s'attendent a\*` ce que c\*,a fonctionne de cette
fac\*,on. C'est donc comme c\*,a que c\*,a marche.
.PP
.Vb 9
\& $name = "foo";
\& $$name = 1; # Affecte $foo
\& ${$name} = 2; # Affecte $foo
\& ${$name x 2} = 3; # Affecte $foofoo
\& $name\->[0] = 4; # Affecte $foo[0]
\& @$name = (); # Efface @foo
\& &$name(); # Appelle &foo() (comme en Perl 4)
\& $pack = "THAT";
\& ${"${pack}::$name"} = 5; # Affecte $THAT::foo sans e\*'valuation
.Ve
.PP
C'est tre\*`s puissant, et potentiellement dangereux, dans le sens ou\*` il
est possible de vouloir (avec la plus grande since\*'rite\*') utiliser une
re\*'fe\*'rence dure, et utiliser accidentellement une re\*'fe\*'rence symbolique
a\*` la place. Pour vous en pre\*'munir, vous pouvez utiliser
.PP
.Vb 1
\& use strict 'refs';
.Ve
.PP
et seules les re\*'fe\*'rences dures seront alors autorise\*'es dans le reste
du bloc l'incluant. Un bloc imbrique\*' peut inverser son effet avec
.PP
.Vb 1
\& no strict 'refs';
.Ve
.PP
Seuls les variables (globales, me\*^me si elles sont localise\*'es) de
paquetage sont visibles par des re\*'fe\*'rences symboliques. Les variables
lexicales (de\*'clare\*'es avec \fImy()\fR) ne font pas partie de la table des
symboles, et sont donc invisibles a\*` ce me\*'canisme. Par exemple\ :
.PP
.Vb 6
\& local $value = 10;
\& $ref = "value";
\& {
\& my $value = 20;
\& print $$ref;
\& }
.Ve
.PP
Ceci imprimera 10 et non pas 20. Souvenez-vous que \fIlocal()\fR affecte les
variables de paquetage, qui sont toutes \*(L"globales\*(R" au paquetage.
.Sh "Re\*'fe\*'rences pas\-si\-symboliques\-que\-c\*,a"
.IX Subsection "Re'fe'rences pas-si-symboliques-que-c,a"
Une nouvelle fonctionnalite\*' contribuant a\*` la lisibilite\*' en perl
version\ 5.001 est que les crochets autour d'une re\*'fe\*'rence
symbolique se comportent comme des apostrophes, tout comme elles
l'ont toujours e\*'te\*' dans une chai\*^ne de caracte\*`res. C'est\-a\*`\-dire que
.PP
.Vb 2
\& $push = "pop on ";
\& print "${push}over";
.Ve
.PP
a toujours imprime\*' \*(L"pop on over\*(R", me\*^me si push est un mot
re\*'serve\*'. Ceci a e\*'te\*' ge\*'ne\*'ralise\*' pour fonctionner de me\*^me en dehors de
guillemets, de telle sorte que
.PP
.Vb 1
\& print ${push} . "over";
.Ve
.PP
et me\*^me
.PP
.Vb 1
\& print ${ push } . "over";
.Ve
.PP
auront un effet identique. (Ceci aurait provoque\*' une erreur syntaxique
en Perl\ 5.000, bien que Perl\ 4 l'autorisait dans une forme sans
espaces.) Cette construction n'est \fIpas\fR conside\*'re\*'e comme une
re\*'fe\*'rence symbolique lorsque vous utilisez strict refs\ :
.PP
.Vb 3
\& use strict 'refs';
\& ${ bareword }; # Correct, signifie $bareword.
\& ${ "bareword" }; # Erreur, re\*'fe\*'rence symbolique.
.Ve
.PP
De fac\*,on similaire, a\*` cause de tout le subscripting qui est
effectue\*' en utilisant des mots simples, nous avons applique\*' la me\*^me
re\*`gle a\*` tout mot simple qui soit utilise\*' pour le subscripting d'une
table de hachage. De\*'sormais, au lieu d'e\*'crire
.PP
.Vb 1
\& $array{ "aaa" }{ "bbb" }{ "ccc" }
.Ve
.PP
vous pourrez donc juste e\*'crire
.PP
.Vb 1
\& $array{ aaa }{ bbb }{ ccc }
.Ve
.PP
sans vous inquie\*'ter du fait que les subscripts soient ou non des mots
re\*'serve\*'s. Dans les rares cas ou\*` vous souhaiteriez faire quelque chose
comme\ :
.PP
.Vb 1
\& $array{ shift }
.Ve
.PP
vous pouvez en forcer l'interpre\*'tation comme un mot re\*'serve\*' en
ajoutant n'importe quoi qui soit plus qu'un mot simple\ :
.PP
.Vb 3
\& $array{ shift() }
\& $array{ +shift }
\& $array{ shift @_ }
.Ve
.PP
La directive \f(CW\*(C`use warnings\*(C'\fR ou l'option \fB\-w\fR vous avertira si un mot
re\*'serve\*' est interpre\*'te\*' comme une chai\*^ne de caracte\*`res. Mais il ne vous
avertira plus si vous utilisez des mots en minuscules, car la chai\*^ne
de caracte\*`res est entre guillemets de fac\*,on effective.
.Sh "Pseudo-tables de hachage\ : utiliser un tableau comme table de hachage"
.IX Xref "pseudo-table de hachage"
.IX Subsection "Pseudo-tables de hachage: utiliser un tableau comme table de hachage"
\&\fB\s-1AVERTISSEMENT\s0\fR\ : cette section traite de fonctionnalite\*'s
expe\*'rimentales. Certains de\*'tails pourraient changer sans annonce
particulie\*`re dans les prochaines versions.
.PP
\&\fB\s-1NOTE\s0\fR\ : la partie visible de l'imple\*'mentation actuelle des
pseudo-tables de hachage (l'utilisation singulie\*`re du premier e\*'le\*'ment
du tableau) est de\*'pre\*'cie\*'e a\*` partir de Perl 5.8.0 et disparai\*^tra dans
Perl 5.10.0. Cette fonctionnalite\*' sera imple\*'mente\*'e autrement. Au\-dela\*`
de l'interface actuelle qui est particulie\*`rement horrible,
l'imple\*'mentation actuelle ralentit notablement l'utilisation normale
des tableaux et des tables de hachage. La directive 'fields' restera
disponible.
.PP
Avec la version\ 5.005 de Perl, vous pouvez de\*'sormais utiliser une
re\*'fe\*'rence a\*` un tableau dans un contexte qui exigerait normalement une
re\*'fe\*'rence a\*` une table de hachage. Ceci vous permet d'acce\*'der aux
e\*'le\*'ments d'un tableau en utilisant des noms symboliques, comme s'ils
e\*'taient les champs d'une structure.
.PP
Pour que cela fonctionne, le tableau doit contenir des informations
supple\*'mentaires. Le premier e\*'le\*'ment du tableau doit e\*^tre une re\*'fe\*'rence
a\*` une table de hachage qui associe les noms de champs avec les indices
du tableau. Voici un exemple\ :
.PP
.Vb 1
\& $struct = [{foo => 1, bar => 2}, "FOO", "BAR"];
\&
\& $struct\->{foo}; # identique a\*` $struct\->[1], c'est\-a\*`\-dire "FOO"
\& $struct\->{bar}; # identique a\*` $struct\->[2], c'est\-a\*`\-dire "BAR"
\&
\& keys %$struct; # retournera ("foo", "bar") dans un certain ordre
\& values %$struct; # retournera ("FOO", "BAR") dans le meme certain ordre
\&
\& while (my($k,$v) = each %$struct) {
\& print "$k => $v\en";
\& }
.Ve
.PP
Perl de\*'clenchera une exception si vous essayez d'acce\*'der a\*` des champs
inexistants. Pour e\*'viter les incohe\*'rences, utilisez toujours la
fonction \fIfields::phash()\fR fournie par la directive \f(CW\*(C`fields\*(C'\fR.
.PP
.Vb 2
\& use fields;
\& $pseudohash = fields::phash(foo => "FOO", bar => "BAR");
.Ve
.PP
Pour de meilleures performances, Perl peut aussi effectuer la
traduction des noms de champs en indices de tableau lors de la
compilation pour les re\*'fe\*'rences a\*` des objets type\*'es. Voir fields.
.PP
Il existe deux moyens de ve\*'rifier l'existence d'une cle\*' dans une
pseudo-table de hachage. Le premier est d'utiliser \fIexist()\fR. Cela teste
si ce champ donne\*' a de\*'ja\*` e\*'te\*' utilise\*'. Ce comportement est le me\*^me que
celui d'une table de hachage normale. Par exemple\ :
.PP
.Vb 3
\& use fields;
\& $phash = fields::phash([qw(foo bar pants)], ['FOO']);
\& $phash\->{pants} = undef;
\&
\& print exists $phash\->{foo}; # vrai, 'foo' est value\*' dans la declaration
\& print exists $phash\->{bar}; # faux, 'bar' n'a jamais e\*'te\*' utilise\*'
\& print exists $phash\->{pants}; # vrai, 'pants' a e\*'te\*' utilise\*'
.Ve
.PP
Le second moyen est d'utiliser \fIexists()\fR sur la table de hachage
pre\*'sente comme premier e\*'le\*'ment du tableau. Cela teste si ce champ est
un champ valide pour cette pseudo-table de hachage.
.PP
.Vb 2
\& print exists $phash\->[0]{bar}; # vrai, 'bar' est valide
\& print exists $phash\->[0]{shoes}; # faux, 'shoes' ne peut e\*^tre utilise\*'
.Ve
.PP
Un appel a\*` \fIdelete()\fR sur un e\*'le\*'ment d'une pseudo-table de hachage
n'efface que le valeur correspondant a\*` cette cle\*' et non la cle\*'
elle\-me\*^me. Pour effacer la cle\*', vous devez l'effacer explicitement de
la table situe\*'e au premier e\*'le\*'ment du tableau.
.PP
.Vb 5
\& print delete $phash\->{foo}; # affiche $phash\->[1], "FOO"
\& print exists $phash\->{foo}; # faux
\& print exists $phash\->[0]{foo}; # vrai, la cle\*' existe encore
\& print delete $phash\->[0]{foo}; # maintenant la cle\*' est efface\*'e
\& print $phash\->{foo}; # exception de\*'clenche\*'e
.Ve
.Sh "Mode\*`les de fonctions"
.IX Xref "porte\*'e lexicale fermeture lexical subroutine imbrique\*'e subroutine, local"
.IX Subsection "Mode`les de fonctions"
Comme explique\*' ci\-dessus, une fermeture est une fonction anonyme qui a
acce\*`s aux variables lexicales qui e\*'taient visibles lors de sa
compilation. Elle conserve l'acce\*`s a\*` ses variables me\*^me si elle n'est
exe\*'cute\*'e que plus tard, comme dans le cas des signaux ou des callbacks
en Tk.
.PP
Utiliser une fermeture comme mode\*`le de fonction nous permet de ge\*'ne\*'rer
de nombreuses fonctions agissant de fac\*,on similaire. Supposons que
vous souhaitiez des fonctions nomme\*'es d'apre\*`s la couleur qu'elles
produiront en \s-1HTML\s0 via la balise \s-1FONT\s0\ :
.PP
.Vb 1
\& print "Be ", red("careful"), "with that ", green("light");
.Ve
.PP
Les fonctions \fIred()\fR et \fIgreen()\fR seront tre\*`s similaires. Pour les cre\*'er,
nous allons assigner une fermeture a\*` un typeglob du nom de la fonction
que nous voulonsq construire.
.PP
.Vb 5
\& @colors = qw(red blue green yellow orange purple violet);
\& for my $name (@colors) {
\& no strict 'refs'; # Autorise la manipulation de la table de symboles
\& *$name = *{uc $name} = sub { "@_" };
\& }
.Ve
.PP
De\*'sormais, toutes ces fonctions existent de fac\*,on inde\*'pendante. Vous
pouvez appeler \fIred()\fR, \s-1\fIRED\s0()\fR, \fIblue()\fR, \s-1\fIBLUE\s0()\fR, \fIgreen()\fR, etc. Cette
technique optimise le temps de compilation et l'utilisation de la
me\*'moire, et elle est aussi moins sujette aux erreurs puisque la
ve\*'rification syntaxique a lieu a\*` la compilation. Il est ne\*'cessaire
qu'aucune variable de la routine anonyme ne soit lexicale pour cre\*'er
une fermeture propre. C'est la raison pour laquelle nous avons un
\&\f(CW\*(C`my\*(C'\fR dans notre boucle.
.PP
C'est l'un des seuls endroits ou\*` donner un prototype a\*` une fermeture a
un re\*'el sens. Si vous souhaitiez imposer un contexte scalaire aux
arguments de ces fonctions (ce qui n'est probablement pas une bonne
ide\*'e pour cet exemple particulier), vous auriez pu e\*'crire a\*` la place\ :
.PP
.Vb 1
\& *$name = sub ($) { "$_[0]" };
.Ve
.PP
Quoi qu'il en soit, comme la ve\*'rification des prototypes a lieu a\*` la
compilation, l'affectation ci-dessus est effectue\*'e trop tard pour e\*^tre
vraiment utile. Vous pourriez ge\*'rer c\*,a en inse\*'rant la boucle entie\*`re
d'affectations dans un bloc \s-1BEGIN\s0, forc\*,ant ainsi son exe\*'cution pendant
la compilation.
.PP
L'acce\*`s aux lexicaux qui change au\-dela\*` des types (comme ceux de la
boucle \f(CW\*(C`for\*(C'\fR ci\-dessus) ne fonctionne qu'avec des fermetures et pas
avec des routines ge\*'ne\*'rales. Par conse\*'quent, dans le cas ge\*'ne\*'ral, les
routines nomme\*'es ne s'imbriquent pas proprement, au contraire des
routines anonymes. C'est comme cela parce que les routines nomme\*'es
sont cre\*'es (et re\*'cupe\*`rent les lexicaux externes) une seule fois lors
de la compilation alors que les routines anonymes re\*'alisent cette
re\*'cupe\*'ration a\*` chaque exe\*'cution de l'ope\*'rateur 'sub'. Si vous e\*^tes
habitue\*' a\*` l'utilisation de routines imbrique\*'es dans d'autres langages
de programmation, avec leurs propres variables prive\*'es, il va vous
falloir travailler la\*`\-dessus en Perl un tant soit peu. La
programmation intuitive de ce genre de choses implique des
avertissements myste\*'rieux du genre \*(L"will not stay shared\*(R". Par
exemple, ceci ne fonctionnera pas\ :
.PP
.Vb 5
\& sub outer {
\& my $x = $_[0] + 35;
\& sub inner { return $x * 19 } # FAUX
\& return $x + inner();
\& }
.Ve
.PP
Une solution pourrai\*^t e\*^tre celle-ci\ :
.PP
.Vb 5
\& sub outer {
\& my $x = $_[0] + 35;
\& local *inner = sub { return $x * 19 };
\& return $x + inner();
\& }
.Ve
.PP
Maintenant, \fIinner()\fR ne peut e\*^tre appele\*'e que de l'inte\*'rieur de
\&\fIouter()\fR, gra\*^ce aux affectations temporaires de la fermeture (routine
anonyme). Mais lorsque cela a lieu, elle a un acce\*`s normal a\*` la
variable lexicale \f(CW$x\fR dans la porte\*'e de \fIouter()\fR.
.PP
Ceci a pour effet inte\*'ressant de cre\*'er une fonction locale a\*` une
autre, ce qui n'est pas normalement supporte\*' par Perl.
.SH "AVERTISSEMENT"
.IX Xref "re\*'fe\*'rence, contexte de chai\*^ne re\*'fe\*'rence en tant que cle\*' de hachage"
.IX Header "AVERTISSEMENT"
Vous ne devriez pas (utilement) utiliser une re\*'fe\*'rence comme cle\*' d'une
table de hachage. Elle sera convertie en chai\*^ne de caracte\*`res\ :
.PP
.Vb 1
\& $x{ \e$a } = $a;
.Ve
.PP
Si vous essayez de de\*'re\*'fe\*'rencer la cle\*', il n'y aura pas de
de\*'re\*'fe\*'rencement dur et vous ne ferez pas ce que vous souhaitiez. Vous
devriez pluto\*^t faire ainsi\ :
.PP
.Vb 2
\& $r = \e@a;
\& $x{ $r } = $r;
.Ve
.PP
Et alors, au moins, vous pourrez utiliser les valeurs, par \fIvalues()\fR, qui
seront de ve\*'ritables re\*'fe\*'rences, au contraire des cle\*'s, par \fIkeys()\fR.
.PP
Le module standard Tie::RefHash fournit une base de travail pratique
pour faire ce genre de choses.
.SH "VOIR AUSSI"
.IX Header "VOIR AUSSI"
A\*` co\*^te\*' de la documentation standard, du code source peut e\*^tre
instructif. Quelques exemples pathologiques de l'utilisation de
re\*'fe\*'rences peuvent e\*^tre trouve\*'es dans le test de re\*'gression
\&\fIt/op/ref.t\fR du re\*'pertoire source de Perl.
.PP
Voir aussi perldsc et perllol, pour l'utilisation de re\*'fe\*'rences
dans la cre\*'ation de structures de donne\*'es complexes, et perltoot,
perlobj et perlbot pour leur utilisation dans la cre\*'ation d'objets.
.SH "AUTEUR"
.IX Header "AUTEUR"
Larry Wall
.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\ : Jean-Pascal Peltier
. Mise a\*` jour\ : Paul Gaborit .
.Sh "Relecture"
.IX Subsection "Relecture"
Personne pour l'instant.
.SH "POD ERRORS"
.IX Header "POD ERRORS"
Hey! \fBThe above document had some coding errors, which are explained below:\fR
.IP "Around line 370:" 4
.IX Item "Around line 370:"
Expected '=item 2'
.IP "Around line 410:" 4
.IX Item "Around line 410:"
Expected '=item 3'
.IP "Around line 454:" 4
.IX Item "Around line 454:"
Expected '=item 4'