You don't need clutter just to use a variable. Remember that a do block returns the last evaluated expression. In this example, I assign that result to @memories, which puts the matches in list context so they return the parts they remembered as a list.

$_ = 'abcdefghijk';

foreach my $left ( 0 .. 1 )
    {
    my @memories = do {
        if( $left ) { /ab(..)ef/ }
        else        { /fg(..)jk/ }
        };
    
    print "Left $left: caught @memories\n"
    }
[download]

Once I have the memories in the array, I can easily pull out any element that I like. If the match fails, @memories is empty. I don't have to deal with a lot of gymnastics to figure out is the match succeeded. Without knowing that the match suceeded, you shouldn't use any of the number variables ($1, $2, and so on).

Remember that $1 and so on are package variables, and that they persist until the next successful pattern match. It doesn't have anything to do with lexical scope. Actually, perlvar says:

$<digits> Contains the subpattern from the corresponding set of capturing parentheses from the last pattern match, not counting patterns matched in nested blocks that have been exited already. (Mnemonic: like \digits.) These variables are all read-only and dynamically scoped to the current BLOCK.

Perhaps if/elsif/else could have a continue wherein one could snarf up the variable-values local to the if/elsif/else scope.

throop

None of those are particularly useful in practice since they don't check if the regexp matched successfully (and don't lend well to being modified to do so). When the regexp doesn't match, $1 and similar variables are left unchanged and therefore meaningless. What follows are more practical patterns.

Using ?::

my $re = $left ? qr/ab(..)ef/ : qr/gh(..)jk/;

/$re/ or die("Bad data");
print "Caught $1\n"
[download]

Using if/elsif:

my $re;
if    (...) { $re = qr/.../ }
elsif (...) { $re = qr/.../ }
elsif (...) { $re = qr/.../ }
else        { die '...' }

/$re/ or die("Bad data");
print "Caught $1\n"
[download]

Using a lookup table:

my %re_lookup = (
   ... => qr/.../,
   ... => qr/.../,
   ... => qr/.../,
);

/$re_lookup{...}/ or die("Bad data");
print "Caught $1\n"
[download]

Maybe I'm missing something, but it seems fairly easy to modify OP's code to check for a match:

($left ? /ab(..)ef/ : /gh(..)jk/) or die("Bad data");
[download]

This line is less readable in some ways than your suggested patterns, but it doesn't introduce any new variables.
Note: I got some results that looked funny until I replaced OP's (..) with (.*) in the regexen, watch out for that!
~dewey

I'm rather confused as to what "because the $1 backreference is lost once you exit the scope of the if/else" means to you, to me it sounds like you think $1 is cleared after you exit the scope it was declared in, which is clearly not true.

Am I missinterpreting your statements some how?

Yeah, I was missinterpreting. Consider this retracted.

Did you run the code the OP posted? Since at least 5.6.1, the $1 set by the regexp inside the if is no longer in scope outside the if. The following illustrates this clearly.

'a' =~ /(.)/;

{
   'b' =~ /(.)/;
   print("$1\n");  # b
}

print("$1\n");     # a
[download]

This is documented in perlvar.

You are quite correct and I was missinterpreting his comment. Consider it retracted.