How do I check if a scalar has a compiled regex in it with Perl?

Question

Let's say I have a subroutine/method that a user can call to test some data that (as an example) might look like this:

sub test_output {
    my ($self, $test) = @_;
    my $output = $self->long_process_to_get_data();
    if ($output =~ /\Q$test/) {
        $self->assert_something();
    }
    else {
        $self->do_something_else();
    }
}

Normally, $test is a string, which we're looking for anywhere in the output. This was an interface put together to make calling it very easy. However, we've found that sometimes, a straight string is problematic - for example, a large, possibly varying number of spaces...a pattern, if you will. Thus, I'd like to let them pass in a regex as an option. I could just do:

$output =~ $test

if I could assume that it's always a regex, but ah, but the backwards compatibility! If they pass in a string, it still needs to test it like a raw string.

So in that case, I'll need to test to see if $test is a regex. Is there any good facility for detecting whether or not a scalar has a compiled regex in it?

Answer 1

As hobbs points out, if you're sure that you'll be on 5.10 or later, you can use the built-in check:

 use 5.010;
 use re qw(is_regexp);
 if (is_regexp($pattern)) {
     say "It's a regex";
 } else {
     say "Not a regex";
 }

However, I don't always have that option. In general, I do this by checking against a prototype value with ref:

 if( ref $scalar eq ref qr// ) { ... }

One of the reasons I started doing it this way was that I could never remember the type name for a regex reference. I can't even remember it now. It's not uppercase like the rest of them, either, because it's really one of the packages implemented in the perl source code (in regcomp.c if you care to see it).

If you have to do that a lot, you can make that prototype value a constant using your favorite constant creator:

 use constant REGEX_TYPE => ref qr//;

I talk about this at length in Effective Perl Programming as "Item 59: Compare values to prototypes".

If you want to try it both ways, you can use a version check on perl:

 if( $] < 5.010 ) { warn "upgrade now!\n"; ... do it my way ... }
 else             { ... use is_regex ... }

Answer 2

See the ref built-in.

Answer 3

As of perl 5.10.0 there's a direct, non-tricky way to do this:

use 5.010;
use re qw(is_regexp);
if (is_regexp($pattern)) {
    say "It's a regex";
} else {
    say "Not a regex";
}

is_regexp uses the same internal test that perl uses, which means that unlike ref, it won't be fooled if, for some strange reason, you decide to bless a regex object into a class other than Regexp (yes, that's possible).

In the future (or right now, if you can ship code with a 5.10.0 requirement) this should be considered the standard answer to the problem. Not only because it avoids a tricky edge-case, but also because it has the advantage of saying exactly what it means. Expressive code is a good thing.