Alternative to many substitutions in a row? [closed] - regex

Question

Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 7 years ago.
Improve this question
Most of my Perl scripts deal with converting ugly formats to the plain TXT content. So far, I've done this with dozens and dozens of substitutions all in a row. Is there a more elegant way to do this in Perl? For instance, a hash containing all the s/// pairs, or even an external file containing the substitutions?
I'm just wondering how other people handle this kind of formatting script, or if just having a novel's worth of s/// expressions is the normal way to go. It gets hard to manage at a certain point.
Thanks!

Answer 1

Sometimes the most efficient approach is to parse the old data format into a memory structure and then output the new format.
Depending on the structure, this can be done line by line. But if you have to do the whole document that works, as long as they aren't too gigantic.
As an example, this is how you'd do an image file conversion: read a GIF into a bitmap and then produce a JPEG output. You wouldn't use regular expressions, even if you could, it would be horribly inefficient.

Answer 2

I have a utility method I use all the time for this:
sub subst($#) {
my($x, #map) = #_;
#map % 2 == 0 or die 'subst requires an odd number of params';
while (#map) {
my $from = shift(#map);
my $to = shift(#map);
$x =~ s/$from/$to/g;
}
return $x;
}
I use a list instead of a hash for map so I can control the order. Use it like this:
my $new_x = subst($x,
pattern1 => replacement1,
pattern2 => replacement2);
Even with a single pattern, it's simpler if you aren't substituting something in place. I.e. it's cleaner than this:
my $new_x = $x;
$new_x =~ s/pattern1/replacement1/g;

Answer 3

Zan Lynx gives good advice, but to answer your question about hash-driven substitutions, you can use the following:
my %replacements = (
foo => 'bar',
bar => 'baz',
baz => 'foo',
# ...
);
my $pat = join '|', map quotemeta, keys %replacements;
s/($pat)/$replacements{$1}/g;
This solves two problems:
It scans the input only once, not once per pattern.
It takes away the risk of accidentally matching the replacements of earlier substitutions. In fact, the example I used couldn't be accomplished with three substitutions.

Answer 4

This is an awkward question because the order of the substitutions affects the result
If your changes are so extensive then I would much prefer a sequence of s/// statements to anything held in a hash, which would shuffle the substitutions into a different order each time the program was run
I would still be worried about the accuracy of “dozens and dozens” (two hundred plus?) of substitutions, but at least the result would be under control