Пересечение многомерного хеша в Perl

Подготовьте тот: не изобретать велосипед :)

Быстрый поиск на CPAN подбрасывает невероятно полезные Данные:: Обход. Определите подпрограмму для обработки каждого узла, и Вы отсортированы

use Data::Walk;

my $data = { # some complex hash/array mess };

sub process {
   print "current node $_\n";
}

walk \&process, $data;

И Ваш дядя Bob's. Обратите внимание, что, если Вы хотите передать его хеш для обхода, необходимо будет передать ссылку на него (см. perldoc perlref), следующим образом (иначе это попытается обработать ключи хеша также!):

walk \&process, \%hash;

Для более комплексного решения (но тяжелее найти на первый взгляд в CPAN), используйте Данные:: Посетитель:: Обратный вызов или его родительский модуль - это имеет преимущество давания Вам более прекрасный контроль того, что Вы делаете, и (только для дополнительного уважения) записан с помощью Американского лося.

Это звучит мне как будто Данные:: Дайвер или Данные:: Посетитель является хорошими подходами для Вас.

Следует иметь в виду, что списки Perl и хеши не имеют размеров и так не могут быть многомерными. То, что Вы можете иметь, является объектом хеша, который установлен сослаться на другой хеш или список. Это может использоваться для создания поддельных многомерных структур.

После того как Вы понимаете это, вещи становятся легкими. Например:

sub f($) {
  my $x = shift;
  if( ref $x eq 'HASH' ) {
    foreach( values %$x ) {
      f($_);
    }
  } elsif( ref $x eq 'ARRAY' ) {
    foreach( @$x ) {
      f($_);
    }
  }
}

Добавьте любые потребности, которые будут сделаны помимо пересечения структуры, конечно.

Один изящный способ сделать, в чем Вы нуждаетесь, состоит в том, чтобы передать ссылку кода, которую назовут из f. При помощи sub разработка прототипа Вы могли даже выполнить вызовы, похожи на grep Perl и функции карты.

Можно также уклониться от многомерных массивов, если у Вас всегда есть все значения ключа, или Вы просто не должны получать доступ к индивидуальным уровням как к отдельным массивам:

$arr{"foo",1} = "one";
$arr{"bar",2} = "two";

while(($key, $value) = each(%arr))
{
    @keyValues = split($;, $key);
    print "key = [", join(",", @keyValues), "] : value = [", $value, "]\n";
}

Это использует нижний разделитель "$"; как разделитель для нескольких значений в ключе.

Нет никакого способа получить семантику, которую Вы описываете потому что foreach выполняет итерации по списку одного элемента за один раз. Вы должны были бы иметь deep_keys возвратите LoL (список списков) вместо этого. Даже это не работает в общем случае произвольной структуры данных. Там мог варьироваться уровни подхешей, некоторые уровни могли быть судьями МАССИВА и т.д.

Способ Perlish сделать это состоял бы в том, чтобы записать функцию, которая может обойти произвольную структуру данных и применить обратный вызов в каждом "листе" (то есть, нессылочное значение). ответ bmdhack является начальной точкой. Точная функция варьировалась бы зависящий та, что Вы хотели сделать на каждом уровне. Это довольно просто, если все, о чем Вы заботитесь, является листовыми значениями. Вещи становятся более сложными, если Вы заботитесь о ключах, индексах, и т.д. который получил Вас к листу.

Достаточно легко, если все, что Вы хотите сделать, воздействуют на значения, но если Вы хотите воздействовать на ключи, Вам нужны спецификации того, как уровни будут восстанавливаемыми.

a. Например, Вы могли указать ключи как "$level1_key.$level2_key.$level3_key"- или любой разделитель, представляя уровни.

b. Или у Вас мог быть список ключей.

Я рекомендую последнему.

• Уровень может быть понят под @$key_stack

• и самый локальный ключ $key_stack->[-1].

• Путь может быть восстановлен: join( '.', @$key\_stack )

Код:

use constant EMPTY_ARRAY => [];
use strict;    
use Scalar::Util qw<reftype>;

sub deep_keys (\%) { 
    sub deeper_keys { 
        my ( $key_ref, $hash_ref ) = @_;
        return [ $key_ref, $hash_ref ] if reftype( $hash_ref ) ne 'HASH';
        my @results;

        while ( my ( $key, $value ) = each %$hash_ref ) { 
            my $k = [ @{ $key_ref || EMPTY_ARRAY }, $key ];
            push @results, deeper_keys( $k, $value );
        }
        return @results;
    }

    return deeper_keys( undef, shift );
}

foreach my $kv_pair ( deep_keys %$f ) { 
    my ( $key_stack, $value ) = @_;
    ...
}

Это было протестировано в Perl 5.10.

Если Вы работаете с древовидными данными, идущими больше чем два уровня глубоко, и Вы желаете для обхода того дерева, необходимо сначала полагать, что Вы собираетесь сделать большую дополнительную работу для себя, если Вы планируете перереализацию всего, что необходимо сделать вручную на хешах хешей хешей, когда существует много хороших доступных альтернатив (ищите CPAN "Дерево").

Не зная, каковы Ваши требования к данным на самом деле, я собираюсь вслепую указать на Вас на учебное руководство для Дерева:: DAG_Node для запущения Вас.

Тем не менее Лесоруб корректен, hashwalk наиболее легко сделан с рекурсией. Вот пример для запущения Вас, если Вы чувствуете, что абсолютно необходимо решить проблему с хешами хешей хешей:

#!/usr/bin/perl
use strict;
use warnings;

my %hash = (
    "toplevel-1" => 
    { 
        "sublevel1a"  => "value-1a",
        "sublevel1b"  => "value-1b"
    },
    "toplevel-2" =>
    {
        "sublevel1c" => 
        {
            "value-1c.1" => "replacement-1c.1",
            "value-1c.2" => "replacement-1c.2"
        },
        "sublevel1d" => "value-1d"
    }
);

hashwalk( \%hash );

sub hashwalk
{
    my ($element) = @_;
    if( ref($element) =~ /HASH/ )
    {
        foreach my $key (keys %$element)
        {
            print $key," => \n";
            hashwalk($$element{$key});
        }
    }
    else
    {
        print $element,"\n";
    }
}

Это произведет:

toplevel-2 => 
sublevel1d => 
value-1d
sublevel1c => 
value-1c.2 => 
replacement-1c.2
value-1c.1 => 
replacement-1c.1
toplevel-1 => 
sublevel1a => 
value-1a
sublevel1b => 
value-1b

Обратите внимание, что Вы, которых предсказывает CAN НЕ, в каком порядке будут пересечены элементы хеша, если Вы не свяжете хеш через Связь:: IxHash или подобный — снова, если Вы собираетесь пройти так много работы, я рекомендую древовидный модуль.