perldata - Types de données de Perl
Perl a trois structures de données : les scalaires, les tableaux de scalaires, et les tableaux associatifs de scalaires, appelés ``hachages''. Les tableaux normaux sont indexés par des nombres, en commençant par 0 (les indices négatifs sont comptés depuis la fin). Les tables de hachages sont indexées par des chaînes.
On fait habituellement référence aux valeurs par leur nom (ou par une
référence nommée). Le premier caractère du nom vous indique à quel type de
structure de données il correspond. Le reste du nom vous dit à quelle
valeur particulière il fait référence. La plupart du temps, il consiste en
un simple identifiant, c'est-à-dire une chaîne commençant par une lettre ou un caractère
souligné, et contenant des lettres, des soulignés, et des chiffres. Dans
certains cas, il peut être une chaîne d'identifiants, séparés par :: (ou par ', mais ceci est désapprouvé) ; tous sauf le dernier sont interprétés comme
des noms de paquetages, pour localiser l'espace de nommage dans lequel
l'identifiant final doit être recherché (voir Packages pour plus de détails). Il est possible de substituer à un simple
identifiant une expression qui produit une référence à la valeur lors de
l'exécution ; ceci est décrit plus en détails plus bas, et dans
la page de manuel perlref.
Il existe aussi des variables spéciales dont les noms ne suivent pas ces
règles, pour qu'elles ne rentrent pas en collision avec l'une de vos
variables normales. Les chaînes qui correspondent aux parties entre
parenthèses d'une expression rationnelle sont sauvées sous des noms qui ne
contiennent que des chiffres après le $ (voir la page de manuel perlop
et la page de manuel perlre). De plus, plusieurs variables spéciales qui ouvrent des fenêtres dans le
fonctionnement interne de Perl ont des noms contenant des signes de
ponctuation (voir la page de manuel perlvar).
Les valeurs scalaires sont toujours désignées par un '$', même si l'on se réfère à un scalaire qui fait partie d'un tableau. Cela fonctionne comme les mots ``le'', ``la''. Ainsi, nous avons :
$days # la simple valeur scalaire "days"
$days[28] # le 29ème élément du tableau @days
$days{'Feb'} # la veleur 'Feb' dans le hachage %days
$#days # le dernier indice du tableau @days
mais les tableaux complets ou les tranches de tableaux sont dénotés par '@', qui fonctionne plutôt comme le mot ``ces'' :
@days # ($days[0], $days[1],... $days[n])
@days[3,4,5] # identique à @days[3..5]
@days{'a','c'} # identique à ($days{'a'},$days{'c'})
et les hachages complets sont dénotés par '%':
%days # (clé1, valeur1, clé2, valeur2 ...)
De plus, les sous-programmes sont nommés avec un '&' initial, bien que ce soit optionel lorsqu'il n'y a pas d'ambigüité (tout comme ``faire'' est souvent redondant en français). Les entrées des tables de symboles peuvent être nommées avec un '*' initial, mais vous ne vous souciez pas vraiment de cela pour le moment.
Chaque type de variable a son propre espace de nommage. Vous pouvez, sans
craindre un conflit, utiliser le même nom pour une variable scalaire, un
tableau, ou un hachage (ou, pour cette affaire, un handle de fichier, un
nom de sous-programme, ou un label). Ceci veut dire que $foo
et @foo sont deux variables différentes. Ceci veut aussi dire
que $foo[1] fait partie de @foo, et pas de $foo. Cela peut sembler un peu étrange, mais
c'est normal, puisque c'est étrange.
Puisque les références aux variables et aux tableaux commencent toujours par '$', '@', ou '%', les mots ``réservés'' ne sont en fait pas réservés en ce qui concerne les noms de variables. (Ils SONT toutefois réservés en ce qui concerne les labels et les handles de fichiers, qui n'ont pas de caractère spécial initial. Vous ne pouvez pas avoir un handle de fichier nommé ``log'', par exemple. Indice : vous pourriez dire open(LOG,'logfile') plutôt que open(log,'logfile'). Utiliser des handles de fichiers en lettres majuscules améliore aussi la lisibilité et vous protège de conflits avec de futurs mots réservés). La casse EST significative -- ``FOO'', ``Foo'', et ``foo'' sont tous des noms différents. Les noms qui commencent par une lettre ou un caractère souligné peuvent aussi contenir des chiffres et des soulignés.
Il est possible de remplacer un tel nom alphanumérique par une expression qui retourne une référence à un objet de ce type. Pour une description de ceci, voir la page de manuel perlref.
Les noms qui commencent par un chiffre ne peuvent contenir que des
chiffres. Les noms qui ne commencent pas par une lettre, un souligné ou un
chiffre sont limités à un caractère, e.g., $% or $$ (La plupart de ces noms d'un seul caractère ont une signification
prédéfinie pour Perl. Par exemple, $$ est l'id. du processus courant).
L'interprétation des opérations et des valeurs en Perl dépend parfois des exigences du contexte de l'opération ou de la valeur. Il existe deux contextes majeurs : le contexte scalaire et le contexte de liste. Certaines opérations retournent des valeurs de liste dans les contextes qui réclament une liste, et des valeurs scalaires autrement (si ceci est vrai pour une opération alors cela sera mentionné dans la documentation pour cette opération). En d'autres termes, Perl surcharge certaines opérations selon que la valeur de retour attendue est singulière ou plurielle (certaines mots en français fonctionnent aussi de cette façon, comme ``lys'' et ``dos'').
Réciproquement, une opération fournit un contexte scalaire ou de liste à chacun de ses arguments. Par exemple, si vous dites
int( <STDIN> )
L'opération int fournit un contexte scalaire pour l'opérateur <STDIN>, qui répond en lisant une ligne depuis STDIN et en la passant à l'opération int, qui trouvera alors la valeur entière de cette ligne et retournera cela. Si, au contraire, vous dites
sort( <STDIN> )
alors l'opération sort fournit un contexte de liste pour <STDIN>, qui se mettra à lire toutes les lignes disponibles jusqu'à la fin du fichier, et passera cette liste de lignes à la routine de tri, qui triera alors ces lignes et les retournera en tant que liste à ce qui est le contexte de sort, quel qu'il soit.
L'assignation est un petit peu spéciale en ce sens qu'elle utilise son argument gauche pour déterminer le contexte de l'argument droit. L'assignation à un scalaire évalue la partie droite dans un contexte scalaire, tandis que l'assignation à un tableau ou à une tranche de tableau évalue la partie droite dans un contexte de liste. L'assignation à une liste évalue aussi la partie droite dans un contexte de liste.
Les sous-programmes définis par l'utilisateur peuvent se soucier d'avoir été appelés dans un contexte scalaire ou de liste, mais la plupart des sous-programmes n'en ont pas besoin, car les scalaires sont automatiquement interpolés en listes. Voir wantarray.
Toute donnée en Perl est un scalaire ou un tableau de scalaires ou un hachage de scalaires. Les variables scalaires peuvent contenir des formes variées de données singulières, comme des nombres, des chaînes, et des références. En général, la conversion d'une forme à une autre est transparente (un scalaire ne peut pas contenir des valeurs multiples, mais peut contenir une référence à un tableau ou à un hachage contenant des valeurs multiples). À cause de la conversion automatique des scalaires, les opérations et les fonctions qui retournent des scalaires n'ont pas besoin de (et, en fait, ne peuvent pas) se soucier si le contexte demande une chaîne ou un nombre.
Les scalaires ne sont pas nécessairement une chose ou une autre. Il n'y a pas d'endroit où déclarer qu'une variable scalaire doit être de type ``chaîne'', ou de type ``nombre'', ou de type ``handle de fichier'', ou n'importe quoi d'autre. Perl est un langage contextuellement polymorphe dont les scalaires peuvent être des chaînes, des nombres, ou des références (ce qui inclut les objets). Tandis que les chaînes et les nombres sont considérés comme presque la même chose pour pratiquement tous les usages, les références sont des pointeurs au typage fort et impossible à forcer, avec comptage de référence intégré et invocation de destructeur.
Une valeur scalaire est interprétée comme TRUE (VRAIE, NDT) au sens booléen si ce n'est pas une chaîne vide ou le nombre 0 (ou sous équivalent sous forme de chaîne, ``0''). Le contexte booléen est juste un genre spécial de contexte scalaire.
Il existe en fait deux variétés de scalaires nuls : définis et indéfinis.
Les scalaires nuls indéfinis sont retournés quand il n'y a pas vraiment de
valeur pour quelque chose, comme lorsqu'il s'est produit une erreur, ou à
la fin d'un fichier, ou quand on se réfère à une variable ou un élément de
tableau non initialisé. Un scalaire nul indéfini peut devenir défini la
première fois que vous l'utilisez comme s'il était défini, mais avant cela
vous pouvez utiliser l'opérateur defined() pour déterminer si
la valeur est définie ou non.
Pour trouver si une chaîne donnée est un nombre différent de zéro valide, il suffit habituellement de la tester à la fois avec le 0 numérique et le ``0'' lexical (bien que ceci provoquera du bruit en provenance de -w). C'est parce que les chaînes qui ne sont pas des nombres comptent comme 0, tout comme en awk :
if ($str == 0 && $str ne "0") {
warn "That doesn't look like a number";
}
C'est préférable habituellement parce qu'autrement vous ne traiteriez pas
correctement les notations IEEE comme NaN ou Infinity. À d'autres moments, vous pourriez préférer utiliser une expression
régulière pour vérifier si des données sont numériques. Voyez
la page de manuel perlre pour des détails sur les expressions régulières.
warn "has nondigits" if /\D/;
warn "not a whole number" unless /^\d+$/;
warn "not an integer" unless /^[+-]?\d+$/
warn "not a decimal number" unless /^[+-]?\d+\.?\d*$/
warn "not a C float"
unless /^([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/;
La longueur d'un tableau est une valeur scalaire. Vous pourriez trouver la
longueur du tableau @days en évaluant $#days, comme en
csh (En fait, ce n'est pas la longueur du tableau, c'est l'indice de son
dernier élément, parce qu'il y a (ordinairement) un élément numéro 0). Une
affectation à $#days change la longueur du tableau. Le raccourcissement d'un tableau par cette
méthode détruit les valeurs intermédiaires. L'agrandissement d'un tableau
ayant précédemment été raccourci ne récupère PLUS les valeurs qui étaient stockées dans ces éléments (c'était le cas en Perl
4, mais nous avons dû supprimer cela pour nous assurer que les destructeurs
sont bien appelés quand on s'y attend). Vous pouvez aussi gagner en
efficacité en pré-étendant un tableau qui va devenir gros (vous pouvez
aussi étendre un tableau en affectant des données à un élément qui est
au-delà de la fin du tableau). Vous pouvez tronquer totalement un tableau
en y affectant la liste vide (). Les expressions suivantes sont
équivalentes :
@whatever = ();
$#whatever = -1;
Si vous évaluez un tableau nommé dans un contexte scalaire, cela renvoit la longueur du tableau (notez que ceci n'est pas vrai pour les listes, qui renvoient leur dernière valeur, comme l'opérateur virgule en C). Ce qui suit est toujours vrai :
scalar(@whatever) == $#whatever - $[ + 1;
La version 5 de Perl a changé la sémantique de $[ : les fichiers qui ne fixent pas la valeur de $[ n'ont plus besoin de s'inquiéter de savoir si un autre fichier a changé sa
valeur (en d'autres termes, l'usage de $[ est désapprouvé). Donc de façon générale, vous pouvez présumer que
scalar(@whatever) == $#whatever + 1;
Certains programmeurs choisissent d'utiliser une conversion explicite pour que rien ne soit laissé au hasard :
$element_count = scalar(@whatever);
Si vous évaluez un hachage dans un contexte scalaire, vous obtenez une
valeur qui est vraie si et seulement si le hachage contient une paire
clé/valeur (s'il y a une paire clé/valeur quelconque, la valeur retournée
est une chaîne constituée du nombre de buckets utilisés et du nombre de
buckets alloués, séparés par un signe de division. Ceci n'a tendance à être
très utile que pour déterminer si les algorithmes de hachage (compilée) en
Perl ont des performances médiocres sur vos données. Par exemple, vous
mettez 10.000 trucs dans un hachage, mais l'évaluation de
%HASH dans un contexte scalaire révèle ``1/16'', ce qui
signifie qu'un seul des seize buckets a été touché, et contient
probablement tous vos 10,000 éléments. Cela ne devrait pas se produire).
Les littéraux numériques sont spécifiés dans un quelconque des formats courants de nombres entiers ou à virgule flottante :
12345
12345.67
.23E-10
0xffff # hexa
0377 # octal
4_294_967_296 # souligné pour la lisibilité
Les littéraux de chaîne sont habituellement délimités soit par des
apostrophes, soit par des guillemets. Ils fonctionnent beaucoup comme dans
un shell : les littéraux de chaîne entre guillemets sont sujets aux
substitutions de variables et au préfixage par barre oblique inverse ; les
chaînes entre apostrophes ne le sont pas (sauf pour ``\''' et ``\\''). Les règles habituelles d'utilisation de la barre oblique inverse sous
Unix s'appliquent aussi bien pour créer des caractères comme la nouvelle
ligne, la tabulation, etc., que sous des formes plus exotiques. Voir Quote and Quotelike Operators
pour une liste.
Les représentations octales ou hexadécimales sous formes de chaînes (e.g.
'0xffff') ne sont pas automatiquement converties sous leur représentation
entière. Les fonctions hex() et oct() font ces
conversions pour vous. Voir hex et oct pour plus de détails.
Vous pouvez aussi inclure des ``nouvelles lignes'' directement dans vos chaînes, i.e., elles peuvent se terminer sur une ligne différente de celles où elles ont commencé. C'est bien joli, mais si vous oubliez votre apostrophe de fin (ou votre guillemet - NDT), l'erreur ne sera pas rapportée avant que Perl n'ait trouvé une autre ligne comportant une apostrophe, qui peut se trouver bien plus loin dans le script. La substitution de variable à l'intérieur des chaînes est limitée aux variables scalaires, aux tableaux et aux tranches de tableau (en d'autres termes, des noms commençant par $ ou @, suivi d'une expression optionnelle entre crochets comme indice). Le segment de code qui suit affiche ``The price is $100.''
$Price = '$100'; # pas interprété
print "The price is $Price.\n"; # interprété
Comme dans certains shells, vous pouvez mettre des accolades autour d'un nom pour le séparer des caractères alphanumériques qui le suivent. En fait, un identificateur situé entre de telles accolades est forcé d'être une chaîne, tout comme l'est tout identificateur isolé à l'intérieur d'un indice d'un hachage. Notre exemple précédent,
$days{'Feb'}
peut être écrit sous la forme
$days{Feb}
et les apostrophes seront présumées automatiquement. Mais tout ce qui est plus compliqué dans l'indice sera interprété comme étant une expression.
Notez qu'une chaîne entre apostrophes doit être séparée du mot qui la précède par une espace, parce qu'une apostrophe est un caractère valide (bien que désapprouvé) dans le nom d'une variable (voir Paquetages).
Trois littéraux spéciaux sont __FILE__, __LINE__, et __PACKAGE__, qui représentent le nom de fichier courant, le numéro de la ligne, et le nom du paquetage à ce point de votre programme. Ils ne peuvent être utilisés que comme des mots-clé isolés ; ils ne seront pas interpolés dans les chaînes. S'il n'existe pas de paquetage courant (à cause d'une directive package;), __PACKAGE__ est la valeur indéfinie.
Les mots-clé __END__ et __DATA__ peuvent être utilisés pour indiquer la fin logique du script avant la fin véritable du fichier. Tout texte les suivant est ignoré, mais peut être lu via un handle de fichier DATA : main::DATA pour __END__, ou PACKNAME::DATA (où PACKNAME est le paquetage courant) pour __DATA__. Les deux caractères de contrôle ^D et ^Z sont des synonymes de __END__ (ou __DATA__ dans un module). Voir SelfLoader pour une description plus précise de __DATA__, et un exemple de son utilisation. Notez que vous ne pouvez pas lire depuis le handle de fichier DATA dans un bloc BEGIN : le bloc BEGIN est exécuté dès qu'il est rencontré (pendant la compilation), à un moment où le mot-clé __DATA__ (ou __END__) correspondant n'a pas encore été rencontré.
Un mot qui n'a aucune autre interprétation dans la grammaire sera traité comme s'il était une chaîne entre apostrophes. Ces mots sont connus sous le nom de ``barewords''. Comme pour les handles de fichier et les labels, un bareword constitué entièrement de lettres minuscules risque d'entrer en conflit avec de futurs mots réservés, et si vous utilisez l'option -w, Perl vous avertira pour chacun d'entre eux. Certaines personnes pourraient vouloir rendre les barewords totalement hors-la-loi. Si vous dites
use strict 'subs';
alors tout bareword qui ne serait PAS interprété comme un appel à un
sous-programme produit à la place une erreur au moment de la compilation.
La restriction continue jusqu'à la fin du bloc qui le contient. Un bloc
interne pourrait annuler ceci en disant no strict
'subs'.
Les tableaux sont interpolés en chaînes entre guillemets en joignant tous
les éléments du tableau avec le délimiteur spécifié dans la variable $" ($LIST_SEPARATOR dans le paquetage English.pm), une espace par défaut. Les expressions
suivantes sont équivalentes :
$temp = join($",@ARGV);
system "echo $temp";
system "echo @ARGV";
À l'intérieur d'un motif de recherche (qui subit aussi la substitution
entre guillemets) il y a une vilaine ambigüité : est-ce que
/$foo[bar]/ doit être interprété comme /${foo}[bar]/ (où
[bar] est une classe de caractères pour l'expression régulière) ou comme /${foo[bar]}/ (où [bar] est un indice du tableau @foo)? Si @foo n'existe pas par
ailleurs, alors c'est évidemment une classe de caractères. Si
@foo existe, Perl choisit de deviner la valeur de
[bar], et il a presque toujours raison. S'il se trompe, ou si vous êtes
simplement complètement paranoïaque, vous pouvez forcer l'interprétation
correcte avec des accolades comme ci-dessus.
Une forme de citation orientée ligne est basée sur la syntaxe ``here-doc''
du shell. Après un << vous spécifiez une chaîne pour terminer le matériel cité, et toutes les
lignes qui suivent la ligne courante jusqu'à la chaîne de terminaison
forment la valeur de l'élément. La chaîne de terminaison peut être soit un
identificateur (un mot), ou du texte cité. S'il est entre guillemets, le
type de guillemets que vous utilisez détermine le traitement du texte, tout
comme dans une citation normale. Un identificateur sans guillemets
fonctionne comme des guillemets normaux. Il ne doit pas y avoir d'espace
entre le << et l'identificateur (si vous mettez une espace, elle sera traitée comme un
identificateur nul, ce qui est valide, et correspond à la première ligne
vide). La chaîne de terminaison doit apparaître toute seule (sans
guillemets et sans espaces l'entourant) sur la ligne de terminaison.
print <<EOF;
The price is $Price.
EOF
print <<"EOF"; # comme ci-dessus
The price is $Price.
EOF
print <<`EOC`; # exécute les commandes
echo hi there
echo lo there
EOC
print <<"foo", <<"bar"; # vous pouvez les empiler
I said foo.
foo
I said bar.
bar
myfunc(<<"THIS", 23, <<'THAT');
Here's a line
or two.
THIS
and here's another.
THAT
N'oubliez simplement pas que vous devez mettre un point-virgule à la fin pour terminer la déclaration, car Perl ne sait pas que vous n'allez pas essayer de faire ceci :
print <<ABC
179231
ABC
+ 20;
Les valeurs de liste sont dénotées en séparant les valeurs individuelles par des virgules (et en enfermant la liste entre parenthèses lorsque la précédence le requiert) :
(LIST)
Dans un contexte qui ne requiert pas une valeur de liste, la valeur du littéral de liste est la valeur de l'élément final, comme avec l'opérateur virgule en C. Par exemple,
@foo = ('cc', '-E', $bar);
affecte la totalité de la valeur de liste au tableau foo, mais
$foo = ('cc', '-E', $bar);
affecte la valeur de la variable bar à la variable foo. Notez que la valeur
d'un véritable tableau dans un contexte scalaire est la longueur du tableau
; ce qui suit affecte la valeur 3 à $foo :
@foo = ('cc', '-E', $bar);
$foo = @foo; # $foo prend la valeur 3
Vous pouvez avoir une virgule optionnelle avant la parenthèse fermante d'un littéral de liste, vous pouvez donc dire :
@foo = (
1,
2,
3,
);
Les LIST font une interpolation automatique des sous-listes. C'est-à-dire que lorsqu'une LIST est évaluée, chaque élément de la liste est évalué dans un contexte de liste, et la valeur de liste résultante est interpolée en LIST tout comme si chaque élément était un membre de LIST. Ainsi les tableaux perdent leur identité dans une LIST - la liste
(@foo,@bar,&SomeSub)
contient tous les éléments de @foo suivis par tous les
éléments de @bar, suivis par tous les éléments retournés par le
sous-programme appelé SomeSub quand il est appelé dans un contexte de
liste. Pour faire une référence à une liste qui NE soit PAS interpolée, voir
la page de manuel perlref.
La liste vide est représentée par (). L'interpoler dans une liste n'a aucun effet. Ainsi, ((),(),()) est équivalent à (). De façon similaire, interpoler un tableau qui ne contient pas d'élément revient à ce qu'aucun tableau n'ait été interpolé à ce moment-là.
Une valeur de liste peut aussi être indicée comme un tableau normal. Vous devez mettre la liste entre parenthèses pour éviter les ambiguïtés. Par exemple :
# Stat renvoit une valeur de liste.
$time = (stat($file))[8];
# ICI, ERREUR DE SYNTAXE.
$time = stat($file)[8]; # OOPS, OUBLI DES PARENTHESES
# Trouver un chiffre hexadécimal.
$hexdigit = ('a','b','c','d','e','f')[$digit-10];
# Un "opérateur virgule inversé".
return (pop(@foo),pop(@foo))[0];
Vous pouvez affecter à undef dans une liste. C'est pratique pour balancer certaines valeurs de retour d'une fonction :
($dev, $ino, undef, undef, $uid, $gid) = stat($file);
Les listes peuvent être affectées si et seulement si chaque élément de la liste peut l'être lui aussi :
($a, $b, $c) = (1, 2, 3);
($map{'red'}, $map{'blue'}, $map{'green'}) = (0x00f, 0x0f0, 0xf00);
L'affectation de liste dans un contexte scalaire renvoit le nombre d'éléments produits par l'expression du côté droit de l'affectation :
$x = (($foo,$bar) = (3,2,1)); # met 3 dans $x, pas 2
$x = (($foo,$bar) = f()); # met le nombre de valeurs de retour de f() dans $x
Ceci est très pratique lorsque vous voulez faire une affectation de liste dans un contexte booléen, parce que la plupart des fonctions de liste renvoient une liste vide quand elle se terminent, ce qui donne un 0 quand on l'affecte, 0 qui est interprété comme FALSE (FAUX - NDT).
L'élément final peut être un tableau ou un hachage :
($a, $b, @rest) = split;
local($a, $b, %rest) = @_;
Vous pouvez en vérité mettre un tableau ou un hachage n'importe où dans la
liste, mais le premier situé dans la liste va aspirer toutes les valeurs,
et tout ce qui le suivra prendra une valeur nulle. Cela peut être pratique
dans un local() ou un my().
Un littéral de hachage contient des paires de valeurs qui doivent être interprétées comme une clé et une valeur :
# identique à l'affectation de map ci-dessus
%map = ('red',0x00f,'blue',0x0f0,'green',0xf00);
Tandis que les littéraux de liste et les tableaux nommés sont habituellement interchangeables, ce n'est pas le cas pour les hachages. Le simple fait que vous puissiez indicer une valeur de liste comme un tableau normal ne veut pas dire que vous pouvez indicer une valeur de liste comme un hachage. De la même manière, les hachages inclus comme parties d'autres listes (y compris les listes de paramètres et les listes de retour de fonctions) s'aplatissent toujours en paires clé/valeur. C'est pourquoi il est parfois bon d'utiliser des références.
Il est parfois plus lisible d'utiliser l'opérateur => dans les paires clé/valeur. L'opérateur => est principalement juste un synonyme plus clair visuellement qu'une
virgule, mais il permet aussi à son opérande de gauche d'être interprété
comme une chaîne, si c'est un bareword qui serait un identifiant légal.
Cela rend plus jolie l'initialisation des hachages :
%map = (
red => 0x00f,
blue => 0x0f0,
green => 0xf00,
);
ou pour initialiser les références de hachage devant être utilisées en tant qu'enregistrements :
$rec = {
witch => 'Mable the Merciless',
cat => 'Fluffy the Ferocious',
date => '10/31/1776',
};
ou pour utiliser l'appel par variables pour les fonctions compliquées :
$field = $query->radio_group(
name => 'group_name',
values => ['eenie','meenie','minie'],
default => 'meenie',
linebreak => 'true',
labels => \%labels
);
Notez que ce n'est pas parce qu'un hachage est initialisé dans un certain ordre qu'il ressortira dans cet ordre. Voir sort pour des exemples sur la façon de s'arranger pour obtenir des sorties ordonnées.
Perl utilise un type interne appelé un typeglob pour contenir une entrée complète de table de symbole. Le préfixe de type
d'un typeglob est une *, parce qu'il représente tous les types. Ceci fut la manière favorite de
passer par référence à une fonction des tableaux et des hachages, mais
maintenant que nous avons de vraies références, c'est rarement nécessaire.
Ce fut aussi une façon habituelle de passer des handles de fichiers à une
fonction, mais maintenant que nous avons la notation *foo{MACHIN}, ce n'est
pas souvent nécessaire non plus. Il est toujours nécessaire de passer ainsi
les nouveaux handles de fichiers (*HANDLE{IO} fonctionne uniquement si
HANDLE a déjà été utilisé).
Si vous avez besoin d'utiliser un typeglob pour sauver un handle de fichier, faites-le de cette façon :
$fh = *STDOUT;
ou peut être comme une vraie référence, comme ceci :
$fh = \*STDOUT;
C'est aussi un moyen de créer un handle de fichier local. Par exemple :
sub newopen {
my $path = shift;
local *FH; # not my!
open (FH, $path) || return undef;
return *FH;
}
$fh = newopen('/etc/passwd');
Une autre façon de créer des handles de fichier locaux est d'utiliser IO::Handle et compagnie, voir la fin de open().
Voir la page de manuel perlref, perlsub, et Tables de Symboles pour plus d'informations sur les typeglobs.
Roland Trique <roncevaux@mail.dotcom.fr>
Jim Fox <fox@sugar-land.dowell.slb.com> Etienne Gauthier <egauthie@capgemini.fr>