Regular expressions may be applied to the $_ implicit variable, or explicitly to any variable with the =~ operator.  The statement 

$variable =~ someRE 

If the regular expression is a matching test, the result is reported as true if there is a match, and false otherwise. 

Matching 

Assume, 
$sentence = "The quick brown fox jumped."; 

The command, 

$sentence =~ /fox/

$sentence =~ m/fox/

$sentence !~ /fox/

The general form for substitutions is 

s/expr1/expr2/opt

$buffer =~ s/\ /+/;

$buffer =~ s/\ /+/g;

Translate 

The translate process 

tr/expr1/expr2/

For example, 

tr/abc/xyz/

$buffer ~= tr/[A-Z]/[a-z]/;

Translate can also be used to count the number of occurrences of a pattern, for example, 

$count = ($buffer ~= tr/[A-Z]/[a-z]/);

There are several special characters that play specific rolls in regular expressions.  The table to the right lists the special characters with their roles and a simple llustration of its use.  These special characters play important roles in specifiying particular locations in the string and groups of substrings. 

Along with the special characters there is also a set of backslash codes.  The backslask code serve several purposes: 

1. Provide access to the symbols when they are used as ordinary characters.
2. Provide access to the $1 $2, ..., variables.
3. Access to octal, hex, and control codes
4. Useful string processing indicators.

EXAMPLE:  Write a Perl progam to read a string and replace every ccurrence of a blank with a plus sign. 

This program begins with the problem of indicating a blank.  A blnk may be indicated by an actua blank space, or with a backslash code.  For the sake of readability, we use a backslash code.

#!usr/local/bin/perl
#
$buf=<STDIN>;
chomp $buf;
$buf ~= s/\ /+/g;
print "$buf\n";
exit;

#!usr/local/bin/perl
#
$_ = <STDIN>;
chomp;
s/\ /+/g;
print "$_ \n";
exit;

Let's begin by solving the first part, when a blank precedes an alphabetic character.  Finding a blank followed by an alphabetic character is relatively easy, "\ [a-z]".  The baskslash blank matches a blank and [a-z] finds any lower case a through z. 
 
Next, the RE feature must be told to replace the lower case symbol by its upper case equivalent.  This is accomplished by placing parentheses around [a-z], ([a-z]) to capture the symbol in a temporary variable, then that variable is used with the \U code to indicate the symbol is to be forced to upper case, as illustrated in the program,

#!usr/local/bin/perl 
# 
$_ = <STDIN>; 
chomp; 
s/\ ([a-z])/\ \U\1/g; 
print "$_ \n"; 
exit;

To handle the symbol at the beginning of the line, the beginning of line indicator, ^, is used.  Now the search is looking for the beginning of the line or a blank, "^|\ " followed by the "[a-z]".  Each of these is captured in a temporary variable for use with the substitution.  This leads to the program,

#!usr/local/bin/perl 
# 
$_ = <STDIN>; 
chomp; 
s/(^|\ )([a-z])/\1\U\2/g; 
print "$_ \n"; 
exit;