$keys = join '|', map "\Q$_\E", keys %sub_hash;
$keys_REx = qr/$keys/;

$string =~ s/($keys_REx)/$sub_hash{$1}/g;
[download]

I'm not sure about the application, but it might be advisable to at least put in some '\b's to prevent unfortunate collisions that would render some names as "Mikestone", or "Moeseph".

Here is a slight modification of japhy's (or merlyn's, you decide) code:

  $keys     = join '|', map "\\b\Q$_\E\\b", keys %sub_hash;
  $keys_REx = qr/$keys/;
  $string   =~ s/($keys_REx)/$sub_hash{$1}/g;
[download]

my $regex = join "|", map quotemeta, keys %substitute_hash;
$regex = qr/$regex/; # compile
...
$string =~ s/($regex)/$substitute_hash{$1}/g;
[download]

-- Randal L. Schwartz, Perl hacker

You might want to throw in a reverse sort there. It was not in the spec, but it may happen that someone will want to do one substitution on "foo" and another on "foobar". Since Perl's REs are DFAs rather than NFAs this is not going to work unless in the RE you see foobar before foo.,,

As a lowly acolyte I have great respect for <kbd>map</kbd> and a fondness of good old <kbd>foreach</kbd>. So I naturally thought: isn't a loop with simple pattens faster than a pattern with <kbd>|</kbd> in it?

Here's my benchmarking code:

use Benchmark;

timethese(500, {
        'or pattern'    => \&orpattern,
        'many patterns' => \&manypatterns
});


sub init {
   %sub_hash = (John => Mike, Jack => Mark, Joe => Moe);
   $string = "Dear John!.\nI've run off with Jack and Joe.\nSue\n\n"
               x 1000;
}


sub orpattern {
        init;

        my $keys = join '|', map "\Q$_\E", keys %sub_hash;
        my $keys_REx = qr/$keys/;

        $string =~ s/($keys_REx)/$sub_hash{$1}/g;
        return $string;
}

sub manypatterns {
        init;

        my %patterns = map { qr/$_/ => $sub_hash{$_} } 
              keys %sub_hash;

        foreach $pat (keys %patterns) {
                my $replace = $patterns{$pat};
                $string =~ s/$pat/$replace/g;
        }
        return $string;
}
[download]

And the results:

Benchmark: timing 500 iterations of many patterns, or pattern...
many patterns:  2 wallclock secs ( 1.61 usr +  0.00 sys =  1.61 CPU)
or pattern: 12 wallclock secs (11.94 usr +  0.01 sys = 11.95 CPU)

Of course there's a difference in functionality between the two, just think of:

%substitute_hash = ( Jack => Chris,  Chris => Jaquline );
[download]

--
Brigitte    'I never met a chocolate I didnt like'    Jellinek
http://www.horus.com/~bjelli/         http://perlwelt.horus.at

If you're doing a lot of this kind of thing then maybe you should consider one of the many templating systems available from the CPAN. I'm a particular fan of the Template Toolkit.

"Perl makes the fun jobs fun
and the boring jobs bearable" - me

Just wanted to say: I think it's pretty cool that both answers given are exactly the same (barring minor naming differences). Gave me a chuckle, anyway...

Chris
M-x auto-bs-mode

That's because this is an idiomatic way of doing it. We've all copied the same notes from the same authors. {grin}

-- Randal L. Schwartz, Perl hacker

while (<IN_FILE>) {
    foreach my $key (keys %substitute_hash) {
        s/$key/$substitute_hash{$key}/g;
    }
}
[download]

Now, obviously, you'll need to assign the sub'ed into string to something if you want to save it and this will also overwrite previous substitutions. That may or may not be a factor.

Now, if you want to do this real-time, you'll want to do it as above. But, I have a script that reads through some 100,000 lines of code in ~1450 files doing a given match and it runs in 10-30 seconds. (This is a compilation script, in case you're wondering.) I also have another script that does a number of matches and cross-correlations on those same files and it runs in about 2 minutes. Unless you really need to get faster than that, KISS.