perlreftut - En ligne dans le Cloud

PROGRAMME:

Nom

perlreftut - Le très court tutoriel de Mark sur les références

DESCRIPTION

L’une des nouvelles fonctionnalités les plus importantes de Perl 5 était la capacité de gérer des langages complexes.
Structures de données telles que tableaux multidimensionnels et hachages imbriqués. Pour les activer, Perl 5
introduit une fonctionnalité appelée « références », et l'utilisation des références est la clé de la gestion
données complexes et structurées en Perl. Malheureusement, la syntaxe est souvent étrange.
apprendre, et la page principale du manuel peut être difficile à suivre. Le manuel est assez complet, et
Parfois, les gens trouvent cela problématique, car il peut être difficile de dire ce qui est important et
ce qui n'est pas.

Heureusement, il vous suffit de connaître 10 % du contenu de la page principale pour obtenir 90 % du contenu.
avantage. Cette page vous montrera que 10 %.

Qui sommes-nous Besoins Compliqué Date Des structures ?

Un problème récurrent est le besoin d'un hachage dont les valeurs sont des listes. Perl a
des hachages, bien sûr, mais les valeurs doivent être des scalaires ; elles ne peuvent pas être des listes.

Pourquoi vouloir un hachage de listes ? Prenons un exemple simple : vous avez un fichier de villes.
et les noms de pays, comme ceci :

Chicago, États-Unis
Francfort, Allemagne
Berlin, Allemagne
Washington, États-Unis
Helsinki, Finlande
New York, États-Unis

et vous souhaitez produire un résultat comme celui-ci, avec chaque pays mentionné une fois, puis un
liste alphabétique des villes de ce pays :

Finlande : Helsinki.
Allemagne : Berlin, Francfort.
États-Unis : Chicago, New York, Washington.

La manière naturelle de procéder est d'avoir un hachage dont les clés sont des noms de pays.
À chaque nom de pays correspond une liste des villes de ce pays. Chaque fois que vous lisez un
ligne de saisie, divisez-la en un pays et une ville, recherchez la liste des villes déjà
Si vous savez que vous êtes dans ce pays, ajoutez la nouvelle ville à la liste. Une fois terminé,
en lisant l'entrée, parcourez le hachage comme d'habitude, en triant chaque liste de villes avant vous
imprime-le.

Si les valeurs de hachage ne pouvaient pas être listées, vous perdriez. Il faudrait probablement combiner toutes les villes.
en une seule chaîne d'une manière ou d'une autre, et ensuite, lorsque le moment est venu d'écrire la sortie, vous devez
décomposer la chaîne en une liste, trier la liste et la reconvertir en chaîne. Ceci est
brouillon et source d'erreurs. Et c'est frustrant, car Perl possède déjà de très bonnes
des listes qui résoudraient le problème si seulement vous pouviez les utiliser.

Le manuel de formation Solution

Au moment où Perl 5 est arrivé, nous étions déjà coincés avec cette conception : les valeurs de hachage doivent
être des scalaires. La solution à ce problème réside dans les références.

Une référence est une valeur scalaire qui se réfère à un tableau entier ou un hachage entier (ou simplement
(à propos de tout autre chose). Les noms sont un type de référence que vous connaissez déjà.
Pensez au président des États-Unis : un sac de sang et d’os désordonné et peu pratique.
Mais pour parler de lui, ou pour le représenter dans un programme informatique, il suffit de
chaîne scalaire facile et pratique « Barack Obama ».

En Perl, les références sont comme les noms des tableaux et des tables de hachage. Ce sont les éléments privés et internes de Perl.
noms, pour être sûr qu'ils sont sans ambiguïté. Contrairement à « Barack Obama », une simple référence
fait référence à une chose, et vous savez toujours à quoi cela fait référence. Si vous avez une référence à une
tableau, vous pouvez récupérer l'intégralité du tableau. Si vous avez une référence à un hachage, vous
peut récupérer l'intégralité du hachage. Cependant, la référence reste une valeur scalaire simple et compacte.

Vous ne pouvez pas avoir un hachage dont les valeurs sont des tableaux ; les valeurs de hachage ne peuvent être que des scalaires. Nous
Je suis coincé avec ça. Mais une seule référence peut faire référence à un tableau entier, et les références sont
scalaires, vous pouvez donc avoir un hachage de références à des tableaux, et cela agira beaucoup comme un hachage
de tableaux, et ce sera tout aussi utile qu'un hachage de tableaux.

Nous reviendrons sur ce problème ville-campagne plus tard, après avoir vu une syntaxe pour
gestion des références.

Syntaxe

Il n'y a que deux façons de créer une référence et seulement deux façons de l'utiliser une fois que vous l'avez.

Fabrication Références
Marque Règle 1

Si vous mettez un « \" devant une variable, vous obtenez une référence à cette variable.

$aref = \@array; # $aref contient désormais une référence à @array
$href = \%hash; # $href contient désormais une référence à %hash
$sref = \$scalar; # $sref contient désormais une référence à $scalar

Une fois la référence stockée dans une variable comme $aref ou $href, vous pouvez la copier ou la stocker
c'est exactement la même chose que n'importe quelle autre valeur scalaire :

$xy = $aref; # $xy contient désormais une référence à @array
$p[3] = $href; # $p[3] contient désormais une référence à %hash
$z = $p[3]; # $z contient désormais une référence à %hash

Ces exemples montrent comment faire référence à des variables avec des noms. Parfois, vous souhaitez
Créez un tableau ou une table de hachage sans nom. C'est une méthode analogue à celle que vous utilisez.
pour pouvoir utiliser la chaîne "\n" ou le nombre 80 sans avoir à le stocker dans un répertoire nommé
variable en premier.

Marque Règle 2

« [ ITEMS ] » crée un nouveau tableau anonyme et renvoie une référence à ce tableau. « { ITEMS
}" crée un nouveau hachage anonyme et renvoie une référence à ce hachage.

$aref = [ 1, "foo", indéfini, 13 ];
# $aref contient désormais une référence à un tableau

$href = { AVR => 4, AOÛT => 8 };
# $href contient désormais une référence à un hachage

Les références que vous obtenez de la règle 2 sont du même type que celles que vous obtenez de la règle
1:

# Ce:
$aref = [ 1, 2, 3 ];

# Fait la même chose que ceci :
@array = (1, 2, 3);
$aref = \@array;

La première ligne est une abréviation des deux lignes suivantes, sauf qu'elle ne
créez la variable de tableau superflue @array.

Si vous écrivez simplement « [] », vous obtenez un nouveau tableau anonyme vide. Si vous écrivez simplement « {} », vous
obtenir un nouveau hachage anonyme vide.

En utilisant Références
Que peut-on faire avec une référence une fois qu'on l'a ? C'est une valeur scalaire, et nous l'avons vu.
que vous pouvez le stocker comme un scalaire et le récupérer comme n'importe quel scalaire. Il y a
juste deux autres façons de l'utiliser :

Utilisez le Règle 1

Vous pouvez toujours utiliser une référence de tableau, entre accolades, à la place du nom d'un tableau.
Par exemple, « @{$aref} » au lieu de @array.

Voici quelques exemples :

Tableaux:

@a @{$aref} Un tableau
reverse @a reverse @{$aref} Inverse le tableau
$a[3] ${$aref}[3] Un élément du tableau
$a[3] = 17; ${$aref}[3] = 17 Affectation d'un élément

Sur chaque ligne se trouvent deux expressions qui font la même chose. Les versions de gauche fonctionnent
sur le tableau @a. Les versions de droite fonctionnent sur le tableau référencé par
$aref. Une fois le tableau sur lequel elles opèrent trouvé, les deux versions effectuent la même opération.
les tableaux.

L'utilisation d'une référence de hachage est exactement le même:

%h %{$href} Un hachage
clés %h clés %{$href} Récupérer les clés du hachage
$h{'red'} ${$href}{'red'} Un élément du hachage
$h{'red'} = 17 ${$href}{'red'} = 17 Affectation d'un élément

Quoi que vous souhaitiez faire avec une référence, Utilisez le Règle 1 vous explique comment le faire. Vous n'avez qu'à
écrivez le code Perl que vous auriez écrit pour faire la même chose à un programme normal
tableau ou hachage, puis remplacez le nom du tableau ou du hachage par « {$reference} ». « Comment puis-je
boucler sur un tableau alors que je n'ai qu'une référence ? » Eh bien, pour boucler sur un tableau, vous
écrirait

pour mon $element (@array) {
...
}

remplacez donc le nom du tableau, @array, par la référence :

pour mon $element (@{$aref}) {
...
}

« Comment puis-je imprimer le contenu d'un hachage si je n'ai qu'une référence ? » Écrivez d'abord
le code pour imprimer un hachage :

pour ma $key (clés %hash) {
imprimer "$key => $hash{$key}\n";
}

Et puis remplacez le nom du hachage par la référence :

pour ma $key (clés %{$href}) {
imprimer "$key => ${$href}{$key}\n";
}

Utilisez le Règle 2

Utilisez le Règle 1 c'est tout ce dont vous avez vraiment besoin, car il vous dit comment faire absolument tout
que vous avez besoin de faire avec des références. Mais la chose la plus courante à faire avec un tableau ou un
Le hachage consiste à extraire un seul élément, et le Utilisez le Règle 1 la notation est fastidieuse. Il y a donc
est une abréviation.

"${$aref}[3]" est trop difficile à lire, vous pouvez donc écrire "$aref->[3]" à la place.

"${$href}{red}" est trop difficile à lire, vous pouvez donc écrire "$href->{red}" à la place.

Si $aref contient une référence à un tableau, alors "$aref->[3]" est le quatrième élément du
tableau. Ne pas confondre avec $aref[3], qui est le quatrième élément d'un tableau totalement
tableau différent, nommé de manière trompeuse @aref. $aref et @aref ne sont pas liés de la même manière
que $item et @item sont.

De même, "$href->{'red'}" fait partie du hachage référencé par la variable scalaire $href,
peut-être même un sans nom. $href{'red'} fait partie du hachage %href au nom trompeur.
Il est facile d'oublier d'omettre le "->", et si vous le faites, vous obtiendrez des résultats bizarres lorsque
votre programme obtient des éléments de tableau et de hachage à partir de hachages et de tableaux totalement inattendus qui
ce n'étaient pas ceux que vous vouliez utiliser.

An Exemple
Voyons un exemple rapide de l’utilité de tout cela.

Tout d’abord, rappelez-vous que « [1, 2, 3] » crée un tableau anonyme contenant « (1, 2, 3) », et
vous donne une référence à ce tableau.

Maintenant, pensez à

@a = ( [1, 2, 3],
[4, 5, 6],
[7, 8, 9]
);

@a est un tableau avec trois éléments, et chacun est une référence à un autre tableau.

$a[1] est l'une de ces références. Elle désigne un tableau contenant « (4, 5,
6)", et parce qu'il s'agit d'une référence à un tableau, Utilisez le Règle 2 dit que nous pouvons écrire
$a[1]->[2] pour obtenir le troisième élément de ce tableau. $a[1]->[2] est le 6. De même,
$a[0]->[1] est le 2. Ce que nous avons ici est comme un tableau à deux dimensions ; vous pouvez écrire
$a[ROW]->[COLUMN] pour obtenir ou définir l'élément dans n'importe quelle ligne et n'importe quelle colonne du tableau.

La notation semble encore un peu lourde, il y a donc une abréviation supplémentaire :

flèche Règle
Entre deux indices, la flèche est facultative.

Au lieu de $a[1]->[2], on peut écrire $a[1][2] ; cela signifie la même chose. Au lieu de
"$a[0]->[1] = 23", on peut écrire "$a[0][1] = 23" ; cela signifie la même chose.

Maintenant, cela ressemble vraiment à des tableaux à deux dimensions !

On comprend l'importance des flèches. Sans elles, nous aurions dû écrire
« ${$a[1]}[2] » au lieu de $a[1][2]. Pour les tableaux tridimensionnels, ils nous permettent d'écrire
$x[2][3][5] au lieu de l'illisible "${${$x[2]}[3]}[5]".

Solution

Voici la réponse au problème que j'ai posé plus tôt, de reformater un fichier de ville et
noms de pays.

1 ma %table;

2 tant que (<>) {
3 croquettes;
4 mon ($ville, $pays) = split /, /;
5 $table{$country} = [] sauf si $table{$country} existe ;
6 appuyez sur @{$table{$country}}, $city;
7}

8 foreach $country (clés de tri %table) {
9 imprimer "$country: ";
10 mes @villes = @{$table{$pays}};
11 imprimer rejoindre ', ', trier @cities;
12 imprimer ".\n";
13}

Le programme comporte deux parties : les lignes 2 à 7 lisent l’entrée et construisent une structure de données, et
Lignes 8 à 13 : analysez les données et imprimez le rapport. Nous allons créer un hachage, %table,
dont les clés sont des noms de pays et dont les valeurs sont des références à des tableaux de noms de villes.
La structure des données ressemblera à ceci :

%tableau
+-------+---+
| | | +-----------+--------+
|Allemagne| *---->| Francfort | Berlin |
| | | +-----------+--------+
+-------+---+
| | | +----------+
|Finlande| *---->| Helsinki |
| | | +----------+
+-------+---+
| | | +---------+------------+----------+
| États-Unis | *---->| Chicago | Washington | New York |
| | | +---------+------------+----------+
+-------+---+

Commençons par examiner la sortie. Supposons que nous ayons déjà cette structure. Comment l'imprimer ?
en dehors?

8 foreach $country (clés de tri %table) {
9 imprimer "$country: ";
10 mes @villes = @{$table{$pays}};
11 imprimer rejoindre ', ', trier @cities;
12 imprimer ".\n";
13}

%table est un hachage ordinaire, et nous en obtenons une liste de clés, trions les clés et bouclons
sur les touches, comme d'habitude. Les références ne sont utilisées qu'à la ligne 10. $table{$country}
la clé $country dans le hachage et obtient la valeur, qui est une référence à un tableau de
villes de ce pays. Utilisez le Règle 1 dit que nous pouvons récupérer le tableau en disant
« @{$table{$country}} ». La ligne 10 est comme

@cities = @array;

sauf que le nom « array » a été remplacé par la référence « {$table{$country}} ».
« @ » indique à Perl de récupérer le tableau complet. Une fois la liste des villes obtenue, nous la trions.
rejoignez-le et imprimez-le comme d'habitude.

Les lignes 2 à 7 sont à l'origine de la construction de la structure. Les voici.
encore:

2 tant que (<>) {
3 croquettes;
4 mon ($ville, $pays) = split /, /;
5 $table{$country} = [] sauf si $table{$country} existe ;
6 appuyez sur @{$table{$country}}, $city;
7}

Les lignes 2 à 4 acquièrent un nom de ville et de pays. La ligne 5 vérifie si le pays est déjà
présente comme clé dans le hachage. Si ce n'est pas le cas, le programme utilise la notation « [] » (Marque Règle
2) pour fabriquer un nouvel ensemble anonyme et vide de villes et y installer une référence
dans le hachage sous la clé appropriée.

La ligne 6 installe le nom de la ville dans le tableau approprié. $table{$country} contient désormais un
référence à l'éventail de villes observées dans ce pays jusqu'à présent. La ligne 6 est exactement comme

pousser @array, $ville;

sauf que le nom « array » a été remplacé par la référence « {$table{$country}} ».
« push » ajoute un nom de ville à la fin du tableau référencé.

Il y a un point important que j'ai omis : la ligne 5 est inutile, et nous pouvons nous en débarrasser.

2 tant que (<>) {
3 croquettes;
4 mon ($ville, $pays) = split /, /;
5 #### $table{$country} = [] sauf si $table{$country} existe;
6 appuyez sur @{$table{$country}}, $city;
7}

S'il existe déjà une entrée dans %table pour le $country actuel, alors rien n'est différent.
La ligne 6 localisera la valeur dans $table{$country}, qui est une référence à un tableau, et
Insérez $ville dans le tableau. Mais que fait-il lorsque $pays contient une clé, par exemple « Grèce » ?
qui n'est pas encore dans %table ?

C'est Perl, donc il fait exactement ce qu'il faut. Il voit que vous voulez pousser « Athènes ».
sur un tableau qui n'existe pas, il crée donc utilement un nouveau tableau vide et anonyme pour
Vous l'installez dans %table, puis y déposez « Athènes ». C'est ce qu'on appelle
« autovivification » : donner vie aux choses automatiquement. Perl a compris que la clé n'était pas
dans le hachage, une nouvelle entrée a donc été créée automatiquement. Perl a vu que vous vouliez utiliser
la valeur de hachage sous forme de tableau, il a donc créé un nouveau tableau vide et installé une référence à
automatiquement dans le hachage. Et comme d'habitude, Perl a allongé le tableau d'un élément pour
conserver le nouveau nom de la ville.

Le manuel de formation Reste

Je vous ai promis de vous donner 90 % des avantages avec 10 % des détails, et cela signifie que je suis parti
90 % des détails. Maintenant que vous avez un aperçu des parties importantes, il devrait
il serait plus facile de lire la page de manuel perlref, qui traite de 100 % des détails.

Quelques points forts de perlref :

· Vous pouvez faire référence à n'importe quoi, y compris des scalaires, des fonctions et d'autres
les références.

· Dans Utilisez le Règle 1, vous pouvez omettre les accolades lorsque l'élément à l'intérieur est un
Variable scalaire atomique comme $aref. Par exemple, @$aref est identique à « @{$aref} », et
$$aref[1] est identique à « ${$aref}[1] ». Si vous débutez, vous pourriez vouloir
prenez l'habitude d'inclure toujours les accolades.

· Ceci ne copie pas le tableau sous-jacent :

$aref2 = $aref1;

Vous obtenez deux références au même tableau. Si vous modifiez « $aref1->[23] » et que vous regardez
dans "$aref2->[23]" vous verrez le changement.

Pour copier le tableau, utilisez

$aref2 = [@{$aref1}];

Ceci utilise la notation « [...] » pour créer un nouveau tableau anonyme, et $aref2 se voit attribuer un
référence au nouveau tableau. Ce dernier est initialisé avec le contenu du
tableau référencé par $aref1.

De même, pour copier un hachage anonyme, vous pouvez utiliser

$href2 = {%{$href1}};

Pour vérifier si une variable contient une référence, utilisez la fonction « ref ». Elle renvoie « true » si
Son argument est une référence. En fait, c'est un peu mieux : elle renvoie
« HASH » pour les références de hachage et « ARRAY » pour les références de tableau.

· Si vous essayez d'utiliser une référence comme une chaîne, vous obtenez des chaînes comme

TABLEAU(0x80f5dec) ou HASH (0x826afc0)

Si vous voyez une chaîne qui ressemble à ceci, vous saurez que vous avez imprimé une référence
par erreur.

Un effet secondaire de cette représentation est que vous pouvez utiliser « eq » pour voir si deux références
font référence à la même chose. (Mais vous devriez généralement utiliser « ==" à la place, car c'est beaucoup plus
plus rapide.)

· Vous pouvez utiliser une chaîne comme s'il s'agissait d'une référence. Si vous utilisez la chaîne « foo » comme
référence de tableau, elle est considérée comme une référence au tableau @foo. C'est ce qu'on appelle une
qualité, que vous pourrez utilisé référence or symbolique référence. La déclaration « utiliser des « refs » strictes » désactive
cette fonctionnalité, qui peut causer toutes sortes de problèmes si vous l'utilisez par accident.

Vous préférerez peut-être passer à perllol plutôt qu'à perlref ; il traite des listes de listes et
Les tableaux multidimensionnels en détail. Ensuite, vous devriez passer à perldsc ; c'est un outil de données.
Structure Livre de recettes qui montre des recettes pour utiliser et imprimer des tableaux de hachages, des hachages
de tableaux et d'autres types de données.

Résumé

Tout le monde a besoin de structures de données composées, et en Perl, la façon de les obtenir est avec
références. Il existe quatre règles importantes pour la gestion des références : deux pour
références et deux pour les utiliser. Une fois ces règles connues, vous pourrez réaliser la plupart des
choses importantes que vous devez faire avec les références.

Crédits

Auteur : Mark Jason Dominus, Plover Systems ("[email protected]")

Cet article a été publié dans Le manuel de formation Perl Journal ( http://www.tpj.com/ ) tome 3, #2.
Reproduit avec la permission.

Le titre original était Comprendre Références Aujourd'hui.

Distribution Conditions
Copyright 1998 Le Journal Perl.

Cette documentation est gratuite ; vous pouvez le redistribuer et/ou le modifier dans les mêmes conditions
comme Perl lui-même.

Quelle que soit sa distribution, tous les exemples de code dans ces fichiers sont par la présente placés dans
le domaine public. Vous êtes autorisé et encouragé à utiliser ce code dans vos propres programmes
pour le plaisir ou pour le profit comme bon vous semble. Un simple commentaire dans le code donnant crédit serait
courtois mais n'est pas obligatoire.

Utiliser perlreftut en ligne avec les services onworks.net