Regular expressions (regex) are text strings that describe search patterns to match or find other strings or sets of strings. They are useful for tasks like syntax highlighting, find and replace, text searching, and programming. The document discusses various regex constructs like single/multiple characters, word groups, quantifiers, grouping, greedy/lazy matching, lookahead/behind, and provides examples of using regex in C# and Linux tools. It notes pros of regex like flexibility and expressing complex patterns concisely, but also cons like difficulty of reading and debugging complex patterns.

1. Regular Expressions
21 Januari 2014
Sido Grond
Exception Twente
1

2. Index
•
•
•
•
•
•
•
Introduction
Applications
Constructs
Regular expressions in C#
Demos
Pros and cons
Conclusions
2

3. Introduction
• Regular Expression (RE or regex) is a text
string that describes a search pattern
• Some similarity to wildcards (e.g. *.txt)
• Platform/language independent but some
minor differences among them
• Available in a.o. C#, Perl, Python, Java,
Javascript, Visual Studio, Notepad++, Linux
command line tools
3

4. Applications
• Syntax highlighting
• Find and replace
– Visual Studio (as usual: different syntax)
– Notepad++
• Text searching
– Unix tools: grep, sed, find
• Programming
– Pattern matching, filtering, replacing
4

5. Constructs: single character
Regex
Strings that match
Strings that don’t match
a
“abc”, “bad”
“xyz”
^a
“abc”
“bad”, “xyz”, “^a”
a$
“cba”
“abc”, “bad”, “xyz”
^[a-z]$
“a”, “x”
“aa”, “A”
^[a-z0-9+-]$
“s”, “3”, “+”, “-”
“12”, “Q”, “a1”
^[^a-zA-Z]$
“5”, “+”
“p”, “R”, “abc”, “15”
^[a-zA-Z]
“b”, “C123”, “dd”
“1cba”, “ f”(note space)
[^a-zA-Z]
“1cba”, “ f”
“b”, “dd”
^.$
“m”, “3”, “%”
“13”, “%a”, “xyz”
.
“%”, “e4”, “xyz”, “.”
“”
.
“.”
“%”, “e4”, “xyz”
5

6. Constructs: word groups
•
•
•
•
•
•
d is shorthand for Digits [0-9]
w is shorthand for Words [a-zA-Z0-9]
s is shorthand for whiteSpace [ trn]
D is shorthand for non-Digits [^0-9]
W is shorthand for non-Words [^a-zA-Z0-9]
S is shorthand for non-whiteSpace [^ trn]
6

7. Constructs: multiple character
Regex
Strings that match
Strings that don’t match
abc
“abcde”, “rabco”
“bac”, “ABC”, “bcde”
^abc
“abc”, “abcde”
“rabco”, “ABC”, “bcde”
Ed
“ME3”, “E85”, “EBE5” “ACME”, “E”, “E 8”
Ed+$
“ME35”, “EBE5”
“E85x”, “E3EB”, “E 8”
foo|bar
“foot”, “bart”
“ooba”
a(b|c)d
“Tabd”, “acdc”
“abcd”, “aed”, “ad”
^foo|bar
“foo1”, “Harbar”
“toofoo”
^(foo|bar)
“foo1”, “bart”
“toofoo”, “Harbar”
7

8. Constructs: quantifiers
Regex
Strings that match
Strings that don’t match
^a?$
“”, “a”
“aa”, “aaaaa”
^a*$
“a”, “aaaaa”, “”
“aaab”, “c”, “ba”
^a+$
“a”, “aaaaa”
“aaab”, “c”, “ba”, “”
^a{4}$
“aaaa”
“a”, “aaaaa”, “”
^a{2,6}$
“aa”, “aaa”, “aaaaaa”
“a”, “”, “aaaaaaa”
(e|o){2}
“koe”, “booom”, “veel” “kol”, “omo”, “vele”
e|(o{2})
“nest”, “booom”, “koe” “kol”
(a[0-9]*){2}
“aa”, “ba45a”, “a3a0”
“abacus”, “a3b8a0”
8

9. Constructs: advanced
Regex
String
First match
Greedy
<.+>
“This is a <B>first</B> test”
“<B>first</B>”
Lazy
<.+?>
“This is a <B>first</B> test”
“<B>”
Greedy/lazy repetition
Regex
Strings that match
Groups
^(a|b)c(d)$
“acd”, “bcd”
0:”acd” 1:”a” 2:”d”
^(?:a|b)c(d)$
same as above
0:”acd” 1:”d”
^(?<name>a|b)c(d)$
same as above
0:”acd” 1:”d” name:”a”
Grouping
9

10. Constructs: advanced
Regex
Strings that match
Strings that don’t match
^([a-c])x1x1
“axaxa”, “bxbxbyyyy”
“axaxb”, “bxaxc”
<(b)><(i)>.*?</2></1>
“<b><i>bla</i></b>”
“<b><i>bla</b></i>”
Backreferences: inside regex
Regex
Strings that match Replace pattern Result strings
^(var)(1|2)$
“var1”, “var2”
1iable
“variable”
^(a|b)c(d|e)
“acd”, “bcd”
2XXX1
“dXXXa”, “dXXXb”
Backreferences: find and replace
10

11. Constructs: advanced
Regex
Strings that match
Strings that don’t match
([a-b](?=x))
“blaax”, “bxa”
“ab”, “bacx”
((?<=x)[a-b])
“yyxa”, “bxb”
“ab”, “aax”
([a-b](?!x))
“bla”, “a”, “bxa”
“bxc”, “ax”
((?<!x)[a-b])
“ral”, “dbx”, “bxa”
“xa”, “lxb”
Look ahead/behind
11

12. Regexes in C#
• using System.Text.RegularExpressions
• Regex reg = new Regex(“a(b|c)d”);
–
–
–
–
–
reg.IsMatch(“abd”);
reg.Matches(“abdEacd”);
reg.Groups(“abdEabdC”);
reg.Split(“abdEabdC”);
reg.Replace(“abdEabdC”, “X”);
true
2 Matches
2 Groups per match
2 Strings (“E” and “C”)
“XEXC”
• Single/Multiline options: is linebreak(n)
special character
12

13. Regexes in C#
• Demo
13

14. Regexes in editors
• Notepad++
14

15. Regexes in Linux
• grep, sed, find, vi
15

16. Pros and cons
• Advantages
–
–
–
–
–
Very flexible
Fast processing
Language independent
A lot of work in a single line of code
Often simpler than ‘substring+indexes’ approach
• Disadvantages
– Hard to read, for example ‘?’ has three meanings depending on
context
– Hard to debug: no info given when no match
– Compilation only at runtime
– Typos are very easily made (e.g. forget escape character)
16

17. Conclusions
“Some people, when confronted with a
problem, think ‘I know, I'll use regular
expressions.’ Now they have two problems.”
Jamie Zawinski
Don’t overuse it!
17

18. Conclusions
•
•
•
•
Very handy tool for string matching and replacing
Built-in support in most programming languages
Support in/for multiple applications
More info
– http://www.regular-expressions.info/
– http://msdn.microsoft.com/en-us/library/az24scfc
%28v=vs.110%29.aspx
• Fun
– http://regex.alf.nu/
– http://www.i-programmer.info/news/144-graphics-and-games/5450can-you-do-the-regular-expression-crossword.html
18