Discussion :

[USMC666]

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

[disedorgue]

Bonjour,
Un exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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"}

[cmcmc]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 $

[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

[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).

[Philou67430]

Une autre manière un peu plus fun

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Lolo78]

Jolie solution, Philou.

... 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.

[Philou67430]

Jolie solution, Philou.

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

@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.

[cmcmc]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[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.

[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

... et je m'en sers illico ici (ligne 70) . Merci encore

[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