.\" 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 "PERLDATA 1" .TH PERLDATA 1 "2006-03-19" "DocFr" "User Contributed Perl Documentation" .SH "NAME/NOM" .IX Header "NAME/NOM" perldata \- Types de donne\*'es de Perl .SH "DESCRIPTION" .IX Header "DESCRIPTION" .Sh "Noms des variables" .IX Xref "variable, nom nom de variable type de donne\*'es type" .IX Subsection "Noms des variables" Perl a trois types de donne\*'es inte\*'gre\*'s\ : les scalaires, les tableaux de scalaires et les tableaux associatifs de scalaires, appele\*'s aussi tables de hachage ou X\ hachages\ X. Un scalaire est soit une simple chai\*^ne de caracte\*`res (sans limite de taille si ce n'est la me\*'moire disponible), soit un nombre, soit un re\*'fe\*'rence a\*` quelque chose (notion explique\*'e dans perlref). Les tableaux normaux sont des listes ordonne\*'es de scalaires indexe\*'es par des nombres, en commenc\*,ant par 0. Les tables de hachages sont des collections non ordonne\*'es de valeurs scalaires indexe\*'es par des chai\*^nes qui sont leurs cle\*'s associe\*'es. .PP On fait habituellement re\*'fe\*'rence aux valeurs par leur nom, ou par une re\*'fe\*'rence nomme\*'e. Le premier caracte\*`re du nom vous indique a\*` quel type de structure de donne\*'es il correspond. Le reste du nom vous dit a\*` quelle valeur particulie\*`re il fait re\*'fe\*'rence. Habituellement, ce nom est un simple \&\fIidentifiant\fR, c'est\-a\*`\-dire une chai\*^ne commenc\*,ant par une lettre ou un caracte\*`re souligne\*', et contenant des lettres, des souligne\*'s, et des chiffres. Dans certains cas, il peut e\*^tre une chai\*^ne d'identifiants, se\*'pare\*'s par \f(CW\*(C`::\*(C'\fR (ou par le le\*'ge\*`rement archai\*:que \f(CW\*(C`'\*(C'\fR)\ ; tous sauf le dernier sont interpre\*'te\*'s comme des noms de paquetages, pour localiser l'espace de nommage dans lequel l'identifiant final doit e\*^tre recherche\*' (voir \&\*(L"Paquetages\*(R" in perlmod pour plus de de\*'tails). Il est possible de substituer a\*` un simple identifiant une expression qui produit une re\*'fe\*'rence a\*` la valeur lors de l'exe\*'cution. Ceci est de\*'crit plus en de\*'tails plus bas, et dans perlref. .IX Xref "identifiant" .PP Perl a aussi ses propres variables inte\*'gre\*'es dont les noms ne suivent pas ces re\*`gles. Elles ont des noms e\*'tranges pour qu'elles ne rentrent pas accidentellement en collision avec l'une de vos variables normales. Les chai\*^nes qui correspondent aux parties entre parenthe\*`ses d'une expression rationnelle sont sauve\*'es sous des noms qui ne contiennent que des chiffres apre\*`s le \f(CW\*(C`$\*(C'\fR (voir perlop et perlre). De plus, plusieurs variables spe\*'ciales qui ouvrent des fene\*^tres dans le fonctionnement interne de Perl ont des noms contenant des signes de ponctuation et des caracte\*`res de contro\*^le. Elles sont de\*'crites dans perlvar. .IX Xref "variables pre\*'de\*'finies" .PP Les valeurs scalaires sont toujours de\*'signe\*'es par un '$', me\*^me si l'on se re\*'fe\*`re a\*` un scalaire qui fait partie d'un tableau ou d'un hachage. Le symbole '$' fonctionne d'un point de vue se\*'mantique comme les mots X\ le\ X ou X\ la\ X dans le sens ou\*` ils indiquent qu'on attend une seule valeur. .IX Xref "scalaire" .PP .Vb 4 \& $days # la simple valeur scalaire "days" \& $days[28] # le 29e\*`me e\*'le\*'ment du tableau @days \& $days{'Feb'} # la veleur 'Feb' dans le hachage %days \& $#days # le dernier indice du tableau @days .Ve .PP Les tableaux complets (et les tranches de tableaux ou de hachage sont de\*'note\*'s par '@', qui fonctionne pluto\*^t comme le mot X\ ces\ , en ce sens qu'il indique que des valeurs multiples sont attendues\ . .IX Xref "tableau" .PP .Vb 3 \& @days # ($days[0], $days[1],... $days[n]) \& @days[3,4,5] # identique a\*` ($days[3],$days[4],$days[5]) \& @days{'a','c'} # identique a\*` ($days{'a'},$days{'c'}) .Ve .PP Les hachages complets sont de\*'note\*'s par '%'\ : .IX Xref "hachage table de hachage tableau associatif" .PP .Vb 1 \& %days # (cle\*'1, valeur1, cle\*'2, valeur2 ...) .Ve .PP De plus, les sous-programmes sont nomme\*'s avec un '&' initial, bien que ce soit optionnel lorsqu'il n'y a pas d'ambigui\*:te\*', tout comme X\ faire\ X est souvent redondant en franc\*,ais. Les entre\*'es des tables de symboles peuvent e\*^tre nomme\*'es avec un '*' initial, mais vous ne vous souciez pas vraiment de cela pour le moment (si jamais\ :\-). .PP Chaque type de variable a son propre espace de nommage, tout comme les identifiants de plusieurs types autres que les variables. Ceci signifie que vous pouvez, sans craindre un conflit, utiliser le me\*^me nom pour une variable scalaire, un tableau, ou un hachage \*(-- ou, pour cette affaire, un handle de fichier, un handle de re\*'pertoire, un nom de sous\-programme, ou un label. Ceci veut dire que \f(CW$foo\fR et \f(CW@foo\fR sont deux variables diffe\*'rentes. Ceci veut aussi dire que \f(CW$foo[1]\fR fait partie de \f(CW@foo\fR, et pas de \f(CW$foo\fR. Cela peut sembler un peu e\*'trange, mais c'est normal, puisque c'est e\*'trange. .IX Xref "espace de nommage" .PP Puisque les re\*'fe\*'rences de variables commencent toujours par '$', '@', ou '%', les mots X\ re\*'serve\*'s\ X ne sont en fait pas re\*'serve\*'s en ce qui concerne les noms de variables (Ils \s-1SONT\s0 toutefois re\*'serve\*'s en ce qui concerne les labels et les handles de fichiers, qui n'ont pas de caracte\*`re spe\*'cial initial. Vous ne pouvez pas avoir un handle de fichier nomme\*' X\ log\ X, par exemple. Indice\ : vous pourriez dire \f(CW\*(C`open(LOG,'logfile')\*(C'\fR pluto\*^t que \&\f(CW\*(C`open(log,'logfile')\*(C'\fR. Utiliser des handles de fichiers en lettres majuscules ame\*'liore aussi la lisibilite\*' et vous prote\*`ge de conflits avec de futurs mots re\*'serve\*'s. La casse \fIest\fR significative \*(-- X\ \s-1FOO\s0\ X, X\ Foo\ X, et X\ foo\ X sont tous des noms diffe\*'rents. Les noms qui commencent par une lettre ou un caracte\*`re souligne\*' peuvent aussi contenir des chiffres et des souligne\*'s. .IX Xref "identifiant, sensibilite\*' a\*` la casse casse" .PP Il est possible de remplacer un tel nom alphanume\*'rique par une expression qui retourne une re\*'fe\*'rence au type approprie\*'. Pour une description de ceci, voir perlref. .PP Les noms qui commencent par un chiffre ne peuvent contenir que des chiffres. Les noms qui ne commencent pas par une lettre, un souligne\*', un chiffre ou un accent circonflexe (donc un caracte\*`re de contro\*^le) sont limite\*'s a\*` un caracte\*`re, tels \f(CW$%\fR or \f(CW$$\fR (La plupart de ces noms d'un seul caracte\*`re ont une signification pre\*'de\*'finie pour Perl. Par exemple, \f(CW$$\fR est l'\s-1ID\s0 du processus courant). .Sh "Contexte" .IX Xref "contexte contexte scalaire contexte de liste" .IX Subsection "Contexte" L'interpre\*'tation des ope\*'rations et des valeurs en Perl de\*'pend parfois des exigences du contexte de l'ope\*'ration ou de la valeur. Il existe deux contextes majeurs\ : le contexte de liste et le contexte scalaire. Certaines ope\*'rations retournent des valeurs de liste dans les contextes qui re\*'clament une liste, et des valeurs scalaires autrement Ssi ceci est vrai pour une ope\*'ration alors cela sera mentionne\*' dans la documentation pour cette ope\*'ration. En d'autres termes, Perl surcharge certaines ope\*'rations selon que la valeur de retour attendue est singulie\*`re ou plurielle. Certains mots en franc\*,ais fonctionnent aussi de cette fac\*,on, comme X\ lys\ X et X\ dos\ X. .PP Re\*'ciproquement, une ope\*'ration fournit un contexte scalaire ou de liste a\*` chacun de ses arguments. Par exemple, si vous dites\ : .PP .Vb 1 \& int( ) .Ve .PP L'ope\*'ration int fournit un contexte scalaire pour l'ope\*'rateur <\s-1STDIN\s0>, qui re\*'pond en lisant une ligne depuis \s-1STDIN\s0 et en la passant a\*` l'ope\*'ration int, qui trouvera alors la valeur entie\*`re de cette ligne et retournera cela. Si, au contraire, vous dites\ : .PP .Vb 1 \& sort( ) .Ve .PP alors l'ope\*'ration sort fournit un contexte de liste pour <\s-1STDIN\s0>, qui se mettra a\*` lire toutes les lignes disponibles jusqu'a\*` la fin du fichier, et passera cette liste de lignes a\*` la routine de tri, qui triera alors ces lignes et les retournera en tant que liste a\*` ce qui est le contexte de sort, quel qu'il soit. .PP L'affectation est un petit peu spe\*'ciale en ce sens qu'elle utilise son argument gauche pour de\*'terminer le contexte de l'argument droit. L'affectation a\*` un scalaire e\*'value la partie droite dans un contexte scalaire, tandis que l'affectation a\*` un tableau ou a\*` un hachage e\*'value la partie droite dans un contexte de liste. L'affectation a\*` une liste (ou a\*` une tranche, qui est juste une liste de toute fac\*,on) e\*'value aussi la partie droite dans un contexte de liste. .PP Lorsque vous utilisez le pragma \f(CW\*(C`use warnings\*(C'\fR ou l'option de ligne de commande \fB\-w\fR de Perl, il arrive que vous voyiez des avertissements sur un usage inutile de constantes ou de fonctions dans un X\ contexte vide\ X (X\ void context\ X, \s-1NDT\s0). Le contexte vide signifie juste que la valeur a e\*'te\*' abandonne\*'e, comme pour une instruction ne contenant que \f(CW\*(C`"fred";\*(C'\fR ou \f(CW\*(C`getpwuid(0);\*(C'\fR. Il compte toujours pour un contexte scalaire pour les fonctions qui se soucient de savoir si elles sont ou non appele\*'es dans un contexte scalaire. .PP Les sous-programmes de\*'finis par l'utilisateur peuvent se soucier d'avoir e\*'te\*' appele\*'s dans un contexte vide, scalaire ou de liste. La plupart des sous-programmes n'en ont toutefois pas besoin. C'est parce que les scalaires et les listes sont automatiquement interpole\*'s en listes. Voir \f(CW\*(C`wantarray()\*(C'\fR dans perlfunc pour une fac\*,on dont vous pourriez discerner dynamiquement le contexte d'appel de votre fonction. .Sh "Valeurs scalaires" .IX Xref "scalaire nombre chai\*^ne de caracte\*`res re\*'fe\*'rence" .IX Subsection "Valeurs scalaires" Toute donne\*'e en Perl est un scalaire, un tableau de scalaires ou un hachage de scalaires. Les variables scalaires peuvent contenir des une seule valeur de trois formes diffe\*'rentes\ : un nombre, une chai\*^ne ou une re\*'fe\*'rence. En ge\*'ne\*'ral, la conversion d'une forme a\*` une autre est transparente. Bien qu'un scalaire ne puisse pas contenir des valeurs multiples, il peut contenir une re\*'fe\*'rence a\*` un tableau ou a\*` un hachage qui a\*` son tour contient des valeurs multiples. .PP Les scalaires ne sont pas ne\*'cessairement une chose ou une autre. Il n'y a pas d'endroit ou\*` de\*'clarer qu'une variable scalaire doit e\*^tre de type X\ chai\*^ne\ X, de type X\ nombre\ X, de type X\ re\*'fe\*'rence\ X, ou n'importe quoi d'autre. Du fait de la conversion automatique des scalaires, les ope\*'rations qui en retournent n'ont pas besoin de se soucier (et en fait ne le peuvent pas) de savoir si leur appelant attend une chai\*^ne, un nombre ou une re\*'fe\*'rence. Perl est un langage contextuellement polymorphe dont les scalaires peuvent e\*^tre des chai\*^nes, des nombres, ou des re\*'fe\*'rences (ce qui inclut les objets). Tandis que les chai\*^nes et les nombres sont conside\*'re\*'s comme presque la me\*^me chose pour pratiquement tous les usages, les re\*'fe\*'rences sont des pointeurs au typage fort et impossible a\*` forcer, avec comptage de re\*'fe\*'rence inte\*'gre\*' et invocation de destructeur. .PP Une valeur scalaire est interpre\*'te\*'e comme \s-1TRUE\s0 (\s-1VRAIE\s0, \s-1NDT\s0) au sens boole\*'en si ce n'est pas une chai\*^ne vide ou le nombre 0 (ou son e\*'quivalent sous forme de chai\*^ne, X\ 0\ X). Le contexte boole\*'en est juste un genre spe\*'cial de contexte scalaire, ou\*` aucune conversion vers une chai\*^ne ou un nombre n'est jamais effectue\*'e. .IX Xref "boole\*'en vrai faux ve\*'rite\*'" .PP Il existe en fait deux varie\*'te\*'s de chai\*^nes nulles (parfois appele\*'es des chai\*^nes X\ vides\ X), l'une de\*'finie et l'autre non. La version de\*'finie est juste une chai\*^ne de longueur ze\*'ro, telle que \f(CW""\fR. La version non de\*'finie est la valeur qui indique qu'il n'existe pas de vraie valeur pour quelque chose, comme lorsqu'il s'est produit une erreur, ou a\*` la fin d'un fichier, ou lorsque vous vous re\*'fe\*'rez a\*` une variable ou a\*` un e\*'le\*'ment de tableau ou de hachage non initialise\*'. Bien que dans les anciennes versions de Perl, un scalaire inde\*'fini ait pu devenir de\*'fini lorsqu'il e\*'tait utilise\*' pour la premie\*`re fois dans un endroit ou\*` une valeur de\*'finie e\*'tait attendue, cela ne se produit plus, sauf dans de rares cas d'autovivification tels qu'explique\*'s dans perlref. Vous pouvez utiliser l'ope\*'rateur \fIdefined()\fR pour de\*'terminer si une valeur scalaire est de\*'finie (cela n'a pas de sens pour les tableaux ou les hachages), et l'ope\*'rateur \fIundef()\fR pour produire une valeur inde\*'finie. .IX Xref "undef defined de\*'fini inde\*'fini nulle chai\*^ne nulle" .PP Pour trouver si une chai\*^ne donne\*'e est un nombre diffe\*'rent de ze\*'ro valide, il suffit parfois de la tester a\*` la fois avec le 0 nume\*'rique et le X\ 0\ X lexical (bien que ceci provoquera du bruit si les avertissements sont actifs). C'est parce que les chai\*^nes qui ne sont pas des nombres comptent comme 0, tout comme en \fBawk\fR\ : .PP .Vb 3 \& if ($str == 0 && $str ne "0") { \& warn "That doesn't look like a number"; \& } .Ve .PP Cette me\*'thode est peut\-e\*^tre meilleure parce qu'autrement vous ne traiteriez pas correctement les notations \s-1IEEE\s0 comme \f(CW\*(C`NaN\*(C'\fR ou \f(CW\*(C`Infinity\*(C'\fR. A\*` d'autres moments, vous pourriez pre\*'fe\*'rer de\*'terminer si une donne\*'e chai\*^ne peut e\*^tre utilise\*'e nume\*'riquement en appelant la fonction \fIPOSIX::strtod()\fR ou en inspectant votre chai\*^ne avec une expression rationnelle (tel que documente\*' dans perlre). .PP .Vb 6 \& warn "has nondigits" if /\eD/; \& warn "not a whole number" unless /^\ed+$/; \& warn "not an integer" unless /^[+\-]?\ed+$/ \& warn "not a decimal number" unless /^[+\-]?\ed+\e.?\ed*$/ \& warn "not a C float" \& unless /^([+\-]?)(?=\ed|\e.\ed)\ed*(\e.\ed*)?([Ee]([+\-]?\ed+))?$/; .Ve .PP La longueur d'un tableau est une valeur scalaire. Vous pourriez trouver la longueur du tableau \f(CW@days\fR en e\*'valuant \f(CW$#days\fR, comme en \&\fBcsh\fR. Techniquement, ce n'est pas la longueur du tableau\ ; c'est l'indice de son dernier e\*'le\*'ment, ce qui n'est pas la me\*^me chose parce qu'il y a habituellement un e\*'le\*'ment nume\*'ro 0. Une affectation a\*` \&\f(CW$#days\fR change ve\*'ritablement la longueur du tableau. Le raccourcissement d'un tableau par cette me\*'thode de\*'truit les valeurs interme\*'diaires. L'agrandissement d'un tableau ayant pre\*'ce\*'demment e\*'te\*' raccourci ne re\*'cupe\*`re pas les valeurs qui e\*'taient stocke\*'es dans ces e\*'le\*'ments (c'e\*'tait le cas en Perl 4, mais nous avons du\*^ supprimer cela pour nous assurer que les destructeurs sont bien appele\*'s quand on s'y attend). .IX Xref "$# longueur d'un tableau tableau, longueur" .PP Vous pouvez aussi gagner un tout petit peu d'efficacite\*' en pre\*'\-e\*'tendant un tableau qui va devenir gros (vous pouvez aussi e\*'tendre un tableau en affectant des donne\*'es a\*` un e\*'le\*'ment qui est au\-dela\*` de la fin du tableau). Vous pouvez tronquer totalement un tableau en y affectant la liste vide (). Les expressions suivantes sont e\*'quivalentes\ : .PP .Vb 2 \& @whatever = (); \& $#whatever = \-1; .Ve .PP Si vous e\*'valuez un tableau dans un contexte scalaire, cela renvoie la longueur du tableau (notez que ceci n'est pas vrai pour les listes, qui renvoient leur dernie\*`re valeur, comme l'ope\*'rateur virgule en C, et contrairement aux fonctions inte\*'gre\*'es, qui renvoient ce qu'elles ont envie de renvoyer). Ce qui suit est toujours vrai\ : .IX Xref "longueur d'un tableau tableau, longueur" .PP .Vb 1 \& scalar(@whatever) == $#whatever \- $[ + 1; .Ve .PP La version 5 de Perl a change\*' la se\*'mantique de \f(CW$[\fR\ : les fichiers qui ne fixent pas la valeur de \f(CW$[\fR n'ont plus besoin de s'inquie\*'ter de savoir si un autre fichier a change\*' sa valeur (en d'autres termes, l'usage de \f(CW$[\fR est de\*'sapprouve\*'). Donc de fac\*,on ge\*'ne\*'rale, vous pouvez pre\*'sumer que .IX Xref "$[" .PP .Vb 1 \& scalar(@whatever) == $#whatever + 1; .Ve .PP Certains programmeurs choisissent d'utiliser une conversion explicite pour ne rien laisser au hasard\ : .PP .Vb 1 \& $element_count = scalar(@whatever); .Ve .PP Si vous e\*'valuez un hachage dans un contexte scalaire, vous obtenez faux si le hachage est vide. S'il contient une paire cle\*'/valeur quelconque, il renvoie vrai\ ; plus pre\*'cise\*'ment, la valeur retourne\*'e est une chai\*^ne constitue\*'e du nombre de buckets utilise\*'s et du nombre de buckets alloue\*'s, se\*'pare\*'s par un signe de division. Ceci n'a tendance a\*` e\*^tre tre\*`s utile que pour de\*'terminer si les algorithmes de hachage (compile\*'s) en Perl ont des performances me\*'diocres sur vos donne\*'es. Par exemple, vous mettez 10\ 000 trucs dans un hachage, mais l'e\*'valuation de \f(CW%HASH\fR dans un contexte scalaire re\*'ve\*`le X\ 1/16\ X, ce qui signifie qu'un seul des seize buckets a e\*'te\*' touche\*', et contient probablement tous vos 10\ 000 e\*'le\*'ments. Cela ne devrait pas se produire). .IX Xref "table de hachage, contexte scalaire table de hachage, bucket bucket" .PP Vous pouvez pre\*'alloue\*' de la me\*'moire pour une table de hachage en affectant une valeur a\*` la fonction \fIkeys()\fR. Ceci arrondi le nombre de buckets alloue\*'s a\*` la puissance de deux directement supe\*'rieure\ : .PP .Vb 1 \& keys(%users) = 1000; # pre\*'\-alloue 1024 buckets .Ve .Sh "Constructeurs de valeurs scalaires" .IX Xref "scalaire litte\*'ral scalaire constant" .IX Subsection "Constructeurs de valeurs scalaires" Les litte\*'raux nume\*'riques sont spe\*'cifie\*'s dans un quelconque des formats suivants de nombres entiers ou a\*` virgule flottante\ : .PP .Vb 9 \& 12345 \& 12345.67 \& .23E\-10 # un tre\*`s petit nombre \& 3.14_15_92 # un nombre tre\*`s important \& 4_294_967_296 # souligne\*' pour la lisibilite\*' \& 0xff # hexa \& 0xfade_bebe # un autre hexa \& 0377 # octal (des chiffres commenc\*,ant par 0) \& 0b011011 # binaire .Ve .PP Vous pouvez utiliser le caracte\*`re underscore (souligne\*') dans un nombre litte\*'ral entre les chiffres pour ame\*'liorer la lisibilite\*'. Vous pouvez, par exemple, regrouper les chiffres par trois (pour les droits d'acce\*`s Unix tel 0b110_100_100) ou par quatre (pour repre\*'senter des chiffres hexa dans 0b1010_0110) ou tout autre regroupement. .IX Xref "nombre, litte\*'ral" .PP Les litte\*'raux de chai\*^ne sont habituellement de\*'limite\*'s soit par des apostrophes, soit par des guillemets. Ils fonctionnent beaucoup comme dans un shell Unix standard\ : les litte\*'raux de chai\*^ne entre guillemets sont sujets aux substitutions de variables et au pre\*'fixage par barre oblique inverse\ ; les chai\*^nes entre apostrophes ne le sont pas (sauf pour \f(CW\*(C`\e'\*(C'\fR et \f(CW\*(C`\e\e\*(C'\fR). Les re\*`gles habituelles d'utilisation de la barre oblique inverse en C s'appliquent aussi bien pour cre\*'er des caracte\*`res comme la nouvelle ligne, la tabulation, etc., que sous des formes plus exotiques. Voir \*(L"Ope\*'rateurs apostrophe et type apostrophe\*(R" in perlop pour une liste. .IX Xref "chai\*^ne de caracte\*`res, litte\*'rale" .PP Les repre\*'sentations hexade\*'cimales, octales ou binaires sous forme de chai\*^nes (e.g. '0xff') ne sont pas automatiquement converties sous leur repre\*'sentation entie\*`re. Les fonctions \fIhex()\fR et \fIoct()\fR font ces conversions pour vous. Voir \&\fIhex()\fR et \fIoct()\fR pour plus de de\*'tails. .PP Vous pouvez aussi inclure des X\ nouvelles lignes\ X directement dans vos chai\*^nes, i.e., elles peuvent se terminer sur une ligne diffe\*'rente de celles ou\*` elles ont commence\*'. C'est bien joli, mais si vous oubliez votre apostrophe de fin (ou votre guillemet \- \&\s-1NDT\s0), l'erreur ne sera pas rapporte\*'e avant que Perl n'ait trouve\*' une autre ligne comportant une apostrophe, qui peut se trouver bien plus loin dans le script. La substitution de variable a\*` l'inte\*'rieur des chai\*^nes est limite\*'e aux variables scalaires, aux tableaux et aux tranches de tableau ou de hachage (en d'autres termes, des noms commenc\*,ant par $ ou @, suivi d'une expression optionnelle entre crochets comme indice). Le segment de code qui suit affiche X\ The price is \f(CW$100\fR.\ X .IX Xref "interpolation" .PP .Vb 2 \& $Price = '$100'; # pas d'interpolation \& print "The price is $Price.\en"; # interpole\*' .Ve .PP Il n'y a pas de double interpolation en Perl, donc '$100' restera tel quel. .PP Comme dans certains shells, vous pouvez mettre des accolades autour d'un nom pour le se\*'parer des caracte\*`res alphanume\*'riques (et du caracte\*`re souligne\*') qui le suivent. Vous devez aussi faire cela lorsque vous interpolez une variable dans une chai\*^ne pour se\*'parer son nom d'un deux-points ou d'une apostrophe, puisqu'ils seraient autrement traite\*'s comme un se\*'parateur de paquetage\ : .IX Xref "interpolation" .PP .Vb 3 \& $who = "Larry"; \& print PASSWD "${who}::0:0:Superuser:/:/bin/perl\en"; \& print "We use ${who}speak when ${who}'s here.\en"; .Ve .PP Sans les accolades, Perl aurait cherche\*' un \f(CW$whospeak\fR, un \f(CW$who::0\fR, et une variable \f(CW\*(C`who's\*(C'\fR. Les deux dernie\*`res auraient e\*'te\*' les variables \f(CW$0\fR et \f(CW$s\fR dans le paquetage \f(CW\*(C`who\*(C'\fR (probablement) inexistant. .PP En fait, un identifiant situe\*' entre de telles accolades est force\*' d'e\*^tre une chai\*^ne, tout comme l'est tout identificateur isole\*' a\*` l'inte\*'rieur d'un indice d'un hachage. Aucun des deux n'a besoin d'apostrophes. Notre exemple pre\*'ce\*'dent, \f(CW$days{'Feb'}\fR peut e\*^tre e\*'crit sous la forme \f(CW$days{Feb}\fR et les apostrophes seront pre\*'sume\*'es automatiquement. Mais tout ce qui est plus complique\*' dans l'indice sera interpre\*'te\*' comme e\*'tant une expression. Cela signifie par exemple que \f(CW$version{2.0}\fR sera interpre\*'te\*' comme \f(CW$version{2}\fR et non comme \&\f(CW$version{'2.0'}\fR. .PP \fIChai\*^ne de version\fR .IX Xref "chai\*^ne de version vstring v-string" .IX Subsection "Chai^ne de version" .PP \&\fB\s-1NOTE\s0\fR\ : les chai\*^nes de version sont de\*'pre\*'cie\*'es. Elle ne seront plus utilisables apre\*`s Perl 5.8. Le be\*'ne\*'fice minime des chai\*^nes de version est largement infe\*'rieur aux surprises et confusions potentielles. .PP Un litte\*'ral de la forme \f(CW\*(C`v1.20.300.4000\*(C'\fR est analyse\*' comme une chai\*^ne compose\*'e de caracte\*`res correspondants aux ordinaux spe\*'cifie\*'s. Cette formulation, connu sous le nom v\-string ou chai\*^ne de version, fournit une fac\*,on plus lisible de construire des chai\*^nes, au lieu d'utiliser l'interpolation parfois un peu moins lisible \&\f(CW"\ex{1}\ex{14}\ex{12c}\ex{fa0}"\fR. C'est utile pour repre\*'senter des chai\*^nes Unicode, et pour comparer des nume\*'ros de version en utilisant les ope\*'rateurs de comparaison de chai\*^nes, \f(CW\*(C`cmp\*(C'\fR, \f(CW\*(C`gt\*(C'\fR, \f(CW\*(C`lt,\*(C'\fR etc. Si le litte\*'ral contient plusieurs points, le \f(CW\*(C`v\*(C'\fR initial peut e\*^tre omis. .PP .Vb 4 \& print v9786; # affiche le SMILEY code\*' en UTF\-8, \& # "\ex{263a}" \& print v102.111.111; # affiche "foo" \& print 102.111.111; # idem .Ve .PP De tels litte\*'raux sont accepte\*'s a\*` la fois par \f(CW\*(C`require\*(C'\fR et \f(CW\*(C`use\*(C'\fR pour re\*'aliser une ve\*'rification de nume\*'ro de version. La variable spe\*'ciale \f(CW$^V\fR contient aussi le nume\*'ro de version sous cette forme de l'interpre\*'teur Perl en cours d'utilisation. Voir \&\*(L"$^V\*(R" in perlvar. Notez que l'utilisation des chai\*^nes de version pour construire des adresses IPv4 n'est pas portable a\*` moins d'utiliser les fonctions \fIinet_aton()\fR et \fIinet_ntoa()\fR du package Socket. .PP Notez que depuis Perl 5.8.1, une chai\*^ne de version a\*` un seul nombre (comme \f(CW\*(C`v65\*(C'\fR) n'en est pas une si elle est avant l'ope\*'rateur \&\f(CW\*(C`=>\*(C'\fR (qui est utilise\*' habituellement pour se\*'parer une cle\*' d'une valeur dans une table de hachage). C'e\*'tait conside\*'re\*' comme une chai\*^ne de version depuis Perl 5.6.0 jusqu'a\*` Perl 5.8.0 mais cela a provoque\*' plus de confusion et d'erreurs que d'avantages. En revanche, les chai\*^nes de version multi-nombres comme \f(CW\*(C`v65.66\*(C'\fR et \f(CW65.66.67\fR le restent bien. .PP \fILitte\*'raux spe\*'ciaux\fR .IX Xref "litte\*'ral spe\*'cial __END__ __DATA__ END DATA end data ^D ^Z" .IX Subsection "Litte'raux spe'ciaux" .PP Les litte\*'raux spe\*'ciaux _\|_FILE_\|_, _\|_LINE_\|_, et _\|_PACKAGE_\|_ repre\*'sentent le nom de fichier courant, le nume\*'ro de la ligne, et le nom du paquetage a\*` ce point de votre programme. Ils ne peuvent e\*^tre utilise\*'s que comme des mots\-cle\*' isole\*'s\ ; ils ne seront pas interpole\*'s dans les chai\*^nes. S'il n'existe pas de paquetage courant (a\*` cause d'une directive \f(CW\*(C`package;\*(C'\fR), _\|_PACKAGE_\|_ est la valeur inde\*'finie. .IX Xref "__FILE__ __LINE__ __PACKAGE__ line file package" .PP Les deux caracte\*`res de contro\*^le ^D et ^Z, et les mots\-cle\*' _\|_END_\|_ et _\|_DATA_\|_ peuvent e\*^tre utilise\*'s pour indique la fin logique d'un script avant la fin effective du fichier. Tout texte les suivant est ignore\*'. .PP Le texte qui suit _\|_DATA_\|_ peut e\*^tre lu via le handle de fichier \&\f(CW\*(C`PACKNAME::DATA\*(C'\fR, ou\*` \f(CW\*(C`PACKNAME\*(C'\fR est le paquetage qui e\*'tait courant lorsque le mot\-cle\*' _\|_DATA_\|_ a e\*'te\*' rencontre\*'. Le handle de fichier est laisse\*' ouvert, pointant vers le contenu apre\*`s _\|_DATA_\|_. Il est de la responsabilite\*' du programme d'effectuer un \f(CW\*(C`close DATA\*(C'\fR lorsqu'il a fini d'y lire. Pour la compatibilite\*' avec d'anciens scripts e\*'crits avant que _\|_DATA_\|_ ne soit introduit, _\|_END_\|_ se comporte comme _\|_DATA_\|_ dans le script principal (mais pas dans les fichiers charge\*'s par \f(CW\*(C`require\*(C'\fR ou \f(CW\*(C`do\*(C'\fR) et laisse le contenu restant du fichier accessible via \f(CW\*(C`main::DATA\*(C'\fR. .PP Voir SelfLoader pour une plus longue description de _\|_DATA_\|_, et un exemple de son utilisation. Notez que vous ne pouvez pas lire depuis le handle de fichier \s-1DATA\s0 dans un bloc \s-1BEGIN\s0\ : ce bloc est exe\*'cute\*' de\*`s qu'il est vu (pendant la compilation), a\*` un moment ou\*` le mot\-cle\*' _\|_DATA_\|_ (ou _\|_END_\|_) correspondant n'a pas encore e\*'te\*' rencontre\*'. .PP \fIMots simples (ou X\ barewords\ X)\fR .IX Xref "mot simple bareword" .IX Subsection "Mots simples (ou XbarewordsX)" .PP Un mot qui n'a aucune autre interpre\*'tation dans la grammaire sera traite\*' comme s'il e\*'tait une chai\*^ne entre apostrophes. Ces mots sont connus sous le nom de X\ barewords\ X. Comme pour les handles de fichier et les labels, un bareword constitue\*' entie\*`rement de lettres minuscules risque d'entrer en conflit avec de futurs mots re\*'serve\*'s, et si vous utilisez le pragma \f(CW\*(C`use warnings\*(C'\fR ou l'option \fB\-w\fR, Perl vous avertira pour chacun d'entre eux. Certaines personnes pourraient vouloir rendre les barewords totalement hors\-la\-loi. Si vous dites .PP .Vb 1 \& use strict 'subs'; .Ve .PP alors tout bareword qui ne serait \s-1PAS\s0 interpre\*'te\*' comme un appel a\*` un sous-programme produit a\*` la place une erreur au moment de la compilation. La restriction continue jusqu'a\*` la fin du bloc qui le contient. Un bloc interne pourrait annuler ceci en disant \f(CW\*(C`no strict 'subs'\*(C'\fR. .PP \fIDe\*'limiteur de jointure des tableaux\fR .IX Xref "interpolation des tableaux tableau, interpolation $""" .IX Subsection "De'limiteur de jointure des tableaux" .PP Les tableaux et les tranches sont interpole\*'s dans les chai\*^nes entre guillemets en joignant tous les e\*'le\*'ments avec le de\*'limiteur spe\*'cifie\*' dans la variable \f(CW$"\fR (\f(CW$LIST_SEPARATOR\fR si \*(L"use English\*(R" est spe\*'cifie\*'), un espace par de\*'faut. Les expressions suivantes sont e\*'quivalentes\ : .PP .Vb 2 \& $temp = join($", @ARGV); \& system "echo $temp"; \& \& system "echo @ARGV"; .Ve .PP A\*` l'inte\*'rieur d'un motif de recherche (qui subit aussi la substitution entre guillemets) il y a une malheureuse ambigui\*:te\*'\ : est-ce que \f(CW\*(C`/$foo[bar]/\*(C'\fR doit e\*^tre interpre\*'te\*' comme \f(CW\*(C`/${foo}[bar]/\*(C'\fR (ou\*` \f(CW\*(C`[bar]\*(C'\fR est une classe de caracte\*`res pour l'expression re\*'gulie\*`re) ou comme \f(CW\*(C`/${foo[bar]}/\*(C'\fR (ou\*` \f(CW\*(C`[bar]\*(C'\fR est un indice du tableau \f(CW@foo\fR)\ ? Si \f(CW@foo\fR n'existe pas par ailleurs, alors c'est e\*'videmment une classe de caracte\*`res. Si \f(CW@foo\fR existe, Perl choisit de deviner la valeur de \f(CW\*(C`[bar]\*(C'\fR, et il a presque toujours raison. S'il se trompe, ou si vous e\*^tes simplement comple\*`tement paranoi\*:aque, vous pouvez forcer l'interpre\*'tation correcte avec des accolades comme ci\-dessus. .PP Si vous cherchez comment utiliser les here\-documents, les informations qui e\*'taient pre\*'ce\*'demment ici sont maintenant dans \*(L"Ope\*'rateurs apostrophe et type apostrophe\*(R" in perlop. .Sh "Constructeurs de listes de valeurs" .IX Xref "liste" .IX Subsection "Constructeurs de listes de valeurs" Les valeurs de liste sont note\*'es en se\*'parant les valeurs individuelles par des virgules (et en enfermant la liste entre parenthe\*`ses lorsque la pre\*'ce\*'dence le requiert)\ : .PP .Vb 1 \& (LIST) .Ve .PP Dans un contexte qui ne requiert pas une valeur de liste, la valeur de ce qui apparai\*^t e\*^tre un litte\*'ral de liste est simplement la valeur de l'e\*'le\*'ment final, comme avec l'ope\*'rateur virgule en C. Par exemple, .PP .Vb 1 \& @foo = ('cc', '\-E', $bar); .Ve .PP affecte la totalite\*' de la valeur de liste au tableau \f(CW@foo\fR, mais .PP .Vb 1 \& $foo = ('cc', '\-E', $bar); .Ve .PP affecte la valeur de la variable \f(CW$bar\fR a\*` la variable \f(CW$foo\fR. Notez que la valeur d'un ve\*'ritable tableau dans un contexte scalaire est la longueur du tableau\ ; ce qui suit affecte la valeur 3 a\*` \f(CW$foo\fR\ : .PP .Vb 2 \& @foo = ('cc', '\-E', $bar); \& $foo = @foo; # $foo prend la valeur 3 .Ve .PP Vous pouvez avoir une virgule optionnelle avant la parenthe\*`se fermante d'un litte\*'ral de liste, vous pouvez donc dire\ : .PP .Vb 5 \& @foo = ( \& 1, \& 2, \& 3, \& ); .Ve .PP Pour utiliser un here-document afin d'affecter un tableau, une ligne par e\*'le\*'ment, vous pourriez utiliser l'approche suivante\ : .PP .Vb 7 \& @sauces = <\*(C'\fR dans les paires cle\*'/valeur. L'ope\*'rateur \f(CW\*(C`=>\*(C'\fR est principalement le synonyme d'une virgule mais visuellement plus clair. Il permet aussi a\*` son ope\*'rande de gauche d'e\*^tre interpre\*'te\*' comme une chai\*^ne, si c'est un bareword qui serait un identifiant le\*'gal (\f(CW\*(C`=>\*(C'\fR n'agit tout de me\*^me pas sur les identifiants compose\*'s, ceux qui contiennent des deux\-points). Cela rend plus jolie l'initialisation des hachages\ : .PP .Vb 5 \& %map = ( \& red => 0x00f, \& blue => 0x0f0, \& green => 0xf00, \& ); .Ve .PP ou pour initialiser les re\*'fe\*'rences de hachage devant e\*^tre utilise\*'es en tant qu'enregistrements\ : .PP .Vb 5 \& $rec = { \& witch => 'Mable the Merciless', \& cat => 'Fluffy the Ferocious', \& date => '10/31/1776', \& }; .Ve .PP ou pour utiliser l'appel par variables pour les fonctions complique\*'es\ : .PP .Vb 7 \& $field = $query\->radio_group( \& name => 'group_name', \& values => ['eenie','meenie','minie'], \& default => 'meenie', \& linebreak => 'true', \& labels => \e%labels \& ); .Ve .PP Notez que ce n'est pas parce qu'un hachage est initialise\*' dans un certain ordre qu'il ressortira dans cet ordre. Voir \f(CW\*(C`sort()\*(C'\fR pour des exemples sur la fac\*,on de s'arranger pour obtenir des sorties ordonne\*'es. .Sh "Indices" .IX Subsection "Indices" L'acce\*`s aux e\*'le\*'ments d'un tableau s'effectue en e\*'crivant le symbole dollar (\f(CW\*(C`$\*(C'\fR) puis le nom du tableau (sans le \f(CW\*(C`@\*(C'\fR initial) puis l'indice de l'e\*'le\*'ment voulu entre crochets. Par exemple\ : .PP .Vb 2 \& @tableau = (5, 50, 500, 5000); \& print "L'e\*'le\*'ment nume\*'ro 2 est : ", $tableau[2], "\en"; .Ve .PP Les indices dans les tableaux commencent a\*` 0. Un indice ne\*'gatif retrouve les e\*'le\*'ments en partant de la fin du tableau. Dans notre exemple, \f(CW$tableau[\-1]\fR vaut 5000 et \f(CW$tableau[\-2]\fR vaut 500. .PP L'acce\*`s aux e\*'le\*'ments d'une table de hachage est similaire sauf qu'on utilise des accolades a\*` la place des crochets. Par exemple\ : .PP .Vb 7 \& %scientifiques = \& ( \& "Newton" => "Isaac", \& "Einstein" => "Albert", \& "Darwin" => "Charles", \& "Feynman" => "Richard", \& ); \& \& print "Le pre\*'nom de Darwin est ", $scientifiques{"Darwin"}, "\en"; .Ve .Sh "Tranches" .IX Xref "tranches slice tranche de tableau tranche de hachage" .IX Subsection "Tranches" Une fac\*,on commune d'acce\*'der a\*` un tableau ou a\*` un hachage est d'en prendre un e\*'le\*'ment a\*` la fois. Vous pouvez aussi indicer une liste pour en obtenir un seul e\*'le\*'ment. .PP .Vb 3 \& $whoami = $ENV{"USER"}; # un e\*'le\*'ment du hachage \& $parent = $ISA[0]; # un e\*'le\*'ment du tableau \& $dir = (getpwnam("daemon"))[7]; # idem, mais avec une liste .Ve .PP Une tranche acce\*`de a\*` plusieurs e\*'le\*'ments d'une liste, d'un tableau ou d'un hachage simultane\*'ment en utilisant une liste d'indices. C'est plus pratique que d'e\*'crire les e\*'le\*'ments individuellement sous la forme d'une liste de valeurs scalaires se\*'pare\*'es. .PP .Vb 4 \& ($him, $her) = @folks[0,\-1]; # tranche de tableau \& @them = @folks[0 .. 3]; # tranche de tableau \& ($who, $home) = @ENV{"USER", "HOME"}; # tranche de hachage \& ($uid, $dir) = (getpwnam("daemon"))[2,7]; # tranche de liste .Ve .PP Puisque vous pouvez affecter a\*` une liste de variables, vous pouvez aussi affecter a\*` une tranche de tableau ou de hachage. .PP .Vb 4 \& @days[3..5] = qw/Wed Thu Fri/; \& @colors{'red','blue','green'} \& = (0xff0000, 0x0000ff, 0x00ff00); \& @folks[0, \-1] = @folks[\-1, 0]; .Ve .PP Les affectations pre\*'ce\*'dentes sont exactement e\*'quivalents a\*` .PP .Vb 4 \& ($days[3], $days[4], $days[5]) = qw/Wed Thu Fri/; \& ($colors{'red'}, $colors{'blue'}, $colors{'green'}) \& = (0xff0000, 0x0000ff, 0x00ff00); \& ($folks[0], $folks[\-1]) = ($folks[\-1], $folks[0]); .Ve .PP Puisque changer une tranche change le tableau ou le hachage original dont la tranche est issue, une structure \f(CW\*(C`foreach\*(C'\fR alte\*`rera certaines \*(-- ou me\*^me toutes les \*(-- valeurs du tableau ou du hachage. .PP .Vb 1 \& foreach (@array[ 4 .. 10 ]) { s/peter/paul/ } \& \& foreach (@hash{qw[key1 key2]}) { \& s/^\es+//; # supprime les espaces au de\*'but des e\*'le\*'ments \& s/\es+$//; # supprime les espaces a\*` la fin des e\*'le\*'ments \& s/(\ew+)/\eu\eL$1/g; # met une majuscule aux mots \& } .Ve .PP Une tranche d'une liste vide est encore une liste vide. Ainsi\ : .PP .Vb 3 \& @a = ()[1,0]; # @a n'a pas d'e\*'le\*'ments \& @b = (@a)[0,1]; # @b n'a pas d'e\*'le\*'ments \& @c = (0,1)[2,3]; # @c n'a pas d'e\*'le\*'ments .Ve .PP Mais\ : .PP .Vb 2 \& @a = (1)[1,0]; # @a a deux e\*'le\*'ments \& @b = (1,undef)[1,0,2]; # @b a trois e\*'le\*'ments .Ve .PP Ceci rend aise\*'e l'e\*'criture de boucles qui se terminent lorsqu'une liste nulle est renvoye\*'e\ : .PP .Vb 3 \& while ( ($home, $user) = (getpwent)[7,0]) { \& printf "%\-8s %s\en", $user, $home; \& } .Ve .PP Comme note\*' pre\*'ce\*'demment dans ce document, le sens scalaire de l'affectation de liste est le nombre d'e\*'le\*'ments de la partie droite de l'affectation. La liste nulle ne contient pas d'e\*'le\*'ments, donc lorsque le fichier de mots de passe est vide\*', le re\*'sultat est 0 et non pas 2. .PP Si vous e\*^tes trouble\*' par le pourquoi de l'usage d'un '@' ici sur une tranche de hachage au lieu d'un '%', pensez-y ainsi. Le type de parenthe\*'sage (avec des crochets ou des accolades) de\*'cide si c'est un tableau ou un hachage qui est examine\*'. D'un autre co\*^te\*', le symbole en pre\*'fixe ('$' ou '@') du tableau ou du hachage indique si vous re\*'cupe\*'rez une valeur simple (un scalaire) ou une valeur multiple (une liste). .Sh "Typeglobs et handles de Fichiers" .IX Xref "typeglob handle de fichier *" .IX Subsection "Typeglobs et handles de Fichiers" Perl utilise un type interne appele\*' un \fItypeglob\fR pour contenir une entre\*'e comple\*`te de table de symbole. Le pre\*'fixe de type d'un typeglob est une \f(CW\*(C`*\*(C'\fR, parce qu'il repre\*'sente tous les types. Ceci fut la manie\*`re favorite de passer par re\*'fe\*'rence a\*` une fonction des tableaux et des hachages, mais maintenant que nous avons de vraies re\*'fe\*'rences, c'est rarement ne\*'cessaire. .PP Le principal usage des typeglobs dans le Perl moderne est de cre\*'er des alias de table de symbole. Cette affectation\ : .PP .Vb 1 \& *this = *that; .Ve .PP fait de \f(CW$this\fR un alias de \f(CW$that\fR, \f(CW@this\fR un alias de \f(CW@that\fR, \f(CW%this\fR un alias de \&\f(CW%that\fR, &this un alias de &that, etc. Il est bien plus su\*^r d'utiliser une re\*'fe\*'rence. Ceci\ : .PP .Vb 1 \& local *Here::blue = \e$There::green; .Ve .PP fait temporairement de \f(CW$Here::blue\fR un alias de \f(CW$There::green\fR, mais ne fait pas de \f(CW@Hzere::blue\fR un alias de \f(CW@There::green\fR, ou de \f(CW%Here::blue\fR un alias de \&\f(CW%There::green\fR, etc. Voir \*(L"Tables de Symboles\*(R" in perlmod pour plus d'exemples de ceci. Aussi e\*'trange que cela puisse parai\*^tre, c'est la base de tout le syste\*`me d'import/export de module. .PP Un autre usage des typeglobs est le passage de handles de fichiers a\*` une fonction, ou la cre\*'ation de nouveaux handles de fichiers. Si vous avez besoin d'utiliser un typeglob pour sauvegarder un handle de fichier, faites-le de cette fac\*,on\ : .PP .Vb 1 \& $fh = *STDOUT; .Ve .PP ou peut\-e\*^tre comme une vraie re\*'fe\*'rence, comme ceci\ : .PP .Vb 1 \& $fh = \e*STDOUT; .Ve .PP Voir perlsub pour des exemples d'usages de ceci comme handles de fichiers indirects dans des fonctions. .PP Les typeglobs sont aussi une fac\*,on de cre\*'er un handle de fichier local en utilisant l'ope\*'rateur \fIlocal()\fR. Ceux-ci ne durent que jusqu'a\*` ce que leur bloc soit termine\*', mais peuvent e\*^tre passe\*'s en retour. Par exemple\ : .PP .Vb 7 \& sub newopen { \& my $path = shift; \& local *FH; # not my! \& open (FH, $path) || return undef; \& return *FH; \& } \& $fh = newopen('/etc/passwd'); .Ve .PP Maintenant que nous avons la notation \f(CW*foo{THING}\fR, les typeglobs ne sont plus autant utilise\*'s pour les manipulations de handles de fichiers, me\*^me s'ils sont toujours ne\*'cessaires pour passer des fichiers tout neufs et des handles de re\*'pertoire dans les fonctions. C'est parce que \f(CW*HANDLE{IO}\fR ne fonctionne que si \s-1HANDLE\s0 a de\*'ja\*` e\*'te\*' utilise\*' en tant que handle. En d'autres termes, \&\f(CW*FH\fR doit e\*^tre utilise\*' pour cre\*'er de nouvelles entre\*'es de table de symboles\ ; \f(CW*foo{THING}\fR ne le peut pas. En cas de doute, utilisez \&\f(CW*FH\fR. .PP Toutes les fonctions qui sont capables de cre\*'er des handles de fichiers (\fIopen()\fR, \fIopendir()\fR, \fIpipe()\fR, \fIsocketpair()\fR, \fIsysopen()\fR, \fIsocket()\fR, et \fIaccept()\fR) cre\*'ent automatiquement un handle de fichier anonyme si le handle qui leur est passe\*' est une variable scalaire non initialise\*'e. Ceci permet aux constructions telles que \f(CW\*(C`open(my $fh, ...)\*(C'\fR et \f(CW\*(C`open(local $fh,...)\*(C'\fR d'e\*^tre utilise\*'es pour cre\*'er des handles de fichiers qui seront convenablement et automatiquement ferme\*'s lorsque la porte\*'e se termine, pourvu qu'il n'existe aucune autre re\*'fe\*'rence vers eux. Ceci e\*'limine largement le besoin pour les typeglobs lors de l'ouverture des handles de fichiers qui doivent e\*^tre passe\*'s a\*` droite et a\*` gauche, comme dans l'exemple suivant\ : .PP .Vb 5 \& sub myopen { \& open my $fh, "@_" \& or die "Can't open '@_': $!"; \& return $fh; \& } \& \& { \& my $f = myopen("; \& # $f implicitly closed here \& } .Ve .PP Notez que si un scalaire de\*'ja\*` initialise\*' est utilise\*', cela a un effet diffe\*'rent\ : \f(CW\*(C`my $fh='zzz'; open($fh, ...)\*(C'\fR est e\*'quivalent a\*` \&\f(CW\*(C`open( *{'zzz'}, ...)\*(C'\fR. \f(CW\*(C`use strict 'refs'\*(C'\fR interdit cela. .PP Une autre fac\*,on de cre\*'er des handles de fichiers anonymes est d'utiliser le module Symbol ou le module IO::Handle et ceux de son acabit. Ces modules ont l'avantage de ne pas cacher les diffe\*'rents types du me\*^me nom pendant le \&\fIlocal()\fR. Voir la fin de la documentation de la fonction \f(CW\*(C`open()\*(C'\fR pour un exemple. .SH "VOIR AUSSI" .IX Header "VOIR AUSSI" Voir perlvar pour une description des variables inte\*'gre\*'es de Perl et une discussion des noms de variable le\*'gaux. Voir perlref, perlsub, et \&\*(L"Tables de Symboles\*(R" in perlmod pour plus de de\*'tails sur les typeglobs et la syntaxe \f(CW*foo{THING}\fR. .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 \&\fIpaul.gaborit at enstimac.fr\fR. .Sh "Relecture" .IX Subsection "Relecture" Jim Fox <\fIfox@sugar\-land.dowell.slb.com\fR>, Etienne Gauthier <\fIegauthie@capgemini.fr\fR>, Ge\*'rard Delafond