Pattern Matching

Matching variables

• $1, $2, ...
• Used outside of a regex
• When grouping metacharacters () are used, the parts of a string that matched are saved in matching variables

# Replace abcdef with cd                                                                                                                                                                 
s/ab(cd)ef/$1/

Backreferences

• \1, \2, ...
• Use inside a regex
• Backreferences are essentially matching variables that can be used inside a regex

# Replace abcabc with xyz
s/(abc)\1/xyz/

# Find all 3-letter words that are repeated twice with a space in-between ("the the")
/(\w\w\w)\s\1/

Matching operator

• Find a matching string
  
• //
• m//
  
• /reg-expr/

• Operates on $_ by default
• Can be bound to another variable using =~
• Returns a true value if the pattern matched; otherwise, it returns false

• Can use other delimiters when the "m" prefix is used, such as m||,  m!! and m{}
• If single quotes are used, m'', then the regex is treated as a single-quoted string (no substitutions are made)
• In scalar context, a match /regex/ will return the value "1" upon a successful match, otherwise it will return the value ""

• In list context, a match /regex/ with no groupings () will return a list containing each successful match
• A match /regex/ with groupings () will implicitly assign each grouping of matched values to a list of the form ($1, $2, ...).  In list context, the groupings will also be explicitly assigned to the stated list

@-, @+

• $-[0]  : position of the start of the entire match
• $+[0]  : position of the end

• $-[n]  : position of the start of the $n match
• $+[n]  : position of the end
• If $n is undefined, so are $-[n] and $+[n]

$str =~ /orange/                   # Search for "orange" in $str

$str = 'red';
m'$str';                           # Matches '$str', not 'red'

# extract hours, minutes, seconds
($hours, $minutes, $second) = ($time =~ /(\d\d):(\d\d):(\d\d)/);

# extract hours, minutes, seconds
$time =~ /(\d\d):(\d\d):(\d\d)/;   # Match hh:mm:ss format
$hours = $1;
$minutes = $2;
$seconds = $3;

# extract minutes
($minutes) = ($time =~ /\d\d:(\d\d):\d\d/);

'cathouse' =~ /cat$foo/;    # matches
'housecat' =~ /${foo}cat/;  # matches

Substitution operator

• Search and replace
  
• s///
• s|||
• s/reg-expr/replacement-string/modifiers

• If there is a match, s/// returns the number of substitutions made, otherwise it returns false
• Can use other delimiters, such as s!!! and s{}{}, and even s{}//. If single quotes are used, s''', then the regex and replacement are treated as single quoted strings

s/apples/oranges/      # Replace the first occurrence of "apples" with "oranges"
s/cats/dogs/g          # Replace all occurrences of "cats" with "dogs"

$y = "'quoted words'";
$y =~ s/^'(.*)'$/$1/;  # strip single quotes; $y contains "quoted words"

# reverse all the words in a string
$x = "the cat in the hat";
$x =~ s/(\w+)/reverse $1/ge;  # $x contains "eht tac ni eht tah"

# convert percentage to decimal
$x = "A 39% hit rate";
$x =~ s!(\d+)%!$1/100!e;      # $x contains "A 0.39 hit rate"

Command line

• perl operates in a line-by-line manner (like sed) when run in this way

perl -pi -e "s|apple|orange|gis;" "$file"           # apple ==> orange
perl -pi -e "s|([^q])q([^q])|\$1 \$2|gs;" "$file"   # Remove isolated q's (aqb ==> a b)

# Backreferences (substitution variables)
perl -pi -e "s|a(p)\1le|orange|gs;" "$file"

# Matching variables
perl -pi -e "s|a(p)ple|\1|gs;" "$file"
perl -pi -e "s|a(p)ple|\$1|gs;" "$file"

Split operator

• split //, STRING
• split /reg-expr/, STRING

• The regex determines the character sequence that the string is split with respect to
• If the empty regex, //, is used, the string is split into individual characters
• If the regex has groupings, then the list produced contains the matched substrings from the groupings as well

@arr = split /\s+/, "zero one two"; # Whitespace: "zero", "one", "two" 
@arr = split /,\s*/, "aa,bb, cc";   # Comma-delimited: "aa", "bb", "cc"
@arr = split //, "xyz";             # Individual characters: "a", "b", "c"
@arr = split /(:)/ "10:20";         # Groupings: "10", ":", "20"

Modifiers

Default behavior

• . matches any character except \n
• ^ matches only at the beginning of the string
• $ matches only at the end or before a newline at the end

/s

• Treats the string as a single long line
• . matches any character, including \n
• ^ matches only at the beginning of the string
• $ matches only at the end or before a newline at the end

/m

• Treats the string as a set of multiple lines
• . matches any character except \n
• ^ and $ are can match at the start or end of any line within the string

/sm

• Treats the string as a single long line, but detects multiple lines
• . matches any character, including \n
• ^ and $ can match at the start or end of any line within the string

/g

• Global (applies to all occurrences of the search pattern)

/i

• Case insensitive

/o

• Performs variable substitutions in the regex only once (useful in loops)

/x

• Allows extended regular expressions (improves the readability by allowing whitespace and comments to be used)
  

Modifiers specific to matching

/c

• The search position on a failed match is not reset when /g is in effect

Modifiers specific to substitution

/e

• Evaluates the right side as an expression