Les hash.

La notion de hash.

Il s'agit d'un objet semblable à une liste dans lequel chaque élément est identifié par une clé spécifique.
Contrairement à une structure indicée standard, la clé n'est pas une valeur numérique prédefinie (1,2 ...n) mais une valeur définie par l'usager et pouvant être tout type de scalaire.
Le nom d'un hash est précédé du signe %, il représente dans ce cas l'ensemble de la structure.

%nom_du_hash
  

Chacun de ses éléments étant un scalaire sera identifié par le signe $

$nom_du_hash{"valeur_de_la_cle"}
  

#!/usr/bin/perl;
%h = (a,A,b,B,c,C,d,D);
@cle = (a,b,c,d);
foreach $i (@cle) {
print ("hash($i) = $h{$i}\n");
}
    

c:\progs> perl xxx.plent
hash(a) = A
hash(b) = B
hash(c) = C
hash(d) = D
c:\progs>
    

Bien noter que dans le cas d'une liste l'indice était représenté entre crochets [ ], et que dans le cas d'un hash, la clé se présente entre deux acolades { }.

#!/usr/bin/perl;
%hash = (a,A,b,B,c,C,d,D);
@indices = (a,b,c,d);
foreach $i (@indices) {
  $hash{$i} = $hash{$i}.$hash{$i};
}
foreach $i (@indices) {
  print "hash($i) = $hash{$i}\n";
}
    

c:\progs> perl hash2.plent
hash(a) = AA
hash(b) = BB
hash(c) = CC
hash(d) = DD
c:\progs>
    

L'exemple ci dessus met en evidence deux choses.
Tout d'abord l'initialisation d'un hash, une liste dans laquelle tous les éléments de rang pair feront office de clés et tous les éléments de rang pair de valeurs.
Puis, l'accés à chaque élément, individuellement.

#!/usr/bin/perl;
%hash = (a,A,b,B,c,C,d,D);
@liste = %hash;
print "liste = @liste\n";
    

c:\progs> perl hash3.plent
hash = a A b B c C d D
c:\progs>
    

Si un hash n'est jamais que l'interprétation d'une liste, il est possible comme le montre l'exemple de passer sans problème de l'un à l'autre et vice versa.

Manipulations de hash.

Voyons sur des exemples les principales fonctionalités d'un hash.

#!/usr/bin/perl;
@liste = (a,A,b,B,c,C,d,D);
%hash = @table;
@indices = (a,b,c,d);
print "Hash initial :\n";
foreach $i (@indices) {
  print "hash($i) = $hash{$i}\n";
  $hash{$i} = $hash{$i}.$hash{$i};
}
print "\nHash modifie :\n";
foreach $i (@indices) {
  print "hash($i) = $hash{$i}\n";
}
    

c:\progs> perl hash4.plent
Hash initial :
hash(a) = A
hash(b) = B
hash(c) = C
hash(d) = D

Hash modifie :
hash(a) = AA
hash(b) = BB
hash(c) = CC
hash(d) = DD
c:\progs>
    

Cet exemple met en évidence la création d'un hash à partir d'une liste.

#!/usr/bin/perl;
%hash1 = (a,A,b,B,c,C,d,D);
%hash2 = %hash;
@indices = (a,b,c,d);
print "Hash1 :\n";
foreach $i (@indices) {
print "hash1($i) = $hash1{$i}\n";
}
print "\Hash2 :\n";
foreach $i (@indices) {
print "hash2($i) = $hash2{$i}\n";
}
    

c:\progs> perl hash5.plent
Hash1 :
hash1(a) = A
hash1(b) = B
hash1(c) = C
hash1(d) = D

Hash2 :
hash2(a) = A
hash2(b) = B
hash2(c) = C
hash2(d) = D
c:\progs>
    

Recopie de la totalité d'un hash dans un autre.

Opérateurs de hash.

L'opérateur keys()
Affecté à un liste standard, il permet de récupérer dans la liste en question l'ensemble des clés d'accés à un hash.

@cles = keys(%hash);
  

Affecté à un scalaire il permet d'obtenir le nombre d'éléments d'un hash.

$taille = keys(%hash);
  

#!/usr/bin/perl;
%hash = (a,A,b,B,c,C,d,D);
$nb = keys(%hash);
@cles = keys(%hash);
print "Nombre d'elements : $nb\n";
print "Cles : @cles\n\n";
foreach $i (@cles) {
  print "hash($i) = $hash{$i}\n";
}
    

c:\progs> perl hash6.plent
Nombre d'elements : 4
Cles : a b c d

hash(a) = {a}
hash(b) = {b}
hash(c) = {c}
hash(d) = {d}
c:\progs>
    

On dispose ainsi d'un moyen simple pour tester si un hash contient ou non des éléments.

#Test du hash.
if (keys(%nom_du_tableau)) {
  # Ici le tableau n'est pas vide.
}else{
  # Ici le tableau est vide
}
  

L'opérateur values()

Affecté à une liste standard, il permet de récupérer dans la liste en question l'ensemble des valeurs d'un hash.

@valeurs = values(%hash);
  

Affecté à un scalaire il permet d'obtenir le nombre d'éléments d'un hash.

$taille = values(%hash);
  

#!/usr/bin/perl;
%hash = (a,A,b,B,c,C,d,D);
$nb = values(%hash);
@valeurs = values(%hash);
print "Nombre d'elements : $nb\n";
print "Valeurs : @valeurs\n";
}
    

c:\progs> perl hash7.plent
Nombre d'elements : 4
Valeurs : A B C D
c:\progs>
    

L'opérateur each()

Cet opérateur va permettre d'effectuer une itération sur l'ensemble des éléments d'un hash sans avoir à procéder à un accés préalable aux clés.

@cles = keys(%table);
foreach (@cles) {
  . . .
}
  

Ou plus synthétiquement.

foreach (keys(%table)) {
  . . .
}
  

L'opérateur each() permet, à chacun de ses appels, de récupérer un doublet de scalaires.
Le premier contient la clé.
Le second contient la valeur.
Lorsque'il ne reste plus d'éléments, la valeur retournée est undef.
Il suffit donc de la tester pour terminer le processus.

#!/usr/bin/perl;
%hash = (a,A,b,B,c,C,d,D);
while (($c,$v) = each(%hash)) {
  print "Cle : $c, Valeur : $v\n";
}
    

c:\progs> perl hash8.plent
Cle : a, Valeur : A
Cle : b, Valeur : B
Cle : c, Valeur : C
Cle : d, Valeur : D
c:\progs>
    

L'opérateur delete()

L'ajout d'un élément dans un hash est simple, il suffit de procéder à l'affectation d'une valeur correspondant à une nouvelle clé, le nouveau couplr (clé,valeur) est automatiquement créée.

$hash($nouvelle_cle) = 3.14159;
  

L'effacement d'un élément doit, pour sa part, passer par l'intermédiaire dun opérateur spécifique, l'opérateur delete().

delete ($table{"clé"};
  

Permet de supprimer l'entré du hash correspondant à la clé dont le nom est passée en paramètre.

#!/usr/bin/perl;
%hash = (a,A,b,B,c,C,d,D);
print "Ajout de l'element e,E.\n";
$hash{"e"} = "E";
while (($c,$v) = each(%table)) {
  print "Cle : $c, Valeur : $v\n";
}
print "\nSuppression de l'element b,B.\n";
delete ($hash{"b"});
while (($c,$v) = each(%table)) {
  print "Cle : $, Valeur : $v\n";
}
    

c:\progs> perl hash9.plent
Ajout de l'element e,E.
Cle : a, Valeur : A
Cle : b, Valeur : B
Cle : c, Valeur : C
Cle : d, Valeur : D
Cle : e, Valeur : E

Suppression de l'element b,B.
Cle : a, Valeur : A
Cle : c, Valeur : C
Cle : d, Valeur : D
Cle : e, Valeur : E
c:\progs>
    

Précédent

Suivant