delete @hash{grep !/\d+_\d+/, keys %hash};
[download]

And, of course, you can omit the delete if you want the expression to evaluate to the desired hash without modifying the original data.

Thanks, merlyn!

With that, I can now proceed with my coding.

foreach (keys %hash) {
    delete($hash{$_}) if ($_ !~ /\d+_\d+/);
}
[download]

Going to see if merlyn's example works on my version of Perl... Oh neat, it does. I think his trumps mine by a bit.

Simply test the keys against your pattern:

foreach my $key ( keys %hash )
{
    if( $key =~ m/\d+_\d+/ )
    {
         print "key = $key, value = $hash{$key}\n";
    }
}
[download]

Or am I missing something?

HTH

Update: I forgot about the "modify hash" requirement - sorry. merlyn came up with a great one-liner, of course!

Thanks, bobf!

That was what I was going to do. But if I had proportionately more unwanted key-value pairs, the looping of keys to get to the right key-value pair might become an expensive operation.

Or some iterative versions which do a little less work:

# destructive
while( my $k = each %hash ) {
    delete $hash{ $k } unless $k =~ /\d+_\d+/;
}

# nondestructive
my %hash2;
while( my( $k, $v ) = each %hash ) {
    $hash2{ $k } = $v if $k =~ /\d+_\d+/;
}
[download]

or maybe

# destructive
/\d+_\d+/ or delete $hash{ $_ } while local $_ = each %hash;

# nondestructive
my %hash2;
/\d+_\d+/ and $hash2{ $_ } = $a while local( $_, $a ) = each %hash;
[download]

Makeshifts last the longest.

You might also have a look at Tie::Hash::Regex

Non-destructively:

  my %hash2 = map  {$_ => $hash{$_}}
              grep {/^\d+_\d+$/}
              keys %hash;
[download]

You can pick more than one value at a time out of a hash — see merlyn's code and gaal's remark.

my %hash2 = @hash{ grep /\d+_\d+/, keys %hash };
[download]

Update: thanks to bobf for notifying me that this code makes, uh, very little sense. Here's a hash slice incantation that actually works:

my %hash2;
@hash2{ @$_ } = @hash{ @$_ } for [ grep /\d+_\d+/, keys %hash ];

# or more verbosely

my %hash2;
{
    my @key = grep /\d+_\d+/, keys %hash;
    @hash2{ @key } = @hash{ @key };
}
[download]

Makeshifts last the longest.