How to access captured groups using $1, $2 in Perl?

In Perl, when you perform a regular expression match that contains capturing parentheses (...), the matched substrings within those parentheses are stored in special variables $1, $2, $3, and so forth. These variables allow you to access the captured groups directly after a successful pattern match.

Understanding Captured Groups with $1, $2, etc.

Each set of parentheses in a regex creates a numbered capture group. The numbering is based on the order of the opening parentheses from left to right. For example:

• $1 contains the substring matched by the first capturing group.
• $2 contains the substring matched by the second capturing group.
• And so on...

Importantly, these variables are set only if the match is successful, and they persist until the next successful match operation. If the match fails, their values remain unchanged from the last successful match.

Key Points and Perl-Specific Details

• Sigils: The sigil $ denotes a scalar variable; $1 is a scalar holding one string.
• Context: Captures are always strings; no matter the context.
• TMTOWTDI: While $1, $2 are convenient, Perl also allows you to use my @captures = ($string =~ /(pattern)/g) to get captures in a list.
• Scope and Timing: The $1, $2 variables are dynamically scoped to the last successful regex match in the current lexical scope.

Common Pitfalls & Gotchas

• Accessing $1, $2 before a successful match — they will hold values from the previous successful match or be undefined.
• Using global match /g with capturing parentheses updates $1, $2 for each match iteration.
• Modifying regex or running another regex between accessing the capture variables overwrites them.
• Be careful if using eval, threads, or other constructs that may affect the values of these variables.

Runnable Example

use strict;
use warnings;

my $text = "Name: John Doe, Age: 32";

if ($text =~ /Name:\s+(\w+)\s+(\w+),\s+Age:\s+(\d+)/) {
    print "Full match succeeded.\n";
    print "First name: $1\n";   # Captured first word after "Name:"
    print "Last name: $2\n";    # Captured second word
    print "Age: $3\n";          # Captured digits after "Age:"
} else {
    print "No match!\n";
}

# Demonstrating that the capture variables persist until next match:
if ("No match here" =~ /nomatch/) {
    # no capturing groups, so these won't change
} 
print "After failed match, first name still: $1\n";

# Showing that new match updates captures:
if ("Alice Smith 27" =~ /(\w+)\s+(\w+)\s+(\d+)/) {
    print "New match captures:\n";
    print "First name: $1\n";
    print "Last name: $2\n";
    print "Age: $3\n";
}

This example matches a simple string with three capture groups: first name, last name, and age. After the match, you can directly access the captures using $1, $2, and $3. The second part shows that these capture variables keep their values until overwritten by another successful pattern match.

Summary

In Perl, captured groups from regexes are accessed via the special global scalar variables $1, $2, … after a successful match. They are very convenient but require care to ensure you only use them immediately after a match and before running other regex operations that could overwrite them. This behavior is part of Perl’s flexible design and its philosophy of “There’s more than one way to do it” (TMTOWTDI).