Problème avec Hash table

Version imprimable

Bonjour,

J'ai stocké une liste de donnée dans une table de hachage et à ce stade pas de problème.
Le problème se pose lorsque je récupère mes données,je constate qu'elles ne sont pas dans l'ordre.Je m'explique par le script et l'output ci dessous:)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 # initialisation des hashs my %HASH; #### Recupération des données sub hashtable { my ( $Hash_twig, $TwigHASHEURS) = @_; my $a= $TwigHASHEURS->first_child('hash') foreach my $Twig($a->children('A')) { my $b = $Twig->first_child('B'); my $c = $Twig->first_child('C'); $HASH{$a->text}{$b->text} = $c->text; print "before\n"; print $c->text."\n"; } } #### Affichage foreach my $a(sort keys %HASH) { foreach my $b (keys %{$HASH{$a}}) { print "After\n"; print $HASH{$a}{$b} ."\n"; } }
l'ouput est :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 Before 1 2 3 4 5 6 After 1 4 3 6 2 5
Donc comment faire pour récupèrer les données dans l'ordre??:roll:

Il faut que tu précises quel est la clé d'ordonnancement. En effet, quand tu parcours un hash, les clés ne sont par défaut pas triées, ni les valeurs d'ailleurs (foreach (values %hash) par exemple).

Par exemple, si tu souhaites afficher les values terminales du hash par ordre croissant de la première clé, puis, de la deuxième clé :
Code:

1 2 3 4 5 foreach my $k1 (sort keys %HASH) { foreach my $k2 (sort keys %{$HASH{$k1}}) { print $HASH{$k1}{$k2} ."\n"; } }
Si tu souhaites trier par ordre croissant de la première clé, puis par ordre croissant des valeurs :
Code:

1 2 3 4 5 foreach my $k1 (sort keys %HASH) { foreach my $k2 (sort { $HASH{$k1}->{$a} <=> $HASH{$k1}->{$b} } keys %{$HASH{$a}}) { print $HASH{$k1}{$k2} ."\n"; } }
Si tu souhaites afficher les valeurs par ordre d'insertion dans la structure, c'est plus compliqué, car il te faut gérer l'ordre d'insertion indépendamment de la structure, car cet ordre n'est pas conservé dans le hash, mais je doute que ce soit vraiment ton besoin, sinon tu aurais utilisé un tableau de structure, comme ceci :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 # initialisation des ARRAYs my %ARRAY; #### Recupération des données sub arraytable { my ( $Hash_twig, $TwigHASHEURS) = @_; my $a= $TwigHASHEURS->first_child('hash') foreach my $Twig($a->children('A')) { my $b = $Twig->first_child('B'); my $c = $Twig->first_child('C'); push @ARRAY, { a => $a->text, b => $b->text, c => $c->text }; print "before\n"; print $c->text."\n"; } } #### Affichage foreach my $a(@ARRAY) { print "After\n"; print $a->{c} ."\n"; }
(je précise que je n'ai pas testé, ce code n'est pas exempt d'erreur).

Un conseil final : n'utilise pas les variables nommées $a et $b, car ce sont aussi des variables "magiques" de perl utilisées dans par la fonction sort.

04/04/2013, 17h27
tunwim

merci bien Philou.

Donc mon problème c'est exactement la dernière remarque comme tu l'avais déja dit:

Citation:

Si tu souhaites afficher les valeurs par ordre d'insertion dans la structure, c'est plus compliqué, car il te faut gérer l'ordre d'insertion indépendamment de la structure, car cet ordre n'est pas conservé dans le hash, mais je doute que ce soit vraiment ton besoin, sinon tu aurais utilisé un tableau de structure

Et si j'ai bien compris c'est impossible de récupérer les données à partir d'un hash dans l'ordre d’insertion ??
04/04/2013, 17h54
Lolo78

Citation:

Envoyé par tunwim

Et si j'ai bien compris c'est impossible de récupérer les données à partir d'un hash dans l'ordre d’insertion ??

Oui, sauf si tu as pris la précaution de stocker l'ordre d'insertion quelque part: par exemple dans un tableau accessoire, ou bien en mettant dans chaque élément du hash un tableau de deux éléments (ordre d'insertion + la valeur à stocker), ou encore en concaténant l'ordre d'intertion soit à la clé, soit à la valeur, selon l'usage prévu du hash, afin de pouvoir ensuite trier selon cet ordre.

Sinon, généralement, un hash stocke les données dans un ordre apparemment aléatoire.
04/04/2013, 18h30
tunwim

Citation:

Envoyé par Lolo78

Oui, sauf si tu as pris la précaution de stocker l'ordre d'insertion quelque part: par exemple dans un tableau accessoire, ou bien en mettant dans chaque élément du hash un tableau de deux éléments (ordre d'insertion + la valeur à stocker), ou encore en concaténant l'ordre d'intertion soit à la clé, soit à la valeur, selon l'usage prévu du hash, afin de pouvoir ensuite trier selon cet ordre.

.

merci pour ta réponse Lolo mais j'ai pas bien saisie les cas ou on peut conserver l'ordre d'insertion pour un hash :oops:
04/04/2013, 19h59
Lolo78
On ne peut pas conserver l'ordre d'insertion pour un hash, mais on peut stocker quelque part l'information sur l'ordre d'insertion afin de la récupérer quand le besoin s'en fait sentir.

Un exemple simple, tu veux stocker des données d'une table de conversion dans un hash:
Code:

1 2 3 4 $mois{jan} = "janvier"; $mois{feb} = "février"; $mois{mar} = "mars"; # etc.
Il n'y a aucun moyen de réimprimer tes valeurs ou tes clefs dans l'ordre où les éléments ont été insérés (l'ordre des mois de l'année).

Mais si tu fais ceci:
Code:

1 2 3 4 5 6 7 $mois{jan} = "janvier"; push @order, "jan"; $mois{feb} = "février"; push @order, "feb"; $mois{mar} = "mars"; push @order, "mar" # etc.
Il suffit de relire le tableau @order dans l'ordre pour récupérer les clefs (et donc les valeurs) dans l'ordre:

Code:

print "Le mois dont le nom abrégé est $_ a pour nom entier $mois{$_}\n" foreach @order;

Il y a d'autres moyens de stocker cette information: concaténer la valeur avec un numéro d'ordre:
Code:

1 2 3 $mois{jan} = "01-janvier"; $mois{feb} = "02-février"; $mois{mar} = "03-mars";
Un simple tri sur les valeurs permettra de récupérer les choses dans l'ordre (il suffit ensuite d'éliminer le numéro d'ordre).

Autre méthode: stocker une référence sur un tableau anonyme dans chaque élément du hash:
Code:

1 2 3 $mois{jan} = [1, "janvier"]; $mois{feb} = [2, "février"]; $mois{mar} = [3, "mars"];
On trie ensuite selon le premier élément du tableau de chaque élément du hash.

Le problème qui complique l'affaire ici, c'est que le hash est à 2 niveaux. Il faut donc récupérer d'abord les éléments feuilles, puis les trier par ordre. La seule solution est donc de placer l'ordre d'insertion avec la feuille (l'élément le plus profond dans le hash) :

Mais si l'ordre d'insertion est important, c'est peut-être que la recherche par clé n'est pas "essentielle", voire n'est pas utile. Du coup, le stockage dans un tableau simple, comme je l'indiquais dans mon 3e exemple, est une meilleur solution.
Si toutefois tu souhaites conserver un hash à 2 niveaux, voici une manière de faire :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 my $order = 0; sub hashtable { my ( $Hash_twig, $TwigHASHEURS) = @_; my $a= $TwigHASHEURS->first_child('hash'); foreach my $Twig ($a->children('A')) { my $b = $Twig->first_child('B'); my $c = $Twig->first_child('C'); $HASH{$a->text}{$b->text} = [$order++, $c->text]; print "before\n"; print $c->text."\n"; } } #### Affichage my @ARRAY = (); foreach my $a(sort keys %HASH) { foreach my $b (keys %{$HASH{$a}}) { $ARRAY[$HASH{$a}->{$b}->[0]] = $HASH{$a}->{$b}->[1]; } } print "After\n"; print map "$_\n", @ARRAY;
Mais honnêtement, il faudrait vraiment que tu te poses la question de savoir si l'usage d'un hash est vraiment pertinente dans ton cas.