Regular Expression II

More about Regular Expressions

This lecture notes is based on Prof Doreen De Leon's lectures.

Reading

Learning Perl, Chapter 8

Character Classes

A character class is a list of all possible characters inside square brackets ([]).
Matches any single character from within the class.
It matches just one character, but that character may be any one of the characters listed.
To have[ or ]as a character, use \[ or \].
Can specify a range of characters: use a hyphen (-).
To get a hyphen as a character in the list, use \-

File

XaX
XabcX
XdXaX

Program

while(<>) {
    # matches XaX, XbX, XcX
    if(/X[abc]X/) {
        print $_;
    }
}

Output

XaX
XdXaX

File

XaX
XadX
aXa1Xb
aXbX3Xc
XaXe9X

Program

while(<>) {
    # matches Xa1X, Xb3X, Xc0X etc
    if(/X[a-e][0-9]X/) {
        print $_;
    }
}

Output

aXa1Xb
XaXe9X

Program

while(<>) {
    # matches XaX,XbX,XcX,XdX,XxX,XyX,XzX
    if(/X[a-dx-z]X/) {
        print $_;
    }
}

Negated Character Class

Put a leading caret immediately after left bracket.
Means match any character except the one listed.

File

XaX
XbX
1XcX2

Program

while(<>) {
    # no a between X
    if(/X[^a]X/) {
        print $_;
    }
}

Output

XbX
1XcX2

Predefined Character Classes

\d: digits, 0 to 9, same as [0-9]
\w: "word" characters, a-z, A-Z, digits and underscore _, same as [A-Za-z0-9_]
\s: white space, return, etc
\D: [^\d]
\W: [^\w]
\S: [^\s]
Can use the above either in place of a character class or as part of a character class.

File

12
1a1a1
abcd
fg456

Program

while(<>) {
    # matches 2 digit
    if(/\d\d/) {
        print $_;
    }
}

Output

12
fg456

General Quantifiers

To match between m and n instances of an item, use the general multiplier (curly braces with 1-2 numbers, separated by commas, inside).

File

123456899
X222X
abcedeft
e111222333f
ID123111222
1
12
123
12345
123456
1234567
12345678

Program

while(<>) {
    # matches exactly 9 digits
    if(/\d{9}/) {
        print $_;
    } 
}

Output

123456899
e111222333f
ID123111222

Program

while(<>) {
    # matches more than 6 digits
    if(/\d{6,}/) {
        print $_;
    }   
}

Output

123456899
e111222333f
ID123111222
123456
1234567
12345678

Program

while(<>) {
    # matches more than 8 or 9 digits
    if(/\d{8,9}/) {
        print $_;
    }   
}

Output

123456899
e111222333f
ID123111222
12345678

Anchoring Patterns

Lets you ensure that parts of the pattern line up with certain parts of the string.
^ : beginning of the string
$ : end of the strong
\b : word boundary (begin and end of a \w character).
\B : non-word boundary

File

abc
abcd
abcdef
Xabc
XabcY

Program

while(<>) {
    # matches exactly abc
    if(/^abc$/) {
        print $_;
    } 
}

Output

abc

Program

while(<>) {
     # begins with abc
    if(/^abc/) {
        print $_;
    } 
}

Output

abc
abcd
abcdef

Program

while(<>) {
    # ends with abc
    if(/abc$/) {
        print $_;
    } 
}

Output

abc
Xabc

File

fred is a nice guy.
Alfred is a nice guy.
I saw fredrick yesterday.

Program

while(<>) {
    if(/\bfred\b/) {
        print $_;
    }   
}

Output

fred is a nice guy.

Parentheses

Enclosing part of a pattern in parentheses causes the part of the string matched by the pattern to be remembered so it can be referenced later.

Backreferences

A backreference refers back to a memory that was saved earlier in the current pattern�s processing.

/hot(.)dog\1/;
# Matches a string containing "hot" followed by any single 
# non-newline character (remembering that character in 
# memory 1), followed by "dog," followed by the same character
# as stored in memory 1.

The "1" indicates the first thing referenced. The next would be referenced by "2", etc. The referenced part can be more than a single character.

File

XabcX
BabcC
yabcy
(abc)
ZabcY
ZabcZ

Program

while(<>) {
    # XabcX, YabcY,2abc2 etc
    if(/^(.)abc(\1)$/) {
        print $_;
    }  
}

Output

XabcX
yabcy
ZabcZ

File

abzy
aabb
aaxx
bbzz
bbzy
ccab

Program

while(<>) {
    # aaxx, aayy, etc etc
    if(/^([abc])\1([xyz])\2$/) {
        print $_;
    }  
}

Output

aaxx
bbzz

Precedence in Regular Expressions

Parentheses
Quantifiers
Anchors and sequencing
Alternation