Speeding Up Interpolated Matches (Perl Cookbook, 2nd Edition)

## 6.10. Speeding Up Interpolated Matches

### 6.10.1. Problem

You want your function or program to take one or more regular expressions as arguments, but doing so seems to run slower than using literals.

### 6.10.2. Solution

To overcome this bottleneck, if you have only one pattern whose value won't change during the entire run of a program, store it in a string and use `/$pattern/o`:

>     while ($line = <>) {
>         if ($line =~ /$pattern/o) {
>             # do something
>         }
>     }

However, that won't work for more than one pattern. Precompile the pattern strings using the `qr//` operator, then match each result against each of the targets:

>     @pats = map { qr/$_/ } @strings;
>     while ($line = <>) {
>         for $pat (@pats) {
>             if ($line =~ /$pat/) {
>                 # do something;
>             }
>         }
>     }

### 6.10.3. Discussion

When Perl compiles a program, it converts patterns into an internal form. This conversion occurs at compile time for patterns without variables, but at runtime for those that do. Interpolating variables into patterns, as in `/$pattern/`, can slow your program down—sometimes substantially. This is particularly noticeable when `$pattern` changes often.

The `/o` modifier locks in the values from variables interpolated into the pattern. That is, variables are interpolated only once: the first time the match is run. Because Perl ignores any later changes to those variables, make sure to use it only on unchanging variables.

Using `/o` on patterns without interpolated variables doesn't hurt, but it also doesn't help. The `/o` modifier is also of no help when you have an unknown number of regular expressions and need to check one or more strings against all of these patterns, since you need to vary the patterns' contents. Nor is it of any use when the interpolated variable is a function argument, since each call to the function gives the variable a new value.

Example 6-4 is an example of the slow but straightforward technique for matching many patterns against many lines. The array `@popstates` contains the standard two-letter abbreviations for some of the places in the heartland of North America where we normally refer to soft drinks as pop (soda to us means either plain soda water or else handmade delicacies from the soda fountain at the corner drugstore, preferably with ice cream). The goal is to print any line of input that contains any of those places, matching them at word boundaries only. It doesn't use `/o`, because the variable that holds the pattern keeps changing.

#### Example 6-4. popgrep1

>       #!/usr/bin/perl
>       # popgrep1 - grep for abbreviations of places that say "pop"
>       # version 1: slow but obvious way
>       @popstates = qw(CO ON MI WI MN);
>       LINE: while (defined($line = <>)) {
>           for $state (@popstates) {
>               if ($line =~ /\b$state\b/) {  # this is  s l o o o w
>                   print; next LINE;
>              }
>           }
>       }

Such a direct, obvious, brute-force approach is also distressingly slow, because Perl has to recompile all patterns with each line of input. A better solution is the `qr//` operator (used in Example 6-5), which first appeared in v5.6 and offers a way to step around this bottleneck. The `qr//` operator quotes and possibly compiles its string argument, returning a scalar to use in later pattern matches. If that scalar is used by itself in the interpolated match, Perl uses the cached compiled form and so avoids recompiling the pattern.

#### Example 6-5. popgrep2

>       #!/usr/bin/perl
>       # popgrep2 - grep for abbreviations of places that say "pop"
>       # version 2: fast way using qr//
>       @popstates = qw(CO ON MI WI MN);
>       @poppats = map { qr/\b$_\b/ } @popstates;
>       LINE: while (defined($line = <>)) {
>           for $pat (@poppats) {
>               if ($line =~ /$pat/) {        # this is fast
>                   print; next LINE;
>              }
>           }
>       }

Print the array `@poppats` and you'll see strings like this:

>     (?-xism:\bCO\b)
>     (?-xism:\bON\b)
>     (?-xism:\bMI\b)
>     (?-xism:\bWI\b)
>     (?-xism:\bMN\b)

Those are used for the stringified print value of the `qr//` operator, or to build up a larger pattern if the result is interpolated into a larger string. But also associated with each is a cached, compiled version of that string as a pattern, and this is what Perl uses when the interpolation into a match or substitution operator contains nothing else.

### 6.10.4. See Also

The `qr//` operator in perlop(1) and in the section on "The qr// quote regex operator" in Chapter 5 of Programming Perl

Copyright © 2003 O'Reilly & Associates. All rights reserved.