Dynamicznie/rekursywnie buduje hasze w Perlu?

Question

Jestem całkiem nowy w Perlu i staram się skompilować rekursywnie rekursywnie i nigdzie nie docierając. Próbowałem szukać tutoriali, aby dynamicznie budować hasze, ale wszystko, co mogłem znaleźć, to wstępne artykuły o hashe. Byłbym wdzięczny, gdybyś skierował mnie w dobrym kierunku lub zaproponował fajny artykuł/samouczek.

Próbuję odczytać z pliku, który ma ścieżek w postaci

one/two/three 
four 
five/six/seven/eight 

i chcę zbudować hash jak

VAR = { 
    one : { 
     two : { 
      three : "" 
     } 
    } 
    four : "" 
    five : { 
     six : { 
      seven : { 
       eight : "" 
      } 
     } 
    } 
} 

Skrypt używam obecnie jest :

my $finalhash = {}; 
my @input = <>; 

sub constructHash { 
    my ($hashrf, $line) = @_; 
    @elements = split(/\//, $line); 
    if(@elements > 1) { 
     $hashrf->{shift @elements} = constructHash($hashrf->{$elements[0]}, @elements); 
    } else { 
     $hashrf->{shift @elements} = ""; 
    } 
    return $hashrf; 
} 

foreach $lines (@input) { 
    $finalhash = constructHash($finalhash, $lines); 
} 

Answer 1

To trochę naciągane, ale to działa:

sub insert { 
    my ($ref, $head, @tail) = @_; 
    if (@tail) { insert(\%{$ref->{$head}}, @tail) } 
    else   {   $ref->{$head} = ''  } 
} 

my %hash; 
chomp and insert \%hash, split('/', $_) while <>; 

Opiera się on autovivification, który jest wprawdzie nieco wyprzedza dla początkujących.

To, co prawdopodobnie spowodowałoby, że jakakolwiek odpowiedź na twoje pytanie jest nieco zakręcona, to prośby o puste struny w liściach, które mają inny "typ" niż skróty węzłów i wymagają innej operacji dereferencyjnej.

Answer 2

Nigdy nie zrobiłem czegoś takiego, więc to podejście prawdopodobnie będzie złe, ale cóż, oto mój shot:

use 5.013; 
use warnings; 
use Data::Dumper; 

sub construct { 
    my $hash = shift; 
    return unless @_; 

    return construct($hash->{shift()} //= {}, @_); 
} 

my %hash; 

while (<DATA>) { 
    chomp; 
    construct(\%hash, split m!/!); 
} 

say Dumper \%hash; 

__DATA__ 
one/two/three 
four 
five/six/seven/eight 

EDYCJA: Naprawiono!

EDIT2: A (jak sądzę) zoptymalizowana wersja z ogonem, ponieważ!

sub construct { 
    my $hash = shift; 
    return unless @_; 
    unshift @_, $hash->{shift()} //= @_ ? {} : ''; 

    goto &construct; 
} 

Answer 3

Pobiegłem swój kod i znalazłem kilka problemów:

• jeszcze nie scoped @elements prawidłowo.
• z tą rekursją tworzysz hasz, który się odwołuje, czyli , a nie czego chcesz.
• w swoim najdalszym rozmowy, drugi arg do constructHash() jest ciągiem znaków, ale na rekurencyjnego wywołania wewnątrz, mijamy tablicę @elements

Spróbuj tego.

use Data::Dumper; 

my $finalhash = {}; 
my @input = split "\n", <<INPUT; 
one/two/three 
four 
five/six/seven/eight 
INPUT 

sub constructHash { 
    my $line = shift; 
    my ($first, $remainder) = split(/\//, $line,2); 

    if ($remainder) { 
     return { $first => constructHash($remainder) } ; 
    } else { 
     return { $first , "" }; 
    } 
} 

foreach $lines (@input) { 
    my $linehash = constructHash($lines); 
    my $firstkey = (keys %$linehash)[0]; 
# print Dumper $linehash; 
    $finalhash->{$firstkey} = $linehash->{$firstkey}; 
} 


print Dumper $finalhash; 

Produkuje

$VAR1 = { 
      'five' => { 
         'six' => { 
           'seven' => { 
               'eight' => '' 
              } 
           } 
        }, 
      'one' => { 
        'two' => { 
           'three' => '' 
           } 
        }, 
      'four' => '' 
     }; 

Pamiętaj, mieszań Perl nie są sortowane.

Answer 4

Podstawy:

• the Perl data structure cookbook
• autovivification

Answer 5

Data::Diver obejmuje tę niszę tak dobrze, że ludzie nie powinni wyważać otwartych drzwi.

use strict; 
use warnings; 
use Data::Diver 'DiveVal'; 
use Data::Dumper; 

my $root = {}; 
while (my $line = <DATA>) { 
    chomp($line); 
    DiveVal($root, split m!/!, $line) = ''; 
} 
print Dumper $root; 
__DATA__ 
one/two/three 
four 
five/six/seven/eight