Convertir liste plate en hash spécifique

**djibril** · 02/10/2013, 15h37

Bonjour,

Question bête :
à partir d'une liste my @liste = qw / a b c d/;comment créer le hash suivant $hash->{a}{b}{c}{d} = undef;?

**djibril** · 02/10/2013, 16h47

La liste peut être de taille quelconque.

**Philou67430** · 02/10/2013, 17h54

Ce n'est pas "strictement" ce que tu veux (le undef est remplacé par un hash vide) :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
$ perl -E 'my @liste = qw /a b c d/;my %hash;my $hash = \%hash;foreach my $level (@liste) { $hash->{$level} = {}; $hash = $hash->{$level} };use Data::Dumper; say Data::Dumper->Dump([\%hash],[qw(*hash)])'                                                             %hash = (
          'a' => {
                   'b' => {
                            'c' => {
                                     'd' => {}
                                   }
                          }
                 }
        );

(normal que j'arrive plus à utiliser les boutons d'édition de message, par exemple pour la balise CODE ?)

**Lolo78** · 03/10/2013, 00h51

Hum, réponse pas très propre (et pas testée)...

Code :

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

1
2
3
4
my @liste = qw / a b c d/;
@liste = map { "{$_}"} @liste;
my $string = join '', '$hash->', @liste, " = undef";
eval $string;

Bon, finalement, un petit test sous le debugger:

Code :

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

1
2
3
4
5
6
 x $hash
0  HASH(0x8032f028)
   'a' => HASH(0x80431588)
      'b' => HASH(0x804315b8)
         'c' => HASH(0x804315e8)
            'd' => undef

**cmcmc** · 03/10/2013, 07h17

Code :

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

1
2
3
4
5
6
7
8
9
10
11
Taisha:~/tttmp $ perl -MData::Dumper -e 'sub to_hash { my $c; $c = { $_ => $c } for reverse @_; $c }; print Dumper(to_hash(qw(a b c d)))'
$VAR1 = {
          'a' => {
                   'b' => {
                            'c' => {
                                     'd' => undef
                                   }
                          }
                 }
        };
Taisha:~/tttmp $

**Philou67430** · 03/10/2013, 08h46

Merci cmcmc

**djibril** · 03/10/2013, 09h39

Merci à vous trois.

@philou, ce code peut toujours servir pour réutiliser ton code au niveau des sommaire en partant d'un hash

!

**cmcmc** · 08/10/2013, 10h20

Envoyé par cmcmc

Code :

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

1
2
3
4
5
6
7
8
9
10
11
Taisha:~/tttmp $ perl -MData::Dumper -e 'sub to_hash { my $c; $c = { $_ => $c } for reverse @_; $c }; print Dumper(to_hash(qw(a b c d)))'
$VAR1 = {
          'a' => {
                   'b' => {
                            'c' => {
                                     'd' => undef
                                   }
                          }
                 }
        };
Taisha:~/tttmp $

variante sans reverse

Code :

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

1
2
3
4
5
6
7
8
9
10
11
Taisha:~/tttmp $ perl -MData::Dumper -e 'sub to_hash { my $c = undef; $c = { pop @_ => $c } while @_; $c } print Dumper(to_hash(qw(a b c d)))'
$VAR1 = {
          'a' => {
                   'b' => {
                            'c' => {
                                     'd' => undef
                                   }
                          }
                 }
        };
Taisha:~/tttmp $

variante récursive (ma préférée

)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
Taisha:~/tttmp $ perl -MData::Dumper -E 'sub to_hash { @_ ? { shift(@_) => to_hash(@_) } : undef } say Dumper(to_hash(qw(a b c d)))'
$VAR1 = {
          'a' => {
                   'b' => {
                            'c' => {
                                     'd' => undef
                                   }
                          }
                 }
        };

Taisha:~/tttmp $

**cmcmc** · 08/10/2013, 14h28

j'ai changé d'avis

, je préfère celle là (récursive aussi) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
Taisha:~/tttmp $ perl -MData::Dumper -E 'sub to_hash { $_[0] && { shift(@_) => to_hash(@_) } } say Dumper(to_hash(qw(a b c d)))'
$VAR1 = {
          'a' => {
                   'b' => {
                            'c' => {
                                     'd' => undef
                                   }
                          }
                 }
        };

Taisha:~/tttmp $

Mais attention, elle ne supporte pas 0 comme clé

Code :

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

1
2
3
4
5
6
Taisha:~/tttmp $ perl -MData::Dumper -E 'sub to_hash { $_[0] && { shift(@_) => to_hash(@_) } } say Dumper(to_hash(qw(a 0 c d)))'
$VAR1 = {
          'a' => '0'
        };
 
Taisha:~/tttmp $

en fait la version suivante serait plus robuste mais malheureusement la feuille produite contient 0 et non undef...

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
Taisha:~/tttmp $ perl -MData::Dumper -E 'sub to_hash { @_ && { shift(@_) => to_hash(@_) } } say Dumper(to_hash(qw(a 0 c d)))'  C-c C-z
$VAR1 = {
          'a' => {
                   '0' => {
                            'c' => {
                                     'd' => 0
                                   }
                          }
                 }
        };
 
Taisha:~/tttmp $

**cmcmc** · 23/10/2013, 20h28

Pour le sport, une version Inline::C

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
20
21
22
23
24
# -*- Mode: cperl; coding: utf-8; tab-width: 8; indent-tabs-mode: nil; cperl-indent-level: 4 -*-
# to_hash_inline_C1.pl
use strict;
use warnings;
 
use Inline C => <<'END_OF_C';
SV* to_hash(SV* key1, ...) {
    Inline_Stack_Vars;
    int i;
    SV* ret = newSV(0);
 
    for (i = Inline_Stack_Items; i--; ) {
	HV* hash = newHV();
	hv_store_ent(hash, Inline_Stack_Item(i), ret, 0);
	ret = newRV_noinc((SV*) hash);
    }
    return ret;
}
END_OF_C
    ;
 
 
use Data::Dumper;
print Dumper(to_hash(@ARGV));

seul inconvénient, la liste d'entrée ne peut pas être vide à cause d'une limitation du compilateur C (lorsqu'on utilise une liste variable d'arguments, on est obligé de déclarer au moins 1 argument

).

Code :

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

1
2
3
4
5
6
7
8
9
10
11
Taisha:~/tttmp/to_hash $ perl to_hash_inline_C1.pl a b c d
$VAR1 = {
          'a' => {
                   'b' => {
                            'c' => {
                                     'd' => undef
                                   }
                          }
                 }
        };
Taisha:~/tttmp/to_hash $

**Philou67430** · 24/10/2013, 08h51

C'est sans doute la plus rapide ...

**cmcmc** · 24/10/2013, 12h25

Envoyé par Philou67430

C'est sans doute la plus rapide ...

C'est ironique

?

Elle est effectivement un poil plus rapide, mais pas spectaculairement, ce qui est normal parce qu'elle fait essentiellement la même chose que l'interpréteur... Ce n'était pas l'objet.

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
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
# -*- Mode: cperl; coding: utf-8; tab-width: 8; indent-tabs-mode: nil; cperl-indent-level: 4 -*-
# to_hash_test.pl
use strict;
use warnings;
use Data::Dumper;
use Devel::Leak;
 
use Inline C => <<'END_OF_C';
SV* to_hash_inline(SV* key1, ...) {
    Inline_Stack_Vars;
    int i;
    SV* ret = newSV(0);
 
    for (i = Inline_Stack_Items; i--; ) {
	HV* hash = newHV();
	hv_store_ent(hash, Inline_Stack_Item(i), ret, 0);
	ret = newRV_noinc((SV*) hash);
    }
    return ret;
}
END_OF_C
    ;
 
sub to_hash_reverse { my $c; $c = { $_ => $c } for reverse @_; $c }
sub to_hash_pop { my $c = undef; $c = { pop @_ => $c } while @_; $c }
sub to_hash_recursive { no warnings 'recursion'; @_ ? { shift(@_) => to_hash_recursive(@_) } : undef }
sub to_hash_altrec { no warnings 'recursion'; $_[0] && { shift(@_) => to_hash_altrec(@_) } }
sub to_hash_while { my $c; my $i = @_; $c = { $_[$i] => $c } while $i--; $c }
 
my %dispatch = ( inline    => \&to_hash_inline,
                 reverse   => \&to_hash_reverse,
                 pop       => \&to_hash_pop,
                 recursive => \&to_hash_recursive,
                 altrec    => \&to_hash_altrec,
                 while     => \&to_hash_while,
               );
 
my $name     = shift || q{inline};
my $size     = shift || 100;
my $cnt      = shift || 1;
my $testleak = shift;
 
exists $dispatch{$name} or die "usage : $0 [name [size [cnt [testleak]]]]\n",
  "  name: ", (join ", ", keys %dispatch);
 
 
my @list = 1 .. $size;
my $handle;
 
my ($before, $after);
$before = Devel::Leak::NoteSV($handle) if $testleak;
while ($cnt--) { my $h = $dispatch{$name}->(@list) };
$after  = Devel::Leak::CheckSV($handle) if $testleak;
print "$before $after\n" if $testleak;

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
20
21
22
23
24
25
26
27
28
29
30
31
Taisha:~/tttmp/to_hash $ time perl to_hash_test.pl inline 100 100000
 
real	0m11.438s
user	0m0.015s
sys	0m0.015s
Taisha:~/tttmp/to_hash $ time perl to_hash_test.pl reverse 100 100000
 
real	0m13.841s
user	0m0.015s
sys	0m0.015s
Taisha:~/tttmp/to_hash $ time perl to_hash_test.pl while 100 100000
 
real	0m14.316s
user	0m0.015s
sys	0m0.015s
Taisha:~/tttmp/to_hash $ time perl to_hash_test.pl pop 100 100000
 
real	0m14.041s
user	0m0.047s
sys	0m0.000s
Taisha:~/tttmp/to_hash $ time perl to_hash_test.pl recursive 100 100000
 
real	0m18.402s
user	0m0.047s
sys	0m0.000s
Taisha:~/tttmp/to_hash $ time perl to_hash_test.pl altrec 100 100000
 
real	0m17.717s
user	0m0.015s
sys	0m0.015s
Taisha:~/tttmp/to_hash $

En fait j'ai un problème avec les deux versions récursives qui semblent causer des fuites de mémoire, que je n'ai pas encore eu le temps d'investiguer... J'ai codé la version inline pour me rafraîchir un peu sur le sujet.

Oh, et pour mémoire, encore une version pure perl :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
Taisha:~/tttmp/to_hash $ perl -MData::Dumper -e 'sub to_hash { my $c; my $i = @_; $c = { $_[$i] => $c } while $i--; $c }; print Dumper(to_hash(qw/a b c d/))'
$VAR1 = {
          'a' => {
                   'b' => {
                            'c' => {
                                     'd' => undef
                                   }
                          }
                 }
        };
Taisha:~/tttmp/to_hash $

**Philou67430** · 24/10/2013, 13h45

Envoyé par cmcmc

C'est ironique

?

Juste humoristique, ce n'était pas moqueur

Convertir liste plate en hash spécifique

Langage Perl

Discussions similaires

Partager

Partager