pdf viewer in asp net c# : Adding an image to a pdf file software SDK dll windows wpf azure web forms PowerGREP27-part3047

266 
6. The Dot Matches (Almost) Any Character 
In regular expressions, the dot or period is one of the most commonly used metacharacters. Unfortunately, it 
is also the most commonly misused metacharacter. 
The  dot  matches  a  single  character,  without  caring  what  that  character  is.  The  only  exception  are 
newlinecharacters. In all regex flavors discussed in this tutorial, the dot will not match a newline character by 
default. So by default, the dot is short for the negated character class «
[^\n]
» (UNIX regex flavors) or 
«
[^\r\n]
» (Windows regex flavors). 
This exception exists mostly because of historic reasons. The first tools that used regular expressions were 
line-based. They would read a file line by line, and apply the regular expression separately to each line. The 
effect is that with these tools, the string could never contain newlines, so the dot could never match them. 
Modern tools and languages can apply regular expressions to very large strings or even entire files. All regex 
flavors  discussed  here  have  an  option  to  make  the  dot  match  all  characters,  including  newlines.  In 
RegexBuddy, EditPad Pro or PowerGREP, you simply tick the checkbox labeled ´dot matches newlineµ. 
In Perl, the mode where the dot also matches newlines is called "single-line mode". This is a bit unfortunate, 
because it is easy to mix up this term with ´multi-line modeµ. Multi-line mode only affects anchors, and 
single-line mode only affects the dot. You can activate single-line mode by adding an s after the regex code, 
like this: 
m/^regex$/s;
Other  languages and regex libraries have adopted Perl’s terminology. When  using the regex  classes of 
the  .NET  framework,  you  activate this  mode  by  specifying 
RegexOptions.Singleline
 such  as  in 
Regex.Match("string", "regex", RegexOptions.Singleline)
In all programming languages and regex libraries I know, activating single-line mode has no effect other than 
making the dot match newlines. So if you expose this option to your users, please give it a clearer label like 
was done in RegexBuddy, EditPad Pro and PowerGREP. 
JavaScript and VBScript do not have an option to make the dot match line break characters. In those 
languages, you can use a character class such as «
[\s\S]
» to match any character. This character matches a 
character that is either a whitespace character (including line break characters), or a character that is not a 
whitespace  character. Since all  characters  are  either  whitespace  or  non-whitespace, this character  class 
matches any character. 
Use The Dot Sparingly 
The dot is a very powerful regex metacharacter. It allows you to be lazy. Put in a dot, and everything will 
match just fine when you test the regex on valid data. The problem is that the regex will also match in cases 
where it should not match. If you are new to regular expressions, some of these cases may not be so obvious 
at first. 
I will illustrate this with a simple example. Let’s say we want to match a date in mm/dd/yy format, but we 
want to leave the user the choice of date separators. The quick solution is «
\d\d.\d\d.\d\d
». Seems fine at 
first. It will match a date like „
02/12/03
µ just fine. Trouble is: „
02512703
µ is also considered a valid date by 
Adding an image to a pdf file - insert images into PDF in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Sample C# code to add image, picture, logo or digital photo into PDF document page using PDF page editor control
add jpg to pdf acrobat; add image to pdf reader
Adding an image to a pdf file - VB.NET PDF insert image library: insert images into PDF in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Guide VB.NET Programmers How to Add Images in PDF Document
add jpg to pdf preview; add image to pdf acrobat reader
267 
this regular expression. In this match, the first dot matched „
5
µ, and the second matched „
7
µ. Obviously not 
what we intended. 
«
\d\d[- /.]\d\d[- /.]\d\d
» is a better solution. This regex allows a dash, space, dot and forward slash 
as date separators. Remember that the dot is not a metacharacter inside a character class, so we do not need 
to escape it with a backslash. 
This regex is still far from perfect. It matches „
99/99/99
µ as a valid date. «
[0-1]\d[- /.][0-3]\d[- 
/.]\d\d
» is a step ahead, though it will still match „
19/39/99
µ. How perfect you want your regex to be 
depends on what you want to do with it. If you are validating user input, it has to be perfect. If you are 
parsing data files from a known source that generates its files in the same way every time, our last attempt is 
probably more than sufficient to parse the data without errors. You can find a better regex to match dates in 
the example section. 
Use Negated Character Sets Instead of the Dot 
I will explain this in depth when I present you the repeat operators star and plus, but the warning is important 
enough to mention it here as well. I will illustrate with an example. 
Suppose you want to match a double-quoted string. Sounds easy. We can have any number of any character 
between the double quotes, so «
".*"
» seems to do the trick just fine. The dot matches any character, and the 
star allows the dot to be repeated any number of times, including zero. If you test this regex on ´
Put a 
"string" between double quotes
µ, it will match „
"string"
µ just fine. Now go ahead and test it on 
´
Houston, we have a problem with "string one" and "string two". Please respond.
µ 
Ouch. The regex matches „
"string one" and "string two"
µ. Definitely not what we intended. The 
reason for this is that the star is greedy. 
In the date-matching example, we improved our regex by replacing the dot with a character class. Here, we 
will do the same. Our original definition of a double-quoted string was faulty. We do not want any number of 
any character between the quotes. We want any number of characters that are not double quotes or newlines 
between the quotes. So the proper regex is «
"[^"\r\n]*"
». 
VB.NET PDF Page Insert Library: insert pages into PDF file in vb.
If you want to read the tutorial of PDF page adding in C# class, we suggest you go to C# Imaging - how to insert a new empty page to PDF file.
how to add photo to pdf in preview; add image to pdf preview
VB.NET PDF Library SDK to view, edit, convert, process PDF file
Able to render and convert PDF document to/from supported document and image forms. Capable of adding PDF file navigation features to your VB.NET program.
add png to pdf acrobat; adding image to pdf file
268 
7. Start of String and End of String Anchors 
Thus far, I have explained literal characters and character classes. In both cases, putting one in a regex will 
cause the regex engine to try to match a single character. 
Anchors are a different breed. They do not match any character at all. Instead, they match a position before, 
after or between characters. They can be used to ´anchorµ the regex match at a certain position. The caret «
^
» 
matches the position before the first character in the string. Applying «
^a
» to ´
abc
µ matches „
a
µ. «
^b
» will 
not match ´
abc
µ at all, because the «
b
» cannot be matched right after the start of the string, matched by «
^
». 
See below for the inside view of the regex engine. 
Similarly, «
$
» matches right after the last character in the string. «
c$
» matches „
c
µ in ´
abc
µ, while «
a$
» does 
not match at all. 
Useful Applications 
When using regular expressions in a programming language to validate user input, using anchors is very 
important. If you use the code 
if ($input =~ m/\d+/)
in a Perl script to see if the user entered an integer 
number, it will accept the input even if the user entered ´
qsdf4ghjk
µ, because «
\d+
» matches the 4. The 
correct regex to use is «
^\d+$
». Because ´start of stringµ must be matched before the match of «
\d+
», and 
´end of stringµ must be matched right after it, the entire string must consist of digits for «
^\d+$
» to be able 
to match. 
It is easy for the user to accidentally type in a space. When Perl reads from a line from a text file, the line 
break will also be stored in the variable. So before validating input, it is good practice to trim leading and 
trailing whitespace. «
^\s+
» matches leading whitespace and «
\s+$
» matches trailing whitespace. In Perl, you 
could use 
$input =~ s/^\s+|\s+$//g
. Handy use of alternation and /g allows us to do this in a single 
line of code. 
Using ^ and $ as Start of Line and End of Line Anchors 
If you have a string consisting of multiple lines, like ´
first line\nsecond line
µ (where \n indicates a 
line break), it is often desirable to work with lines, rather than the entire string. Therefore, all the regex 
engines discussed in this tutorial have the option to expand the meaning of both anchors. «
^
» can then match 
at the start of the string (before the ´
f
µ in the above string), as well as after each line break (between ´
\n
µ 
and ´
s
µ). Likewise, «
$
» will still match at the end of the string (after the last ´
e
µ), and also before every line 
break (between ´
e
µ and ´
\n
µ). 
In text editors like EditPad Pro or GNU Emacs, and regex tools like PowerGREP, the caret and dollar 
always match at the start and end of each line. This makes sense because those applications are designed to 
work with entire files, rather than short strings. 
In all programming languages and libraries discussed in this book , except Ruby, you have to explicitly 
activate this extended functionality. It is traditionally called "multi-line mode". In Perl, you do this by adding 
an m after the regex code, like this: 
m/^regex$/m;
. In .NET, the anchors match before and after newlines 
when  you  specify 
RegexOptions.Multiline
 such  as  in 
Regex.Match("string",  "regex", 
RegexOptions.Multiline)
C# PDF Page Insert Library: insert pages into PDF file in C#.net
By using reliable APIs, C# programmers are capable of adding and inserting (empty) PDF page or pages from various file formats, such as PDF, Tiff, Word, Excel
adding image to pdf; add jpg to pdf file
VB.NET PDF File & Page Process Library SDK for vb.net, ASP.NET
on creating, loading, merge and splitting PDF pages and Files, adding a page blank pages or image-only pages from an image source PDF File Creation and Loading.
add image field to pdf form; how to add a jpg to a pdf
269 
Permanent Start of String and End of String Anchors 
«
\A
» only ever matches at the start of the string. Likewise, «
\Z
» only ever matches at the end of the string. 
These two tokens never match at line breaks. This is true in all regex flavors discussed in this tutorial, even 
when you turn on ´multiline modeµ. In EditPad Pro and PowerGREP, where the caret and dollar always 
match at the start and end of lines, «
\A
» and «
\Z
» only match at the start and the end of the entire file. 
JavaScript, POSIX and XML do not support «
\A
» and «
\Z
». You’re stuck with using the caret and dollar for 
this purpose. 
The GNU extensions to POSIX regular expressions use «
\`
» (backtick) to match the start of the string, and 
«
\'
» (single quote) to match the end of the string. 
Zero-Length Matches 
We saw that the anchors match at a position, rather than matching a character. This means that when a regex 
only consists of one or more anchors, it can result in a zero-length match. Depending on the situation, this 
can be very useful or undesirable. Using «
^\d*$
» to test if the user entered a number (notice the use of the 
star instead of the plus), would cause the script to accept an empty string as a valid input. See below. 
However, matching only a position can be very useful. In email, for example, it is common to prepend a 
´greater thanµ symbol and a space to each line of the quoted message. In VB.NET, we can easily do this with 
Dim Quoted as String = Regex.Replace(Original, "^", "> ", RegexOptions.Multiline)
We are using multi-line mode, so the regex «
^
» matches at the start of the quoted message, and after each 
newline. The Regex.Replace method will remove the regex match from the string, and insert the replacement 
string (greater than symbol and a space). Since the match does not include any characters, nothing is deleted. 
However, the match does include a starting position, and the replacement string is inserted there, just like we 
want it. 
Strings Ending with a Line Break 
Even though «
\Z
» and «
$
» only match at the end of the string (when the option for the caret and dollar to 
match at embedded line breaks is off), there is one exception. If the string ends with a line break, then «
\Z
» 
and «
$
» will match at the position before that line break, rather than at the very end of the string. This 
´enhancementµ was introduced by Perl, and is copied by many regex flavors, including Java, .NET and 
PCRE. In Perl, when reading a line from a file, the resulting string will end with a line break. Reading a line 
from a file with the text ´joeµ results in the string ´
joe\n
µ. When applied to this string, both «
^[a-z]+$
» 
and «
\A[a-z]+\Z
» will match „
joe
µ. 
If you only want a match at the absolute very end of the string, use «
\z
» (lower case z instead of upper case 
Z). «
\A[a-z]+\z
» does not match ´
joe\n
µ. «
\z
» matches after the line break, which is not matched by the 
character class. 
C# PDF File & Page Process Library SDK for C#.net, ASP.NET, MVC
Image: Copy, Paste, Cut Image in Page. Link: Edit URL. Bookmark an (empty) page to a PDF and adding empty pages random pages can be deleted from PDF file as well.
add signature image to pdf; add png to pdf preview
C# PDF insert text Library: insert text into PDF content in C#.net
C#.NET PDF SDK - Insert Text to PDF Document in C#.NET. Providing C# Demo Code for Adding and Inserting Text to PDF File Page with .NET PDF Library.
add an image to a pdf in preview; add jpg to pdf form
270 
Looking Inside the Regex Engine 
Let’s see what happens when we try to match «
^4$
» to ´
749\n486\n4
µ (where \n represents a newline 
character) in multi-line mode. As usual, the regex engine starts at the first character: ´
7
µ. The first token in 
the regular expression is «
^
». Since this token is a zero-width token, the engine does not try to match it with 
the character, but rather with the position before the character that the regex engine has reached so far. «
^
» 
indeed matches the position before ´
7
µ. The engine then advances to the next regex token: «
4
». Since the 
previous token was zero-width, the regex engine does not advance to the next character in the string. It 
remains at ´
7
µ. «
4
» is a literal character, which does not match ´
7
µ. There are no other permutations of the 
regex, so the engine starts again with the first regex token, at the next character: ´
4
µ. This time, «
^
» cannot 
match at the position before the 4. This position is preceded by a character, and that character is not a 
newline. The engine continues at ´
9
µ, and fails again. The next attempt, at ´
\n
µ, also fails. Again, the position 
before ´
\n
µ is preceded by a character, ´
9
µ, and that character is not a newline. 
Then, the regex engine arrives at the second ´
4
µ in the string. The «
^
» can match at the position before the 
´
4
µ, because it is preceded by a newline character. Again, the regex engine advances to the next regex token, 
«
4
», but does not advance the character position in the string. «
4
» matches „
4
µ, and the engine advances both 
the regex token and the string character. Now the engine attempts to match «
$
» at the position before 
(indeed: before) the ´
8
µ. The dollar cannot match here, because this position is followed by a character, and 
that character is not a newline. 
Yet again, the engine must try to match the first token again. Previously, it was successfully matched at the 
second ´
4
µ, so the engine continues at the next character, ´
8
µ, where the caret does not match. Same at the 
six and the newline. 
Finally, the regex engine tries to match the first token at the third ´
4
µ in the string. With success. After that, 
the engine successfully matches «
4
» with „
4
µ. The current regex token is advanced to «
$
», and the current 
character is advanced to the very last position in the string: the void after the string. No regex token that 
needs a character to match can match here. Not even a negated character class. However, we are trying to 
match a dollar sign, and the mighty dollar is a strange beast. It is zero-width, so it will try to match the 
position before the current character. It does not matter that this ´characterµ is the void after the string. In 
fact, the dollar will check the current character. It must be either a newline, or the void after the string, for «
$
» 
to match the position before the current character. Since that is the case after the example, the dollar matches 
successfully. 
Since «
$
» was the last token in the regex, the engine has found a successful match: the last „
4
µ in the string. 
Another Inside Look 
Earlier I mentioned that «
^\d*$
» would successfully match an empty string. Let’s see why. 
There is only one ´characterµ position in an empty string: the void after the string. The first token in the 
regex is «
^
». It matches the position before the void after the string, because it is preceded by the void before 
the string. The next token is «
\d*
». As we will see later, one of the star’s effects is that it makes the «
\d
», in 
this case, optional. The engine will try to match «
\d
» with the void after the string. That fails, but the star 
turns the failure of the «
\d
» into a zero-width success. The engine will proceed with the next regex token, 
without advancing the position in the string. So the engine arrives at «
$
», and the void after the string. We 
already saw that those match. At this point, the entire regex has matched the empty string, and the engine 
reports success. 
C# PDF Library SDK to view, edit, convert, process PDF file for C#
Able to render and convert PDF document to/from supported document and image forms in .NET WinFoms project. Support protecting PDF file by adding password and
how to add a picture to a pdf file; add a picture to a pdf document
VB.NET TIFF: Add New Image to TIFF File in Visual Basic .NET
unzipping the evaluation version, you need to find following dlls and add them to your VB.NET project references for adding image to your TIFF file using VB
add jpg to pdf; adding a jpg to a pdf
271 
Caution for Programmers 
A regular expression such as «
$
» all by itself can indeed match after the string. If you would query the engine 
for the character position, it would return the length of the string if string indices are zero-based, or the 
length+1 if string indices are one-based in your programming language. If you would query the engine for the 
length of the match, it would return zero. 
What you have to watch out for is that String[Regex.MatchPosition] may cause an  access violation or 
segmentation fault, because MatchPosition can point to the void after the string. This can also happen with 
«
^
» and «
^$
» if the last character in the string is a newline. 
C# PDF Password Library: add, remove, edit PDF file password in C#
Able to perform PDF file password adding, deleting and changing in Visual Studio .NET project use C# source code in .NET class. Allow
add picture pdf; how to add image to pdf form
272 
8. Word Boundaries 
The metacharacter «
\b
» is an anchor like the caret and the dollar sign. It matches at a position that is called a 
´word boundaryµ. This match is zero-length. 
There are three different positions that qualify as word boundaries: 
Before the first character in the string, if the first character is a word character.  
After the last character in the string, if the last character is a word character.  
Between two characters in the string, where one is a word character and the other is not a word 
character.  
Simply put: «
\b
» allows you to perform a ´whole words onlyµ search using a regular expression in the form 
of «
\bword\b
». A ´word characterµ is a character that can be used to form words. All characters that are not 
´word charactersµ are ´non-word charactersµ. 
In all flavors, the characters «
[a-zA-Z0-9_]
» are word characters. These are also matched by the short-hand 
character class «
\w
». Flavors showing ´asciiµ for word boundaries in the flavor comparison recognize only 
these as word characters. Flavors showing ´YESµ also recognize letters and digits from other languages or all 
of Unicode as word characters. Notice that Java supports Unicode for «
\b
» but not for «
\w
». Python offers 
flags to control which characters are word characters (affecting both «
\b
» and «
\w
»). 
In Perl and the other regex flavors discussed in this tutorial, there is only one metacharacter that matches 
both before a word and after a word. This is because any position between characters can never be both at 
the start and at the end of a word. Using only one operator makes things easier for you. 
Since digits are considered to be word characters, «
\b4\b
» can be used to match a 4 that is not part of a 
larger number. This regex will not match ´
44 sheets of a4
µ. So saying "«
\b
» matches before and after an 
alphanumeric sequence´ is more exact than saying µbefore and after a word". 
Negated Word Boundary 
«
\B
» is the negated version of «
\b
». «
\B
» matches at every position where «
\b
» does not. Effectively, «
\B
» 
matches at any position between two word characters as well as at any position between two non-word 
characters. 
Looking Inside the Regex Engine 
Let’s see what happens when we apply the regex «
\bis\b
» to the string ´
This island is beautiful
µ. 
The engine starts with the first token «
\b
» at the first character ´
T
µ. Since this token is zero-length, the 
position before the character is inspected. «
\b
» matches here, because the T is a word character and the 
character before it is the void before the start of the string. The engine continues with the next token: the 
literal «
i
». The engine does not advance to the next character in the string, because the previous regex token 
was zero-width. «
i
» does not match ´
T
µ, so the engine retries the first token at the next character position. 
273 
«
\b
» cannot match at the position between the ´
T
µ and the ´
h
µ. It cannot match between the ´
h
µ and the 
´
i
µ either, and neither between the ´
i
µ and the ´
s
µ. 
The next character in the string is a space. «
\b
» matches here because the space is not a word character, and 
the preceding character is. Again, the engine continues with the «
i
» which does not match with the space. 
Advancing a character and restarting with the first regex token, «
\b
» matches between the space and the 
second ´
i
µ in the string. Continuing, the regex engine finds that «
i
» matches „
i
µ and «
s
» matches „
s
µ. Now, 
the engine tries to match the second «
\b
» at the position before the ´
l
µ. This fails because this position is 
between two word characters. The engine reverts to the start of the regex and advances one character to the 
´
s
µ in ´
island
µ. Again, the «
\b
» fails to match and continues to do so until the second space is reached. It 
matches there, but matching the «
i
» fails. 
But «
\b
» matches at the position before the third ´
i
µ in the string. The engine continues, and finds that «
i
» 
matches „
i
µ and «
s
» matches „
s
µ. The last token in the regex, «
\b
», also matches at the position before the 
third space in the string because the space is not a word character, and the character before it is. 
The engine has successfully matched the word „
is
µ in our string, skipping the two earlier occurrences of the 
characters i and s. If we had used the regular expression «
is
», it would have matched the „
is
µ in ´
This
µ. 
Tcl Word Boundaries 
Word boundaries, as described above, are supported by most regular expression flavors. Notable exceptions 
are the POSIX and XML Schema flavors, which don’t support word boundaries at all. Tcl uses a different 
syntax. 
In Tcl, «
\b
» matches a backspace character, just like «
\x08
» in most regex flavors (including Tcl’s). «
\B
» 
matches a single backslash character in Tcl, just like «
\\
» in all other regex flavors (and Tcl too). 
Tcl uses the letter ´yµ instead of the letter ´bµ to match word boundaries. «
\y
» matches at any word 
boundary position, while «
\Y
» matches at any position that is not a word boundary. These Tcl regex tokens 
match exactly the same as «
\b
» and «
\B
» in Perl-style regex flavors. They don’t discriminate between the start 
and the end of a word. 
Tcl has two more word boundary tokens that do discriminate between the start and end of a word. «
\m
» 
matches only at the start of a word. That is, it matches at any position that has a non-word character to the 
left of it, and a word character to the right of it. It also matches at the start of the string if the first character 
in the string is a word character. «
\M
» matches only at the end of a word. It matches at any position that has a 
word character to the left of it, and a non-word character to the right of it. It also matches at the end of the 
string if the last character in the string is a word character. 
The only regex engine that supports Tcl-style word boundaries (besides Tcl itself) is the JGsoft engine. In 
PowerGREP and EditPad Pro, «
\b
» and «
\B
» are Perl-style word boundaries, and «
\y
», «
\Y
», «
\m
» and «
\M
» 
are Tcl-style word boundaries. 
In most situations, the lack of «
\m
» and «
\M
» tokens is not a problem. «
\yword\y
» finds ´whole words onlyµ 
occurrences of ´wordµ just like «
\mword\M
» would. «
\Mword\m
» could never match anywhere, since «
\M
» 
never matches at a position followed by a word character, and «
\m
» never at a position preceded by one. If 
your regular expression needs to match characters before or after «
\y
», you can easily specify in the regex 
274 
whether these characters should be word characters or non-word characters. E.g. if you want to match any 
word, «
\y\w+\y
» will give the same result as «
\m.+\M
». Using «
\w
» instead of the dot automatically restricts 
the first «
\y
» to the start of a word, and the second «
\y
» to the end of a word. Note that «
\y.+\y
» would not 
work. This regex matches each word, and also each sequence of non-word characters between the words in 
your subject string. That said, if your flavor supports «
\m
» and «
\M
», the regex engine could apply «
\m\w+\M
» 
slightly faster than «
\y\w+\y
», depending on its internal optimizations. 
If your regex flavor supports lookahead and lookbehind, you can use «
(?<!\w)(?=\w)
» to emulate Tcl’s 
«
\m
» and «
(?<=\w)(?!\w)
» to emulate «
\M
». Though quite a bit more verbose, these lookaround constructs 
match exactly the same as Tcl’s word boundaries. 
If your flavor has lookahead but not lookbehind, and also has Perl-style word boundaries, you can use 
«
\b(?=\w)
» to emulate Tcl’s «
\m
» and «
\b(?!\w)
» to emulate «
\M
». «
\b
» matches at the start or end of a 
word, and the lookahead checks if the next character is part of a word or not. If it is we’re at the start of a 
word. Otherwise, we’re at the end of a word. 
GNU Word Boundaries 
The GNU extensions to POSIX regular expressions add support for the «
\b
» and «
\B
» word boundaries, as 
described above. GNU also uses its own syntax for start-of-word and end-of-word boundaries. «
\<
» matches 
at the start of a word, like Tcl’s «
\m
». «
\>
» matches at the end of a word, like Tcl’s «
\M
». 
275 
9. Alternation with The Vertical Bar or Pipe Symbol 
I already explained how you can use character classes to match a single character out of several possible 
characters. Alternation is similar. You can use alternation to match a single regular expression out of several 
possible regular expressions. 
If you want to search for the literal text «
cat
» or «
dog
», separate both options with a vertical bar or pipe 
symbol: «
cat|dog
». If you want more options, simply expand the list: «
cat|dog|mouse|fish
» . 
The alternation operator has the lowest precedence of all regex operators. That is, it tells the regex engine to 
match either everything to the left of the vertical bar, or everything to the right of the vertical bar. If you want 
to limit the reach of the alternation, you will need to use round brackets for grouping. If we want to improve 
the first example to match whole words only, we would need to use «
\b(cat|dog)\b
». This tells the regex 
engine to find a word boundary, then either ´catµ or ´dogµ, and then another word boundary. If we had 
omitted the round brackets, the regex engine would have searched for ´a word boundary followed by catµ, or, 
´dogµ followed by a word boundary. 
Remember That The Regex Engine Is Eager 
I already explained that the regex engine is eager. It will stop searching as soon as it finds a valid match. The 
consequence is that in certain situations, the order of the alternatives matters. Suppose you want to use a 
regex to match a list of function names in a programming language: Get, GetValue, Set or SetValue. The 
obvious solution is «
Get|GetValue|Set|SetValue
». Let’s see how this works out when the string is 
´
SetValue
µ. 
The regex engine starts at the first token in the regex, «
G
», and at the first character in the string, ´
S
µ. The 
match fails. However, the regex engine studied the entire regular expression before starting. So it knows that 
this regular expression uses alternation, and that the entire regex has not failed yet. So it continues with the 
second option, being the second «
G
» in the regex. The match fails again. The next token is the first «
S
» in the 
regex. The match succeeds, and the engine continues with the next character in the string, as well as the next 
token in the regex. The next token in the regex is the «
e
» after the «
S
» that just successfully matched. «
e
» 
matches „
e
µ. The next token, «
t
» matches „
t
µ. 
At this point, the third option in the alternation has been successfully matched. Because the regex engine is 
eager, it considers the entire alternation to have been successfully matched as soon as one of the options has. 
In this example, there are no other tokens in the regex outside the alternation, so the entire regex has 
successfully matched „
Set
µ in ´
SetValue
µ. 
Contrary to what we intended, the regex did not match the entire string. There are several solutions. One 
option is to take into account that the regex engine is eager, and change the order of the options. If we use 
«
GetValue|Get|SetValue|Set
», «
SetValue
» will be attempted before «
Set
», and the engine will match 
the entire string. We could also combine the four options into two and use the question mark to make part of 
them optional: «
Get(Value)?|Set(Value)?
». Because the question mark is greedy, «
SetValue
» will be 
attempted before «
Set
». 
The best option is probably to express the fact that we only want to match complete words. We do not want 
to  match  Set  or  SetValue  if  the  string  is  ´
SetValueFunction
µ.  So  the  solution  is 
Documents you may be interested
Documents you may be interested