hash de construcción dinámica/recursiva en Perl?

Question

Soy bastante nuevo para Perl y estoy tratando de construir hash recursivamente y llegar a ninguna parte. Traté de buscar tutoriales para construir hashes dinámicamente, pero todo lo que pude encontrar fueron artículos introductorios sobre hashes. Le agradecería me señalara en la dirección correcta o sugiriera un buen artículo/tutorial.

Estoy intentando leer desde un archivo que tiene caminos en forma de

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

y quiero construir un hash como

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

El script que estoy usando actualmente es :

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

Esto es un poco exagerado, pero funciona:

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

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

Se basa en autovivification, que es sin duda un poco avanzado para un principiante.

Lo que probablemente haría que una respuesta a su pregunta sea un poco retorcida es que usted pide cadenas vacías en las hojas, que es de un "tipo" diferente a los hashes de los nodos, y requiere una operación de eliminación de referencias diferente.

Answer 2

Nunca he hecho algo como esto, por lo que este enfoque es probable que sea incorrecto, pero bueno, aquí está mi tiro:

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 

EDIT: Reparado!

EDIT2: Una (creo) la versión optimizada de la cola, porque!

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

    goto &construct; 
} 

Answer 3

que corrió su código y encontraron algunos problemas:

• usted no ha de ámbito @elements correctamente.
• con esa recursión está creando un hash que hace referencia a sí mismo, que es no lo que quiere.
• en su llamada externa, el segundo arg a constructHash() es una cadena, pero en la llamada recursiva en el interior, se pasa una matriz de @elements

Prueba esto.

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; 

Produce

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

Recuerde, los hash de Perl no están ordenados.

Answer 4

Los fundamentos:

• the Perl data structure cookbook
• autovivification

Answer 5

Data::Diver cubre este nicho tan bien que no hay que reinventar la rueda.

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