How to filter few key value pairs from hash reference

[jaypal]

Hello Perl Monks,

I need some suggestions in filtering out few key value pairs from a hash reference. Here is a quick example that will probably demonstrate what I am trying to do (you will notice that in my final data structure the array of hashes has one key value pair less as it has been moved outside of array):

Lets assume I have a following data structure:

@data = (
        {
             id => '1',
             name => 'Tom',
             sex => 'Male',
        }, 
        {
             id => '2',
             name => 'Harry',
             sex => 'Male',
        }, 
        {
             id => '3',
             name => 'Pam',
             sex => 'Female',
        }, 
        {
             id => '4',
             name => 'Dick',
             sex => 'Male',
        }
);

From this array of hashes, I am interested in creating a hash of array of hashes which will have inner key of sex whose value will be array of hashes.

My attempt to do this was as follows:

use strict;
use warnings;
use Storable qw / dclone /;

#my @data = ( ... ) As shown above;

my $data2;
for my $href ( @data ) {
    my $copy_ref = dclone($href);
    my $sex = $copy_ref->{sex};
    delete $copy_ref->{sex};
    push @{ $data2->{$sex} }, $copy_ref;
}

use Data::Dumper;
print Dumper $data2;

This was the output:

$VAR1 = {
          'Female' => [
                        {
                          'name' => 'Pam',
                          'id' => '3'
                        }
                      ],
          'Male' => [
                      {
                        'name' => 'Tom',
                        'id' => '1'
                      },
                      {
                        'name' => 'Harry',
                        'id' => '2'
                      },
                      {
                        'name' => 'Dick',
                        'id' => '4'
                      }
                    ]
        };

I am creating a copy of the hash reference and then manipulating the copy reference and then adding it to new data structure to protect my original data structure. Is there a better way to filter certain key value pairs from a hash reference without having to create a copy reference but protecting the original data structure.

Since this is only for learning purposes, I am interested in looking at other options even if they come at the cost of readability.

Looking forward to your wisdom.

Regards
Jaypal

[choroba]

Have you tried printing Dumper \@data after you populate $data2? It seems you aren't creating a copy of the hash. To do that, you'd need something like

for my $href ( @data ) {
    my $copy_ref = { %$href };
    delete $copy_ref->{sex};
    push @{ $data2->{$href->{sex}} }, $copy_ref;
}

Or, you can construct the target hash on the fly:

for my $href (@data) {
    push @{ $data3->{ $href->{sex} } },
         { map 'sex' eq $_ ? () : ( $_ => $href->{$_} ), keys %$href }
+;
}

[jaypal]

Hi Choroba,

Yes, I typed that up in a hurry. I just updated to reflect the use of dclone to copy a hash reference.

Thanks for the alternatives, I will try them out shortly.

[johngg]

Just push onto the correct sex which items you want from the original AoH.

use strict;
use warnings;

use Data::Dumper;

my @data = (
   {
       id   => q{1},
       name => q{Tom},
       sex  => q{Male},
   }, 
   {
       id   => q{2},
       name => q{Harry},
       sex  => q{Male},
   }, 
   {
       id   => q{3},
       name => q{Pam},
       sex  => q{Female},
   }, 
   {
       id   => q{4},
       name => q{Dick},
       sex  => q{Male},
   }
   );

my $rhBySex = { Male => [], Female => [] };

push @{ $rhBySex->{ $_->{ sex } } },
   { name => $_->{ name }, id => $_->{ id } }
   for @data;

print Data::Dumper->Dumpxs( [ $rhBySex ], [ qw{ rhBySex } ] );

Produces

$rhBySex = {
             'Female' => [
                           {
                             'id' => '3',
                             'name' => 'Pam'
                           }
                         ],
             'Male' => [
                         {
                           'name' => 'Tom',
                           'id' => '1'
                         },
                         {
                           'id' => '2',
                           'name' => 'Harry'
                         },
                         {
                           'id' => '4',
                           'name' => 'Dick'
                         }
                       ]
           };

I hope this is helpful.

[jaypal]

Thanks JohnGG, appreciate the alternative.

[CountZero]

I assume the data in your array of hashes will be sourced from an external file and will be much larger than a few records. Why then not transform that external file into a "real" database which you can manipulate with standard SQL queries? In the long run that will save time and effort.

[jaypal]

Thanks CountZero for the suggestion. This was just a learning exercise where I was looking for copying a subset of a hash. Typically, I would use a hash slice but here I was looking to copy the key value pairs.

The map solution posted by choroba seems to be exactly what I needed (without creating a temporary copy of hash reference) though impairs readability (probably due to ternary op). Solution by JohnGG looks promising and quite readable but may not scale well if we have large sets of key value pairs to keep.

Still hoping to find a sweet spot between the two solutions.

[choroba]

Typically, I would use a hash slice

Time to upgrade to 5.20, it seems: New slice syntax.

[einhverfr]

A simple way to do this would be to copy using map and grep. Note since you are doing this multiple times you will probably be better off with a for loop in this case, but this is good to know because if you don't want to do this multiple times, map is usually cleaner:

my $categorized_data = {
     Male   => map { id => $_->{id}, name => $_->{name} }
               grep { $_->{sex} eq 'Male' } @data,
     Female => map { id => $_->{id}, name => $_->{name} }
               grep { $_->{sex} eq 'Female' } @data,
};

Naturally the above is just an example. You probably wouldn't want to grep and map each list multiple times if it was very large, but if you were filtering a small number of keys on a small subset of a list that's how I would do it.