Regular Expressions -- String Matching

A regular expression is contained in slashes, and matching occurs with the =~ operator. The following expression is true if the string the appears in variable $sentence.

$sentence =~ /the/

$sentence = "The quick brown fox";

The operator !~ is used for spotting a non-match. In the above example

$sentence !~ /the/

it is often useful to assign the string to be matched to the special variable $_:

$sentence = "The quick brown fox";
if (/The/)
{
	print "Found match\n";
}

Special Characters in Perl REs

.	# Any single character except a newline
^	# The beginning of the line or string
$	# The end of the line or string
*	# Zero or more of the last character
+	# One or more of the last character
?	# Zero or one of the last character

Square brackets are used to match any one of the characters inside them. Inside square brackets a - indicates "between" and a ^ at the beginning means "not":

[qjk] 	  # Either q or j or k
[^qjk] 	  # Neither q nor j nor k
[a-z] 	  # Anything from a to z inclusive
[^a-z]	  # No lower case letters
[a-zA-Z]  # Any letter
[a-z]+ 	  # Any non-zero sequence of lower case letters

A vertical bar | represents an "or" and parentheses (...) can be used to group things together:

jelly|cream	# Either jelly or cream
(eg|le)gs	# Either eggs or legs
(da)+    	# Either da or dada or dadada or...

More special characters:

\n 	# A newline
\t 	# A tab
\w 	# Any alphanumeric (word) character.
 	# The same as [a-zA-Z0-9_]
\W 	# Any non-word character.
 	# The same as [^a-zA-Z0-9_]
\d 	# Any digit. The same as [0-9]
\D 	# Any non-digit. The same as [^0-9]
\s 	# Any whitespace character: space,
 	# tab, newline, etc
\S 	# Any non-whitespace character
\b 	# A word boundary, outside [] only
\B 	# No word boundary

Clearly characters like $, |, [, ), \, / and so on are peculiar cases in regular expressions. If you want to match for one of those then you have to preceed it by a backslash. So:

\| 	# Vertical bar
\[ 	# An open square bracket
\) 	# A closing parenthesis
\* 	# An asterisk
\^ 	# A carat symbol
\/ 	# A slash
\\ 	# A backslash

Examples for REs

Extracting matches

Example "grep from stdin (can be a file using: while( <> ) { if( /(fred|Fred|john|john)/ ) { print "Found match: $1\n in line: $_\n"; } }

The global modifier "//g" allows the matching operator to match within a string as many times as possible. Perl keeps track of position in the string as it goes along. You can get or set the position with the "pos()" function:

Backreferences

Matching Principles for Multiple Matching Alternatives

0. Taken as a whole, any regexp will be matched at the earliest possible position in the string.
1. In an alternation "a|b|c...", the leftmost alternative that allows a match for the whole regexp will be the one used.
2. The maximal matching quantifiers "?", "*", "+" and "{n,m}" will in general match as much of the string as possible while still allowing the whole regexp to match.
3. If there are two or more elements in a regexp, the leftmost greedy quantifier, if any, will match as much of the string as possible while still allowing the whole regexp to match. The next leftmost greedy quantifier, if any, will try to match as much of the string remaining available to it as possible, while still allowing the whole regexp to match. And so on, until all the regexp elements are satisfied.

Greedy or Non-Greeedy

Sometimes greed is not good, because we would like quantifiers to match a minimal piece of string, rather than a maximal piece.

For this purpose we can use the minimal match or non-greedy quantifiers "??","*?", "+?", and "{}?". These are the usual quanti­ fiers with a "?" appended to them, Examples:

"a??" = match 'a' 0 or 1 times.
         Try 0 first, then 1.

"a*?" = match 'a' 0 or more times, 
        i.e., any number of times, 
        but as few times as possible

"a+?" = match 'a' 1 or more times, 
        i.e., at least once, 
        but as few times as possible

"a{n,m}?" = match at least "n" times, 
            not more than "m" times,
            as few times as possible

"a{n,}?" = match at least "n" times, 
           but as few times as possible

Search and Replace Functions

[ =~ ] [ m ] // [ g ] [ i ] [ m ] [ o ] [ s ] [ x ]

Searches EXPR (default: $_) for a pattern. If you prepend an m you can use almost any pair of delimiters instead of the slashes. If used in array context, an array is returned consisting of the subexpressions matched by the parentheses in the pattern, i.e., ($1,$2,$3,...).
Optional modifiers: g matches as many times as possible; i searches in a case-insensitive manner; o interpolates variables only once. m treats the string as multiple lines; s treats the string as a single line; x allows for regular expression extensions.
If PATTERN is empty, the most recent pattern from a previous match or replacement is used.
With g the match can be used as an iterator in scalar context.

?PATTERN?

This is just like the /PATTERN/ search, except that it matches only once between calls to the reset operator.

[ $VAR =~ ] s/PATTERN/REPLACEMENT/ [ e ] [ g ] [ i ] [ m ] [ o ] [ s ] [ x ]

Searches a string for a pattern, and if found, replaces that pattern with the replacement text. It returns the number of substitutions made, if any; if no substitutions are made, it returns false.
Optional modifiers: g replaces all occurrences of the pattern; e evaluates the replacement string as a Perl expression; for any other modifiers, see /PATTERN/ matching. Almost any delimiter may replace the slashes; if single quotes are used, no interpretation is done on the strings between the delimiters, otherwise the strings are interpolated as if inside double quotes.
If bracketing delimiters are used, PATTERN and REPLACEMENT may have their own delimiters, e.g., s(foo)[bar]. If PATTERN is empty, the most recent pattern from a previous match or replacement is used.

[ $VAR =~ ] tr/SEARCHLIST/REPLACEMENTLIST/ [ c ] [ d ] [ s ]

Translates all occurrences of the characters found in the search list with the corresponding character in the replacement list. It returns the number of characters replaced. y may be used instead of tr.
Optional modifiers: c complements the SEARCHLIST; d deletes all characters found in SEARCHLIST that do not have a corresponding character in REPLACEMENTLIST; s squeezes all sequences of characters that are translated into the same target character into one occurrence of this character.

pos SCALAR

Returns the position where the last m//g search left off for SCALAR. May be assigned to.

study [ $VAR† ]

Study the scalar variable $VAR in anticipation of performing many pattern matches on its contents before the variable is next modified.

Examples for Search and Replace Operations Using RE

Examples for the split Operator Using RE