pdf viewer in asp net c# : How to add image to pdf in acrobat SDK software API wpf winforms asp.net sharepoint PowerGREP28-part3048

276 
«
\b(Get|GetValue|Set|SetValue)\b
»  or  «
\b(Get(Value)?|Set(Value)?)\b
».  Since  all  options 
have the same end, we can optimize this further to «
\b(Get|Set)(Value)?\b
» . 
All regex flavors discussed in this book work this way, except one: the POSIX standard mandates that the 
longest match be returned, regardless if the regex engine is implemented using an NFA or DFA algorithm. 
How to add image to pdf in acrobat - 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
adding images to pdf files; add image to pdf in preview
How to add image to pdf in acrobat - 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 signature image to pdf acrobat; acrobat insert image into pdf
277 
10. Optional Items 
The question mark makes the preceding token in the regular expression optional. E.g.: «
colou?r
» matches 
both „
colour
µ and „
color
µ. 
You can make several tokens optional by grouping them together using round brackets, and placing the 
question mark after the closing bracket. E.g.: «
Nov(ember)?
» will match „
Nov
µ and „
November
µ. 
You can write a regular expression that matches many alternatives by including more than one question mark. 
«
Feb(ruary)? 23(rd)?
» matches „
February 23rd
µ, „
February 23
µ, „
Feb 23rd
µ and „
Feb 23
µ. 
Important Regex Concept: Greediness 
With the question mark, I have introduced the first metacharacter that is greedy. The question mark gives the 
regex engine two choices: try to match the part the question mark applies to, or do not try to match it. The 
engine will always try to match that part. Only if this causes the entire regular expression to fail, will the 
engine try ignoring the part the question mark applies to. 
The effect is that if you apply the regex «
Feb 23(rd)?
» to the string ´
Today is Feb 23rd, 2003
µ, the 
match will always be „
Feb 23rd
µ and not „
Feb 23
µ. You can make the question mark lazy (i.e. turn off the 
greediness) by putting a second question mark after the first. 
I will say a lot more about greediness when discussing the other repetition operators. 
Looking Inside The Regex Engine 
Let’s apply the regular expression «
colou?r
» to the string ´
The colonel likes the color green
µ. 
The first token in the regex is the literal «
c
». The first position where it matches successfully is the „
c
µ in 
´
colonel
µ. The engine continues, and finds that «
o
» matches „
o
µ, «
l
» matches „
l
µ and another «
o
» matches 
o
µ. Then the engine checks whether «
u
» matches ´
n
µ. This fails. However, the question mark tells the regex 
engine that failing to match «
u
» is acceptable. Therefore, the engine will skip ahead to the next regex token: 
«
r
». But this fails to match ´
n
µ as well. Now, the engine can only conclude that the entire regular expression 
cannot be matched starting at the „
c
µ in ´
colonel
µ. Therefore, the engine starts again trying to match «
c
» to 
the first o in ´
colonel
µ. 
After a series of failures, «
c
» will match with the „
c
µ in ´
color
µ, and «
o
», «
l
» and «
o
» match the following 
characters. Now the engine checks whether «
u
» matches ´
r
µ. This fails. Again: no problem. The question 
mark allows the engine to continue with «
r
». This matches „
r
µ and the engine reports that the regex 
successfully matched „
color
µ in our string. 
.NET PDF Document Viewing, Annotation, Conversion & Processing
Convert image files to PDF. File & Page Process. Annotate & Comment. Add, insert PDF native annotations to PDF file. Support for all the print modes in Acrobat PDF
add image in pdf using java; adding images to pdf forms
C# PDF Converter Library SDK to convert PDF to other file formats
without using other external third-party dependencies like Adobe Acrobat. you can easily perform file conversion from PDF document to image or document
how to add a jpeg to a pdf; add picture to pdf document
278 
11. Repetition with Star and Plus 
I already introduced one repetition operator or quantifier: the question mark. It tells the engine to attempt to 
match the preceding token zero times or once, in effect making it optional. 
The asterisk or star tells the engine to attempt to match the preceding token zero or more times. The plus 
tells the engine to attempt to match the preceding token once or more. «
<[A-Za-z][A-Za-z0-9]*>
» 
matches an HTML tag without any attributes. The sharp brackets are literals. The first character class matches 
a letter. The second character class matches a letter or digit. The star repeats the second character class. 
Because we used the star, it’s OK if the second character class matches nothing. So our regex will match a tag 
like „
<B>
µ. When matching „
<HTML>
µ, the first character class will match „
H
µ. The star will cause the second 
character class to be repeated three times, matching „
T
µ, „
M
µ and „
L
µ with each step. 
I could also have used «
<[A-Za-z0-9]+>
». I did not, because this regex would match „
<1>
µ, which is not a 
valid HTML tag. But this regex may be sufficient if you know the string you are searching through does not 
contain any such invalid tags. 
Limiting Repetition 
Modern regex flavors, like those discussed in this tutorial, have an additional repetition operator that allows 
you to specify how many times a token can be repeated. The syntax is 
{
min
,
max
}
, where min is a positive 
integer number indicating the minimum number of matches, and max is an integer equal to or greater than 
min indicating the maximum number of matches. If the comma is present but max is omitted, the maximum 
number of matches is infinite. So «
{0,}
» is the same as «
*
», and «
{1,}
» is the same as «
+
». Omitting both the 
comma and max tells the engine to repeat the token exactly min times. 
You  could  use  «
\b[1-9][0-9]{3}\b
»  to  match  a  number  between  1000  and  9999.  «
\b[1-9][0-
9]{2,4}\b
» matches a number between 100 and 99999. Notice the use of the word boundaries. 
Watch Out for The Greediness! 
Suppose you want to use a regex to match an HTML tag. You know that the input will be a valid HTML file, 
so the regular expression does not need to exclude any invalid use of sharp brackets. If it sits between sharp 
brackets, it is an HTML tag. 
Most people new to regular expressions will attempt to use «
<.+>
». They will be surprised when they test it 
on a string like ´
This is a <EM>first</EM> test
µ. You might expect the regex to match „
<EM>
µ and 
when continuing after that match, „
</EM>
µ. 
But it does not. The regex will match „
<EM>first</EM>
µ. Obviously not what we wanted. The reason is 
that the plus is greedy. That is, the plus causes the regex engine to repeat the preceding token as often as 
possible. Only if that causes the entire regex to fail, will the regex engine backtrack. That is, it will go back to 
the plus, make it give up the last iteration, and proceed with the remainder of the regex. Let’s take a look 
inside the regex engine to see in detail how this works and why this causes our regex to fail. After that, I will 
present you with two possible solutions. 
Like the plus, the star and the repetition using curly braces are greedy. 
C# Windows Viewer - Image and Document Conversion & Rendering in
without using other external third-party dependencies like Adobe Acrobat. Image and Document Conversion Supported by Windows Viewer. Convert to PDF.
add jpeg to pdf; how to add an image to a pdf in preview
C# powerpoint - PowerPoint Conversion & Rendering in C#.NET
using other external third-party dependencies like Adobe Acrobat. SDK to convert PowerPoint document to PDF document code for PowerPoint to TIFF image conversion
how to add image to pdf in preview; add photo to pdf reader
279 
Looking Inside The Regex Engine 
The first token in the regex is «
<
». This is a literal. As we already know, the first place where it will match is 
the first „
<
µ in the string. The next token is the dot, which matches any character except newlines. The dot is 
repeated by the plus. The plus is greedy. Therefore, the engine will repeat the dot as many times as it can. The 
dot matches „
E
µ, so the regex continues to try to match the dot with the next character. „
M
µ is matched, and 
the dot is repeated once more. The next character is the ´
>
µ. You should see the problem by now. The dot 
matches the „
>
µ, and the engine continues repeating the dot. The dot will match all remaining characters in 
the string. The dot fails when the engine has reached the void after the end of the string. Only at this point 
does the regex engine continue with the next token: «
>
». 
So far, «
<.+
» has matched „
<EM>first</EM> test
µ and the engine has arrived at the end of the string. «
>
» 
cannot match here. The engine remembers that the plus has repeated the dot more often than is required. 
(Remember that the plus requires the dot to match only once.) Rather than admitting failure, the engine will 
backtrack. It will reduce the repetition of the plus by one, and then continue trying the remainder of the regex. 
So the match of «
.+
» is reduced to „
EM>first</EM> tes
µ. The next token in the regex is still «
>
». But now 
the next character in the string is the last ´
t
µ. Again, these cannot match, causing the engine to backtrack 
further. The total match so far is reduced to „
<EM>first</EM> te
µ. But «
>
» still cannot match. So the 
engine continues backtracking until the match of «
.+
» is reduced to „
EM>first</EM
µ. Now, «
>
» can match 
the next character in the string. The last token in the regex has been matched. The engine reports that 
<EM>first</EM>
µ has been successfully matched. 
Remember that the regex engine is eager to return a match. It will not continue backtracking further to see if 
there is another possible match. It will report the first valid match it finds. Because of greediness, this is the 
leftmost longest match. 
Laziness Instead of Greediness 
The quick fix to this problem is to make the plus lazy instead of greedy. Lazy quantifiers are sometimes also 
called ´ungreedyµ or ´reluctantµ. You can do that by putting a question markbehind the plus in the regex. 
You can do the same with the star, the curly braces and the question mark itself. So our example becomes 
«
<.+?>
». Let’s have another look inside the regex engine. 
Again, «
<
» matches the first „
<
µ in the string. The next token is the dot, this time repeated by a lazy plus. This 
tells the regex engine to repeat the dot as few times as possible. The minimum is one. So the engine matches 
the dot with „
E
µ. The requirement has been met, and the engine continues with «
>
» and ´
M
µ. This fails. 
Again, the engine will backtrack. But this time, the backtracking will force the lazy plus to expand rather than 
reduce its reach. So the match of «
.+
» is expanded to „
EM
µ, and the engine tries again to continue with «
>
». 
Now, „
>
µ is matched successfully. The last token in the regex has been matched. The engine reports that 
<EM>
µ has been successfully matched. That’s more like it. 
An Alternative to Laziness 
In this case, there is a better option than making the plus lazy. We can use a greedy plus and a negated 
character class: «
<[^>]+>
». The reason why this is better is because of the backtracking. When using the lazy 
plus, the engine has to backtrack for each character in the HTML tag that it is trying to match. When using 
C# Word - Word Conversion in C#.NET
using other external third-party dependencies like Adobe Acrobat. Word SDK to convert Word document to PDF document. demo code for Word to TIFF image conversion
add photo to pdf online; add image to pdf acrobat
VB.NET PDF: How to Create Watermark on PDF Document within
Using this VB.NET Imaging PDF Watermark Add-on, you can a watermark that consists of text or image (such as And with our PDF Watermark Creator, users need no
how to add jpg to pdf file; add picture to pdf in preview
280 
the negated character class,  no backtracking occurs at all  when  the string contains  valid HTML code. 
Backtracking slows down the regex engine. You will not notice the difference when doing a single search in a 
text editor. But you will save plenty of CPU cycles when using such a regex repeatedly in a tight loop in a 
script that you are writing, or perhaps in a custom syntax coloring scheme for EditPad Pro. 
Finally, remember that this tutorial only talks about regex-directed engines. Text-directed engines do not 
backtrack. They do not get the speed penalty, but they also do not support lazy repetition operators.  
Repeating \Q...\E Escape Sequences 
The \Q...\E sequence escapes  a string of characters, matching them  as literal characters. The  escaped 
characters are treated as individual characters. If you place a quantifier after the 
\E
, it will only be applied to 
the last character. E.g. if you apply «
\Q*\d+*\E+
» to ´
*\d+**\d+*
µ, the match will be „
*\d+**
µ. Only the 
asterisk is repeated. Java 4 and 5 have a bug that causes the whole \Q..\E sequence to be repeated, yielding 
the whole subject string as the match. This was fixed in Java 6. 
VB.NET PowerPoint: VB Code to Draw and Create Annotation on PPT
as a kind of compensation for limitations (other documents are compatible, including PDF, TIFF, MS VB.NET PPT: VB Code to Add Embedded Image Object to
add picture to pdf file; add jpg to pdf document
BMP to PDF Converter | Convert Bitmap to PDF, Convert PDF to BMP
Also designed to be used add-on for .NET Image SDK, RasterEdge Bitmap to PDF Converter can Powerful image converter for Bitmap and PDF files; No need for
add an image to a pdf; attach image to pdf form
281 
12. Use Round Brackets for Grouping 
By placing part of a regular expression inside round brackets or parentheses, you can group that part of the 
regular expression together. This allows you to apply a regex operator, e.g. a repetition operator, to the entire 
group. I have already used round brackets for this purpose in previous topics throughout this tutorial. 
Note that only round brackets can be used for grouping. Square brackets define a character class, and curly 
braces are used by a special repetition operator. 
Round Brackets Create a Backreference 
Besides grouping part of a regular expression together, round brackets also create a ´backreferenceµ. A 
backreference  stores  the  part of  the string  matched by  the  part  of  the  regular  expression  inside  the 
parentheses. 
That is, unless you use non-capturing parentheses. Remembering part of the regex match in a backreference, 
slows down the regex engine because it has more work to do. If you do not use the backreference, you can 
speed things up by using non-capturing parentheses, at the expense of making your regular expression slightly 
harder to read. 
The regex «
Set(Value)?
» matches „
Set
µ or „
SetValue
µ. In the first case, the first backreference will be 
empty, because it did not match anything. In the second case, the first backreference will contain „
Value
µ. 
If you do not use the backreference, you can optimize this regular expression into «
Set(?:Value)?
». The 
question mark and the colon after the opening round bracket are the special syntax that you can use to tell the 
regex engine that this pair of brackets should not create a backreference. Note the question mark after the 
opening bracket is unrelated to the question mark at the end of the regex. That question mark is the regex 
operator that makes the previous token optional. This operator cannot appear after an opening round 
bracket, because an opening bracket by itself is not a valid regex token. Therefore, there is no confusion 
between the question mark as an operator to make a token optional, and the question mark as a character to 
change the properties of a pair of round brackets. The colon indicates that the change we want to make is to 
turn off capturing the backreference. 
How to Use Backreferences 
Backreferences allow you to reuse part of the regex match. You can reuse it inside the regular expression (see 
below), or afterwards. What you can do with it afterwards, depends on the tool or programming language you 
are using. The most common usage is in search-and-replace operations. The replacement text will use a 
special syntax to allow text matched by capturing groups to be reinserted. This syntax differs greatly between 
various tools and languages, far more than the regex syntax does. Please check the replacement text reference 
for details. 
JPEG to PDF Converter | Convert JPEG to PDF, Convert PDF to JPEG
It can be used standalone. JPEG to PDF Converter is able to convert image files to PDF directly without the software Adobe Acrobat Reader for conversion.
how to add a photo to a pdf document; how to add image to pdf acrobat
PDF to WORD Converter | Convert PDF to Word, Convert Word to PDF
out transformation between different kinds of image files and Word Converter has accurate output, and PDF to Word need the support of Adobe Acrobat & Microsoft
add image to pdf java; add jpg signature to pdf
282 
Using Backreferences in The Regular Expression 
Backreferences can not only be used after a match has been found, but also during the match. Suppose you 
want to match a pair of opening and closing HTML tags, and the text in between. By putting the opening tag 
into a backreference, we can reuse the name of the tag for the closing tag. Here’s how: «
<([A-Z][A-Z0-
9]*)\b[^>]*>.*?</\1>
» . This regex contains only one pair of parentheses, which capture the string 
matched  by  «
[A-Z][A-Z0-9]*
»  into  the  first  backreference.  This  backreference  is  reused  with  «
\1
» 
(backslash one). The «
/
» before it is simply the forward slash in the closing HTML tag that we are trying to 
match. 
To figure out the number of a particular backreference, scan the regular expression from left to right and 
count the opening round brackets. The first bracket starts backreference number one, the second number 
two, etc. Non-capturing parentheses are not counted. This fact means that non-capturing parentheses have 
another benefit: you can insert them into a regular expression without changing the numbers assigned to the 
backreferences. This can be very useful when modifying a complex regular expression. 
You can reuse the same backreference more than once. «
([a-c])x\1x\1
» will match „
axaxa
µ, „
bxbxb
µ 
and „
cxcxc
µ. 
Looking Inside The Regex Engine 
Let’s  see  how  the  regex  engine  applies  the  above  regex  to  the  string  ´
Testing  <B><I>bold 
italic</I></B> text
µ. The first token in the regex is the literal «
<
». The regex engine will traverse the 
string until it can match at the first „
<
µ in the string. The next token is «
[A-Z]
». The regex engine also takes 
note that it is now inside the first pair of capturing parentheses. «
[A-Z]
» matches „
B
µ. The engine advances 
to «
[A-Z0-9]
» and ´
>
µ. This match fails. However, because of the star, that’s perfectly fine. The position in 
the string remains at ´
>
µ. The position in the regex is advanced to «
[^>]
». 
This step crosses the closing bracket of the first pair of capturing parentheses. This prompts the regex engine 
to store what was matched inside them into the first backreference. In this case, „
B
µ is stored. 
After storing the backreference, the engine proceeds with the match attempt. «
[^>]
» does not match „
>
µ. 
Again, because of another star, this is not a problem. The position in the string remains at ´
>
µ, and position 
in the regex is advanced to «
>
». These obviously match. The next token is a dot, repeated by a lazy star. 
Because of the laziness, the regex engine will initially skip this token, taking note that it should backtrack in 
case the remainder of the regex fails. 
The engine has now arrived at the second «
<
» in the regex, and the second ´
<
µ in the string. These match. 
The next token is «
/
». This does not match ´
I
µ, and the engine is forced to backtrack to the dot. The dot 
matches the second „
<
µ in the string. The star is still lazy, so the engine again takes note of the available 
backtracking position and advances to «
<
» and ´
I
µ. These do not match, so the engine again backtracks. 
The backtracking continues until the dot has consumed „
<I>bold italic
µ. At this point, «
<
» matches the 
third „
<
µ in the string, and the next token is «
/
» which matches ´
/
µ. The next token is «
\1
». Note that the 
token is the backreference, and not «
B
». The engine does not substitute the backreference in the regular 
expression. Every time the engine arrives at the backreference, it will read the value that was stored. This 
means that if the engine had backtracked beyond the first pair of capturing parentheses before arriving the 
second time at «
\1
», the new value stored in the first backreference would be used. But this did not happen 
283 
here, so „
B
µ it is. This fails to match at ´
I
µ, so the engine backtracks again, and the dot consumes the third 
´
<
µ in the string. 
Backtracking continues again until the dot has consumed „
<I>bold italic</I>
µ. At this point, «
<
» 
matches „
<
µ and «
/
» matches „
/
µ. The engine arrives again at «
\1
». The backreference still holds „
B
µ. «
B
» 
matches „
B
µ. The last token in the regex, «
>
» matches „
>
µ. A complete match has been found: „
<B><I>bold 
italic</I></B>
µ. 
Backtracking Into Capturing Groups 
You may have wondered about the word boundary «
\b
» in the «
<([A-Z][A-Z0-9]*)\b[^>]*>.*?</\1>
» 
mentioned  above.  This  is  to  make  sure  the  regex  won’t  match  incorrectly  paired  tags  such  as 
´
<boo>bold</b>
µ. You may think that cannot happen because the capturing group matches „
boo
µ which 
causes «
\1
» to try to match the same, and fail. That is indeed what happens. But then the regex engine 
backtracks. 
Let’s take the regex «
<([A-Z][A-Z0-9]*)[^>]*>.*?</\1>
» without the word boundary and look inside 
the regex engine at the point where «
\1
» fails the first time. First, «
.*?
» continues to expand until it has 
reached the end of the string, and «
</\1>
» has failed to match each time «
.*?
» matched one more character. 
Then the regex engine backtracks into the capturing group. «
[A-Z0-9]*
» has matched „
oo
µ, but would just 
as happily match „
o
µ or nothing at all. When backtracking, «
[A-Z0-9]*
» is forced to give up one character. 
The regex engine continues, exiting the capturing group a second time. Since [A-Z][A-Z0-9]* has now 
matched „
bo
µ, that is what is stored into the capturing group, overwriting „
boo
µ that was stored before. 
«
[^>]*
» matches the second „
o
µ in the opening tag. «
>.*?</
» matches „
>bold<
µ. «
\1
» fails again. 
The regex engine does all the same backtracking once more, until «
[A-Z0-9]*
» is forced to give up another 
character, causing it to match nothing, which the star allows. The capturing group now stores just „
b
µ. 
«
[^>]*
» now matches „
oo
µ. «
>.*?</
» once again matches „
>bold<
µ. «
\1
» now succeeds, as does «
>
» and 
an overall match is found. But not the one we wanted. 
There are several solutions to this. One is to use the word boundary. When «
[A-Z0-9]*
» backtracks the first 
time, reducing the capturing group to „
bo
µ, «
\b
» fails to match between ´
o
µ and ´
o
µ. This forces «
[A-Z0-
9]*
» to backtrack again immediately. The capturing group is reduced to „
b
µ and the word boundary fails 
between ´
b
µ and ´
o
µ. There are no further backtracking positions, so the whole match attempt fails. 
The reason we need the word boundary is that we’re using «
[^>]*
» to skip over any attributes in the tag. If 
your  paired  tags  never  have  any  attributes,  you  can  leave  that  out,  and  use  «
<([A-Z][A-Z0-
9]*)>.*?</\1>
». Each time «
[A-Z0-9]*
» backtracks, the «
>
» that follows it will fail to match, quickly 
ending the match attempt. 
If you didn’t expect the regex engine to backtrack into capturing groups, you can use an atomic group. The 
regex engine always backtracks into capturing groups, and never captures atomic groups. You can put the 
capturing group inside an atomic group to get an atomic capturing group: «
(?>(atomic capture))
». In 
this  case,  we  can  put  the  whole  opening  tag  into  the  atomic  group:  «
(?><([A-Z][A-Z0-
9]*)[^>]*>).*?</\1>
». The tutorial section on atomic grouping has all the details. 
284 
Backreferences to Failed Groups 
The previous section applies to all regex flavors, except those few that don’t support capturing groups at all. 
Flavors behave differently when you start doing things that don’t fit the ´match the text matched by a 
previous capturing groupµ job description. 
There is a difference between a backreference to a capturing group that matched nothing, and one to a 
capturing group that did not participate in the match at all. The regex «
(q?)b\1
» will match „
b
µ. «
q?
» is 
optional and matches nothing, causing «
(q?)
» to successfully match and capture nothing. «
b
» matches „
b
µ 
and «
\1
» successfully matches the nothing captured by the group. 
The regex «
(q)?b\1
» however will fail to match ´
b
µ. «
(q)
» fails to match at all, so the group never gets to 
capture anything at all. Because the whole group is optional, the engine does proceed to match «
b
». However, 
the engine now arrives at «
\1
» which references a group that did not participate in the match attempt at all. 
This causes the backreference to fail to match at all, mimicking the result of the group. Since there’s no «
?
» 
making «
\1
» optional, the overall match attempt fails. 
The only exception is JavaScript. According to the official ECMA standard, a backreference to a non-
participating capturing group must successfully match nothing just like a backreference to a participating 
group that captured nothing does. In other words, in JavaScript, «
(q?)b\1
» and «
(q)?b\1
» both match „
b
µ. 
Forward References and Invalid References 
Modern flavors, notably JGsoft, .NET, Java, Perl, PCRE and Ruby allow forward references. That is: you can 
use a backreference to a group that appears later in the regex. Forward references are obviously only useful if 
they’re inside a repeated group. Then there can  be  situations in which the  regex engine evaluates the 
backreference after the group has already matched. Before the group is attempted, the backreference will fail 
like a backreference to a failed group does. 
If forward references are supported, the regex «
(\2two|(one))+
» will match „
oneonetwo
µ. At the start of 
the string, «
\2
» fails. Trying the other alternative, „
one
µ is matched by the second capturing group, and 
subsequently by the first group. The first group is then repeated. This time, «
\2
» matches „
one
µ as captured 
by the second group. «
two
» then matches „
two
µ. With two repetitions of the first group, the regex has 
matched the whole subject string. 
A nested reference is a backreference inside the capturing group that it references, e.g. «
(\1two|(one))+
». 
This regex will give exactly the same behavior with flavors that support forward references. Some flavors that 
don’t support forward references do support nested references. This includes JavaScript. 
With all other flavors, using a backreference before its group in the regular expression is the same as using a 
backreference to a group that doesn’t exist at all. All flavors discussed in this tutorial, except JavaScript and 
Ruby, treat backreferences to undefined groups as an error. In JavaScript and Ruby, they always result in a 
zero-width match. For Ruby this is a potential pitfall. In Ruby, «
(a)(b)?\2
» will fail to match ´
a
µ, because 
«
\2
» references a non-participating group. But «
(a)(b)?\7
» will match „
a
µ. For JavaScript this is logical, as 
backreferences to non-participating groups do the same. Both regexes will match „
a
µ. 
285 
Repetition and Backreferences 
As I mentioned in the above inside look, the regex engine does not permanently substitute backreferences in 
the regular expression. It will use the last match saved into the backreference each time it needs to be used. If 
a new match is found by capturing parentheses, the previously saved match is overwritten. There is a clear 
difference between «
([abc]+)
» and «
([abc])+
». Though both successfully match „
cab
µ, the first regex will 
put „
cab
µ into the first backreference, while the second regex will only store „
b
µ. That is because in the 
second regex, the plus caused the pair of parentheses to repeat three times. The first time, „
c
µ was stored. 
The second time „
a
µ and the third time „
b
µ. Each time, the previous value was overwritten, so „
b
µ remains. 
This also means that «
([abc]+)=\1
» will match „
cab=cab
µ, and that «
([abc])+=\1
» will not. The reason 
is that when the engine arrives at «
\1
», it holds «
b
» which fails to match ´
c
µ. Obvious when you look at a 
simple example like this one, but a common cause of difficulty with regular expressions nonetheless. When 
using backreferences, always double check that you are really capturing what you want. 
Useful Example: Checking for Doubled Words 
When editing text, doubled words such as ´the theµ easily creep in. Using the regex «
\b(\w+)\s+\1\b
» in 
your text editor, you can easily find them. To delete the second word, simply type in ´
\1
µ as the replacement 
text and click the Replace button. 
Parentheses and Backreferences Cannot Be Used Inside Character Classes 
Round brackets cannot be used inside character classes, at least not as metacharacters. When you put a round 
bracket in a character class, it is treated as a literal character. So the regex «
[(a)b]
» matches „
a
µ, „
b
µ, „
(
µ 
and „
)
µ. 
Backreferences also  cannot be used inside a  character class. The \1 in regex like  «
(a)[\1b]
» will be 
interpreted as an octal escape in most regex flavors. So this regex will match an „
a
µ followed by either «
\x01
» 
or a «
b
». 
Documents you may be interested
Documents you may be interested