Tableaux de hashmap

Soit les hashmap suivantes:

my %h1 = ("toto"=>"toto12", "test"=>"test12");
my %h2 = ("xavier"=>"0471...", "vincent"=>"047945...");

Il n'est pas permis d'écrire ceci en Perl

my @array=undef;
@array[0]=%h1;
@array[1]=%h2;

Il est impératif de référencer les hashmap dans le tableau:

my @array=undef;
@array[0]=\%h1;
@array[1]=\%h2;

Ceci fonctionnera beaucoup mieux.

Là où cela devient amusant c'est pour récupérer les hashmap contenue dans le tableau:

$array[1]->{vincent} me donnera 047945...

si je veux defnir %hmap qui contiendra la hash contenue dans $array[1] je pourrais faire comme suit:
%hmap=%$array[1];
Cela fera malheureusement planter PERL lamentablement.
soit j'écris

$hmap_ref=$array[1];
%hmap=%$hmap_ref;

Cela marchera mais pour un développeur PERL cette écriture est beaucoup trop lourde:
On pourra donc faire plus concis (et plus illisible) en utilisant ceci:

%hmap=%{$array[1]}

Attention c'est la déréférenciation d'un tableau et non pas la valeur de la clé d'une hash (dont la clé serait $array[1]).

Voilà de quoi s'amuser. ..

Hashmap en Perl

Voici la suite des manipulations de Hash en PERL

Tout d’abord une hash est une structure de données référencée par une clé généralement alphanumérique :
(Nom=clé) => Numéro de téléphone

Exemple :
Vincent => +3271546521

La clé sera ici vincent et la valeur associée, +32 blabla. En général on applique un hashage sur la clé (ou un digest) pour transformer la séquence de caractère en un integer plus ou moins unique par chaîne de caractère. Ceci a tendance à améliorer la rapidité des traitements.

Création d’une hash (hashmap)

my %h=( "jyce"=>"071456502",
"toto"=>"toto12");

La hash est un type particulier en PERL représenté par ‘%’
Toute variable déclarée avec un % est une hashmap
Pour obtenir le numéro de tel de jyce :

print $h{jyce} ; # attention pas %{}

Une fois crée il est toujours possible d’ajouter des nouveaux couples clé-valeur dans la hashmap.

# oups oublié, on rajoute directement comme des cochons dans la hashmap
$h{"marc"}="071726532";

Fusionner deux hashmap :

my %h2 = ("vincent"=>"04754455",
"xavier"=>"0479581515");
%h=(%h,%h2); # pas mal hein ?

Afficher l’entiereté d’une hashmap

print "$_=".$h{$_}."\n" foreach (keys(%h)) ;

keys(%h) est une fonction qui renvoit un tableau contenant les clés de la hash :
@k=keys(%h) ;
Par métaphore, $_ représente donc un élément du tableau @k.
Nous allons créer une procédure qui affiche la hashmap :

sub map_params {
my (%m)=@_;
print "Non triée\n";
print "$_=".$m{$_}."\n" foreach (keys(%m)) ;
}
#appel
map_params(%h)

Référencer une hashmap. Dans certains cas de figure il est impératif d’utiliser une référence sur la hashmap.
Créeonns une procédure attendant une hashmap en paramètres, cette procédure aura ainsi par exemple la faculté d’ajouter des choses dans la hashmap et de faire en sorte que ces choses soient toujours là après l’appel (passage par référence) :

sub map_params_ref {
my ($mref)=shift;
map_params(%$mref); # déférenciation et on appel la proc standard d’affichage
}
#appel
map_params_ref(\%h);

remarquez que $mref->{vincent} fonctionne aussi très bien, je n’ai pas besoin dans ce cas de déréférencer.
Afficher une hashmap triée :
Je trie le tableau des clés et j’affiche les valeurs en parcourant le tableau de clé trié :

print "Triée\n";
my @key_sorted=sort ( {$a cmp $b} keys(%m) );
print $_.'='.$m{$_}."\n" foreach (@key_sorted);
trier dans l’ordre descendant
my @key_sorted=sort ( {$b cmp $a} keys(%m) );

Voilà j’espère que ce petit tuto sur les manipulations de hash vous a amusé...

Sub en PERL

PERL est un langage non typé et non signé les fonctions peuvent recevoir tout et n’importe quoi comme paramètres, cette manière assez crade de travailler peut vite amener du code à faire n’importe quoi...

Voyons quelques exemples:

Passer des paramètres à une sub
Définissons une fonction qui somme deux paramètres a et b : façon propre de faire

sub sum {
my ($a,$b)=@_;
return $a+$b;
}

Bon l’explication est simple, les paramètres d’une sub sont un tableau référencé par @_
La notation ($var1, $var2, … , $varn) permet de récupérer les éléments d’un tableau dans l’ordre 1 ..n
Mais pourquoi faire simple quand on peut faire compliquer , PERL va offrir d’atures méchanismes d’extraction dans un tableau
Ex :façon longue
sub sum {
my $a=shift(@_);
my $b=shift(@_);
return $a+$b;
}
Shift permet de retirer des éléments d’un tableau, (le premier entré est le premier sortant FIFO)
Façon plus simple
sub sum {
my $a=shift;
my $b=shift;
return $a+$b;
}
Dans une sub le paramètre @_ est implicite shift s’appliquera donc d’office à lui si rien n’est précisé.
Façon LIFO
sub sum {
my $b=pop;
my $a=pop;
return $a+$b;
}
Attention dans une LIFO le dernier entré est le premier à sortir (pile d'assiettes)
Façon bête :
sub sum{
my $a=$_[0];
my $b=$_[1];
return $a+$b;
}
Remarqué qu’ici on utilise $_[i] puisqu’on référence un élément du tableau qui est scalaire.
Ici nous avons vu le passage par valeur, il n’est pas possible de modifier les paramètres, voyons maintenant le passage par adresse.

Si je passe des variables en paramètre à cette fonction, la valeur des paramètres est copiée dans la fonction.
Donc toute modification apportée aux variables ne sera pas répercutée en dehors de la fonction.
Considérons la fonction suivante :
sub sum_ref {
my ($aref,$bref)=@_;
$$aref=3; # je remplace le paramètre entré 5 par 3.
my $a=$$aref; # je déférence dans $a
my $b=$$bref; # je déférence dans $b
return $a+$b;
}
my $x=5;
my $y=6;
print sum_ref(\$x,\$y);
print "\n$x";
Vous l’aurez compris la sortie va me donner ceci :
9
3
$x vallait cinq mais c’est son adresse qui a été passée. Donc c’est la valeurs contenue à cette adresse logique qui a été remplacée par 3.
Remarquez le bel opérateur de référencement \$var et l’opérateur de déréférencement $$var qui donne au coding une élégance digne des soirées de Monsieur l’Ambassadeur.

En conclusion je rapellerai cette magnifique citation de Dave Small :
Un langage de programmation est censé être une façon conventionnelle de donner des ordres à un ordinateur. Il n'est pas censé être obscur, bizarre et plein de pièges subtils ça, ce sont des attributs de la magie.

Il devait certainement penser à PERL lorsqu’il a écrit cela.