8

我对 Perl 很陌生，我正在尝试以递归方式构建散列并且无处可去。我尝试搜索动态构建散列的教程，但我能找到的只是关于散列的介绍性文章。如果您指出我正确的方向或建议一篇不错的文章/教程，我将不胜感激。

我正在尝试从具有以下形式的路径的文件中读取

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

我想建立一个像

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

我目前使用的脚本是：

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);
}
4

5 回答 5

7

Data::Diver很好地涵盖了这个利基市场，以至于人们不应该重新发明轮子。

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
于 2010-12-30T02:44:12.880 回答
6

这有点牵强，但它有效：

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

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

它依赖于自动生存，这对于初学者来说确实有点先进。

可能会使您的问题的任何答案有点扭曲的是，您要求叶子中的空字符串，它与节点的哈希具有不同的“类型”，并且需要不同的取消引用操作。

于 2010-12-30T00:34:42.257 回答
4

我从来没有做过这样的事情，所以这种方法可能是错误的，但是，这是我的镜头：

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

编辑：固定！

EDIT2：（我认为）尾调用优化版本，因为！

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

   goto &construct;
}
于 2010-12-30T00:25:00.837 回答
3

我运行了你的代码，发现了一些问题：

  • 您没有@elements正确确定范围。
  • 通过该递归，您正在创建一个引用自身的哈希，这不是您想要的。
  • 在最外面的调用中，第二个 arg toconstructHash()是一个字符串，但是在内部的递归调用中，您传递了一个数组@elements

试试这个。

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;

它产生

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

请记住，Perl 哈希没有顺序。

于 2010-12-30T00:42:15.620 回答
1

基础：

于 2010-12-30T00:52:09.127 回答