Dynamisch/rekursiv Hashes in Perl erstellen?

Question

Ich bin ziemlich neu in Perl und ich versuche, einen Hash rekursiv zu erstellen und nirgendwo zu bekommen. Ich habe versucht, nach Tutorials zu suchen, um Hashes dynamisch zu erstellen, aber alles, was ich finden konnte, waren einführende Artikel über Hashes. Ich wäre dankbar, wenn Sie mich in die richtige Richtung weisen oder einen schönen Artikel/Tutorial vorschlagen.

Ich versuche, aus einer Datei zu lesen, die Pfade in Form von

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

hat, und ich möchte einen Hash wie

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

Das Skript zur Zeit verwende ich bauen :

Answer 1

Das ist ein bisschen weit hergeholt, aber es funktioniert:

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

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

Es auf autovivification beruht, die zwar ein bisschen ist für einen Anfänger fortgeschritten.

Was wahrscheinlich eine Antwort auf Ihre Frage ein wenig verdreht wäre, ist, dass Sie nach leeren Strings in den Blättern fragen, die einen anderen "Typ" als die Hashes der Knoten haben und eine andere Dereferenzierung erfordern.

Answer 2

Ich habe so etwas noch nie gemacht, also ist dieser Ansatz wahrscheinlich falsch, aber gut, hier ist mein Aufnahme:

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 

BEARBEITEN: Korrigiert!

EDIT2: Eine (ich glaube) Tail-Call-optimierte Version, weil!

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

    goto &construct; 
} 

Answer 3

lief ich Ihren Code und fand ein paar Probleme:

• Sie nicht @elements richtig scoped haben.
• mit dieser Rekursion erstellen Sie einen Hash, der sich selbst referenziert, das ist nicht was Sie wollen.
• in Ihrem äußersten Anruf, der zweite ARG constructHash() ist eine Zeichenfolge, aber auf dem rekursiven Aufruf nach innen, übergeben Sie ein Array von @elements

bereits.

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; 

Es produziert

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

Denken Sie daran, sind Perl-Hashes nicht bestellt.

Answer 4

Die Grundlagen:

• the Perl data structure cookbook
• autovivification

Answer 5

Data::Diver deckt diese Nische so gut, dass die Menschen nicht das Rad neu erfinden sollte.

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