Inverting a Hash's Key and Values in Perl

I would like to make the value the key, and the开发者_运维问答 key the value. What is the best way to go about doing this?

Adapted from http://www.dreamincode.net/forums/topic/46400-swap-hash-values/:

Assuming your hash is stored in $hash:

while (($key, $value) = each %hash) {
   $hash2{$value}=$key;
}

%hash=%hash2;

Seems like much more elegant solution can be achieved with reverse (http://www.misc-perl-info.com/perl-hashes.html#reverseph):

%nhash = reverse %hash;

Note that with reverse, duplicate values will be overwritten.

Use reverse:

use Data::Dumper;

my %hash = ('month', 'may', 'year', '2011');
print Dumper \%hash;
%hash = reverse %hash;
print Dumper \%hash;

As mentioned, the simplest is

my %inverse = reverse %original;

It "fails" if multiple elements have the same value. You could create an HoA to handle that situation.

my %inverse;
push @{ $inverse{ $original{$_} } }, $_ for keys %original;

So you want reverse keys & vals in a hash? So use reverse... ;)

%hash2 = reverse %hash;

reverting (k1 => v1, k2 => v2) - yield (v2=>k2, v1=>k1) - and that is what you want. ;)

my %orig_hash = (...);
my %new_hash;

%new_hash = map { $orig_hash{$_} => $_ } keys(%orig_hash);

The map-over-keys solution is more flexible. What if your value is not a simple value?

my %forward;
my %reverse;

#forward is built such that each key maps to a value that is a hash ref:
#{ a => 'something', b=> 'something else'}

%reverse = map { join(',', @{$_}{qw(a b)}) => $_ } keys %forward;

Here is a way to do it using Hash::MultiValue.

use experimental qw(postderef);

sub invert {
  use Hash::MultiValue;
  my $mvh = Hash::MultiValue->from_mixed(shift);

  my $inverted;    
  $mvh->each( sub { push $inverted->{ $_[1] }->@* , $_[0] } ) ;
  return $inverted;
}

To test this we can try the following:

my %test_hash = (
  q => [qw/1 2 3 4/],
  w => [qw/4 6 5 7/],
  e => ["8"],
  r => ["9"],
  t => ["10"],
  y => ["11"],
);

my $wow  = invert(\%test_hash);
my $wow2 = invert($wow);

use DDP;
print "\n \%test_hash:\n\n" ;
p %test_hash;
print "\n \%test_hash inverted as:\n\n" ;
p $wow ;

# We need to sort the contents of the multi-value array reference
# for the is_deeply() comparison:
map { 
   $test_hash{$_} = [ sort { $a cmp $b || $a <=> $b } @{ $test_hash{$_} } ] 
} keys %test_hash ; 

map { 
   $wow2->{$_} = [ sort { $a cmp $b || $a <=> $b } @{ $wow2->{$_} } ] 
} keys %$wow2 ; 

use Test::More ;
is_deeply(\%test_hash, $wow2, "double inverted hash == original");
done_testing;

Addendum

Note that in order to pass the gimmicky test here, the invert() function relies on %test_hash having array references as values. To work around this if your hash values are not array references, you can "coerce" the regular/mixed hash into a multi-value hash thatHash::MultiValue can then bless into an object. However, this approach means even single values will appear as array references:

for ( keys %test_hash )  { 
     if ( ref $test_hash{$_} ne 'ARRAY' ) { 
           $test_hash{$_}  = [ $test_hash{$_} ] 
     } 
}

which is longhand for:

ref($_) or $_ = [ $_ ] for values %test_hash ;

This would only be needed to get the "round trip" test to pass.

Assuming all your values are simple and unique strings, here is one more easy way to do it.

%hash = ( ... );
@newhash{values %hash} = (keys %hash);

This is called a hash slice. Since you're using %newhash to produce a list of keys, you change the % to a @.

Unlike the reverse() method, this will insert the new keys and values in the same order as they were in the original hash. keys and values always return their values in the same order (as does each).

If you need more control over it, like sorting it so that duplicate values get the desired key, use two hash slices.

%hash = ( ... );
@newhash{ @hash{sort keys %hash} } = (sort keys %hash);