Question

I have a file and a list of string pairs which I get from another file. I need substitute the first string of the pair with the second one, and do this for each pair.
Is there more efficient/simple way to do this (using Perl, grep, sed or other), then running a separate regexp substitution for each pair of values?

Answer 1

#! /usr/bin/perl

use warnings;
use strict;

my %replace = (
  "foo" => "baz",
  "bar" => "quux",
);

my $to_replace = qr/@{["(" .
                       join("|" => map quotemeta($_), keys %replace) .
                       ")"]}/;

while (<DATA>) {
  s/$to_replace/$replace{$1}/g;
  print;
}

__DATA__
The food is under the bar in the barn.

The @{[...]} bit may look strange. It’s a hack to interpolate generated content inside quote and quote-like operators. The result of the join goes inside the anonymous array-reference constructor [] and is immediately dereferenced thanks to @{}.

If all that seems too wonkish, it’s the same as

my $search = join "|" => map quotemeta($_), keys %replace;
my $to_replace = qr/($search)/;

minus the temporary variable.

Note the use of quotemeta—thanks Ivan!—which escapes the first string of each pair so the regular-expression engine will treat them as literal strings.

Output:

The bazd is under the quux in the quuxn.

Metaprogramming—that is, writing a program that writes another program—is also nice. The beginning looks familiar:

#! /usr/bin/perl

use warnings;
use strict;

use File::Compare;

die "Usage: $0 path ..\n" unless @ARGV >= 1;

# stub
my @pairs = (
  ["foo"     => "baz"],
  ["bar"     => "quux"],
  ['foo$bar' => 'potrzebie\\'],
);

Now we generate the program that does all the s/// replacements—but is quotemeta on the replacement side a good idea?—

my $code =
  "sub { while (<>) { " .
  join(" " => map "s/" . quotemeta($_->[0]) .
                  "/"  . quotemeta($_->[1]) .
                  "/g;",
              @pairs) .
  "print; } }";
#print $code, "\n";

and compile it with eval:

my $replace = eval $code
  or die "$0: eval: $@\n";

To do the replacements, we use Perl’s ready-made in-place editing:

# set up in-place editing
$^I = ".bak";
my @save_argv = @ARGV;

$replace->();

Below is an extra nicety that restores backups that the File::Compare module judges to have been unnecessary:

# in-place editing is conservative: it creates backups
# regardless of whether it modifies the file
foreach my $new (@save_argv) {
  my $old = $new . $^I;
  if (compare($new, $old) == 0) {
    rename $old => $new
      or warn "$0: rename $old => $new: $!\n";
  }
}