/^redirect_(.*)/s and $fdat{$1} = $fdat{$_} for keys %fdat;
[download]

-- Randal L. Schwartz, Perl hacker

package Redirect_Hash;
sub TIEHASH {
  my ($class, $prefix) = @_;
  $prefix = 'redirect_' unless defined $prefix;
  my $self = [$prefix, {}];
  bless $self => $class;
}

sub STORE {
  my ($self, $key, $value) = @_;
  my ($prefix, $hash) = @$self;
  if (index($key, $prefix) == 0) {
    my $truncated = substr($key, length($prefix));
    $hash->{$truncated} = $value
      unless exists $hash->{$truncated};
  } 
  $hash->{$key} = $value;
}

sub FETCH {
  my ($self, $key) = @_;
  my ($prefix, $hash) = @$self;
  $hash->{$key};
}
[download]

To use this, you'd say:

tie %h => Redirect_Hash;

$h{redirect_name} = 'boondoggle';
print $h{name}, "\n"; # prints 'boondoggle'

$h{name} = 'Fred';
print $h{name}, "\n"; # still prints 'Fred'
print $h{redirect_name}, "\n"; # still prints 'boondoggle'
[download]

With the implementation I showed above, you can't use delete. It's not hard to come up with an implementation that fixes that, but I'll leave it as an exercise because I've noticed that people tend not to upvote posts that have too much code in them.

Consider picking up the code blind. Which is easier to understand?

   foreach $oldkey (keys %fdat) {
       if ( ($newkey = $oldkey) =~ s/^redirect_//) {
           $fdat{$newkey} = $fdat{$oldkey};
       }
   }

   $fdat{$_} = $fdat{"redirect_$_"} 
       for map { /^redirect_(.*)$/ ? $1 : () } keys %fdat;

Clarity, please.

Says dws:

> In terms of expressing intent, at least in my
> biased opinion, the original code fragment wins...

I agree. My first reaction on seeing the question was to ask "What's wrong with the code you have?"

That's why I tried to go in a drastically different direction with my answer.

FWIW, I became intrigued by all the suggestions here and found that Benchmark reveals Maclir's code to be the fastest (by about 30% on my system).

Philosophy can be made out of anything. Or less -- Jerry A. Fodor

foreach my $oldkey (keys %fdat) {
    if ( (my $newkey = $oldkey) =~ s/^redirect_//) {
        $fdat{$newkey} = $fdat{$oldkey};
    }
}
[download]

#!/usr/bin/perl -w
use strict;
use Data::Dumper;

my %hash = (
    'f_foo' => 'bleh',
    'f_bar' => 'blarf',
    'f_bas' => 'heh',
);

foreach(keys %hash) {
  $hash{$1} = $hash{$_} if(m/f_(.*)/);
}

print Dumper(\%hash);
[download]

%fdat = (
    'redirect_sam' => 'boondoggle'
);

$fdat{$_} = $fdat{"redirect_$_"} 
    for map /^redirect_(.*)$/, keys %fdat;
[download]

Or, alternately:

for(keys %fdat) {
    $fdat{$1} = $fdat{$_} if /^redirect_(.*)$/;
}
[download]

Don't know if you'll gain any speed from it, though. Please note, I used map instead of grep for the first snippet because I just wanted to return the matched part, not the entire list element as grep does.

HTH

'kaboo

Update:
Sigh... too slow... I like merlyn's tho, it's purtee.

I don't think your first one works. Here is a modified version:

$fdat{$_} = $fdat{"redirect_$_"} 
     for map { /^redirect_(.*)$/ ? $1 : () } keys %fdat;
[download]

Update: I did a lot of work for nothing. In a list context, a matching m// returns the list of captures, ($1), in this case. And a non-matching m// returns the empty list, (), not for example, a list containing one false value. This last item has bitten me several times; you'd think I'd have learned by now. ):

Thanks to chipmunk for reminding me of this.

        - tye (but my friends call me "Tye")