Remplir un hash à partir de deux tableaux

Version imprimable

15/10/2013, 20h31
USMC666

Remplir un hash à partir de deux tableaux

Bonsoir,

Je galère depuis un moment, j'essaye de remplir un hash avec deux tableaux.
En gros :

Tableau 1 : my @int = ("eth0", "eth1");
Tableau 2 : my @octet = (1000, 2000);

je voudrais remplir mon hash avec une boucle mais je ne vois pas comment.

ça donnerai :

my $i = 0;
my %hash_int = (
$int[$i] => $octet[$i],
);

Quel genre de boucle serait à utiliser dans ce cas ?

Merci beaucoup :P

Bonjour,
Un exemple:

Code:

1
2
3
4
5
6
7
8
9
my %hash_int
my @int = ("eth0","eth1");
my @octet = (1000,2000);
my ($i,$a);
foreach $i (@int){
 $hash_int{$i} = $octet[$a++]}
#Affichage du hash
foreach $i (keys %hash_int){
 print $i."=>".$hash_int{$i}."\n"}

Une solution avec mesh (ou zip) de List::MoreUtils

Code:

1
2
3
4
5
6
Taisha:~/tttmp $ perl -MList::MoreUtils"(mesh)" -MData::Dumper -E 'my @int=qw/eth0 eth1/; my @octets = qw/1000 2000/; my %h = mesh(@int, @octets); print Dumper(\%h)'
$VAR1 = {
          'eth1' => '2000',
          'eth0' => '1000'
        };
Taisha:~/tttmp $

15/10/2013, 22h20
USMC666

Il y a du niveau sur ce forum, ça fait plaisir :)
Merci à vous deux pour vos solutions. C'est juste ce qu'il me fallait.
disedorgue, juste une petite question, par excès de curiosité.
Avec ta méthode, les valeurs du hash sont dans le désordre.

Mes deux tableaux :
my @int = ("eth0", "eth1", "eth2", "eth3");
my @octet = (1000, 2000, 3000, 4000);

Le code marche impec, mais la première valeur renvoyée est : eth2=>3000.
ça vient de quoi ?

Encore merci ;)
16/10/2013, 01h34
disedorgue

Cela vient du fait que la seule chose de garanti par la fonction keys est de ramener l'exhaustivité des clés, elle ne garanti pas l'ordre.
(c'est d'ailleurs aussi le cas pour la fonction values).

Une autre manière un peu plus fun :)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
$ perl -MData::Dumper -E '@a = (1 .. 10); @b = ("a".."j");@h{@a} = @b;say Data::Dumper->Dump([\%h],[qw(*h)])'
%h = (
       '6' => 'f',
       '3' => 'c',
       '7' => 'g',
       '9' => 'i',
       '2' => 'b',
       '8' => 'h',
       '1' => 'a',
       '4' => 'd',
       '10' => 'j',
       '5' => 'e'
     );

En toute rigueur, en utilisant "strict", il faudra au préalable déclarer la variable hash:

Code:

1
2
my %h;
@h{@cles} = @valeurs;

16/10/2013, 08h20
Lolo78

Jolie solution, Philou. :ccool:

Citation:

Envoyé par USMC666

... juste une petite question, par excès de curiosité.
Avec ta méthode, les valeurs du hash sont dans le désordre.

Mes deux tableaux :
my @int = ("eth0", "eth1", "eth2", "eth3");
my @octet = (1000, 2000, 3000, 4000);

Le code marche impec, mais la première valeur renvoyée est : eth2=>3000.
ça vient de quoi ?

Il n'y a aucune notion d'ordre dans un hash, presque par définition. Les éléments sont retournés dans un ordre apparemment aléatoire. Mais tu peux toujours faire un tri (par exemple des clefs) au moment d'afficher tes éléments.
16/10/2013, 10h08
Philou67430
Citation:

Envoyé par Lolo78

Jolie solution, Philou. :ccool:

La solution devient plus compliquée à écrire lorsque le hash à remplir n'est accessible que par une référence (par exemple, s'il est lui même un élément de hash). Exemple :
Code:

1 2 3 4 my %sarl = ( employe => {} ); my @personnel = qw(Paul Eric Jean); my @date_entree = qw(2010 2013 2011); @{$sarl{employe}}{@personnel} = @date_entree;
On notera notamment qu'il n'est pas possible d'utiliser la notation -> comme c'est possible pour l'accès à un scalaire :

Code:

@sarl{employe}->{@personnel} = @date_entree;

Dans ce cas, le contexte de scalaire est fourni au déréférencement, et par conséquent, également à l'affectation, donc à @date_entree. Cette limitation au déréférencement scalaire de l'opérateur -> m'a toujours surprise, même si j'imagine qu'il y a de bonnes raisons à cela.

Citation:

Envoyé par Philou67430

Cette limitation au déréférencement scalaire de l'opérateur -> m'a toujours surprise, même si j'imagine qu'il y a de bonnes raisons à cela.

C'est dû à un très ancien bug qui n'a jamais été corrigé pour des raisons de compatibilité arrière, spécifiquement le fait que %h->{$x} est identique à $h{$x}, et que @a->[$x] est identique à $a[$x]. C'est malheureux mais c'est comme ça... Un warning de dépréciation a été introduit en 5.6.1:

Code:

1
2
3
4
5
6
7
8
Taisha:~/tttmp $ perl -E 'my %h = ( x => 1); my @a = (1, 2); say for %h->{x}, $h{x}, @a->[1], $a[1]'
Using a hash as a reference is deprecated at -e line 1.
Using an array as a reference is deprecated at -e line 1.
1
1
2
2
Taisha:~/tttmp $

Je crains fort qu'il y ait peu de chances que ce soit changé maintenant...

Du coup c'est vrai que les combinaisons de @, hashref et -> produisent des résultats, disons, intéressants :weird:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Taisha:~/tttmp $ perl -Mstrict -MData::Dumper -E 'my $h; @{$h}->{qw/a b c/} = qw/1 2 3/; print Dumper($h)'
Can't use an undefined value as a HASH reference at -e line 1.
Taisha:~/tttmp $ perl -Mstrict -MData::Dumper -E 'my $h = {}; @{$h}->{qw/a b c/} = qw/1 2 3/; print Dumper($h)'
Not an ARRAY reference at -e line 1.
Taisha:~/tttmp $ perl -Mstrict -MData::Dumper -E '$; = q{;}; my $h; $h->{qw/a b c/} = qw/1 2 3/; print Dumper($h)'
$VAR1 = {
          'a;b;c' => '3'
        };
Taisha:~/tttmp $ perl -Mstrict -MData::Dumper -E '$; = q{;}; my $h; @{$h->{qw/a b c/}} = qw/1 2 3/; print Dumper($h)'
$VAR1 = {
          'a;b;c' => [
                       '1',
                       '2',
                       '3'
                     ]
        };
Taisha:~/tttmp $

A l'inverse la notation @{hashref}{...} se comporte de manière parfaitement prévisible, même si l'autovivification de hashref en lecture peut surprendre:

Code:

1
2
3
4
Taisha:~/tttmp $ perl -Mstrict -MData::Dumper -E 'my $h; print Dumper($h); my @x = @{$h}{qw/a b c/}; print Dumper($h)'
$VAR1 = undef;
$VAR1 = {};
Taisha:~/tttmp $

mais il me semble que c'est une feature, et en écriture c'est un bonheur :)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Taisha:~/tttmp $ perl -MData::Dumper -E 'my $h; @{$h}{qw/a b c/} = qw/1 2 3/; print Dumper($h)'
$VAR1 = {
          'c' => '3',
          'a' => '1',
          'b' => '2'
        };
Taisha:~/tttmp $ perl -MData::Dumper -E 'my $h; @{$h->{foo}{bar}{baz}}{qw/a b c/} = qw/1 2 3/; print Dumper($h)'
$VAR1 = {
          'foo' => {
                     'bar' => {
                                'baz' => {
                                           'c' => '3',
                                           'a' => '1',
                                           'b' => '2'
                                         }
                              }
                   }
        };
Taisha:~/tttmp $

J'ai l'habitude de lire et modifier des hashes et hashrefs via tranchage mais bizarrement je n'avais pas réalisé que je pouvais aussi les initialiser de cette manière :). Bien vu, +1 et merci :ccool:

16/10/2013, 15h38
Philou67430

L'auto-vivification est effectivement une feature, ... très discutée d'ailleurs. Il me semble que cette notion a été remise à plat pour perl 6 ?

J'y suis favorable lors de la création d'éléments, mais pas lors de leur lecture (genre "exists $h{toto}->{tutu}->{titi}" ; si $h{toto} n'existe pas, il est auto-vivifié).
Du coup, je me méfie toujours de l'auto-vivification.
16/10/2013, 16h07
cmcmc

Citation:

Envoyé par cmcmc

J'ai l'habitude de lire et modifier des hashes et hashrefs via tranchage mais bizarrement je n'avais pas réalisé que je pouvais aussi les initialiser de cette manière :). Bien vu, +1 et merci :ccool:

... et je m'en sers illico ici (ligne 70) :). Merci encore :ccool:
21/10/2013, 09h36
USMC666

J'avoue que je suis un peu dépassé par le reste du sujet lol
En tout cas un grand merci a tous, cela m'as permis de bien avancer dans mon projet.
Je met le sujet en "résolu".

A la prochaine, pour une nouvelle aventure :)