open pdf and draw c# : Add a link to a pdf SDK software service wpf windows .net dnn %5BO%60Reilly%5D%20-%20JavaScript.%20The%20Definitive%20Guide,%206th%20ed.%20-%20%5BFlanagan%5D27-part1556

Character
Matches
\r
Carriage return (
\u000D
)
\x
nn
The Latin character specified by the hexadecimal number 
nn
; for example, 
\x0A
is the same as 
\n
\u
xxxx
The Unicode character specified by the hexadecimal number 
xxxx
; for example, 
\u0009
is the same
as 
\t
\c
X
The control character 
^
X
; for example, 
\cJ
is equivalent to the newline character 
\n
A number of punctuation characters have special meanings in regular expressions. They
are:
^ $ . * + ? = ! : | \ / ( ) [ ] { }
The  meanings  of these  characters  are discussed in  the sections that follow. Some  of
these characters have special meaning only within certain contexts of a regular expres-
sion and are treated literally in other contexts. As a general rule, however, if you want
to include any of these punctuation characters literally in a regular expression, you must
precede them with a 
\
. Other punctuation characters, such as quotation marks and 
@
,
do  not  have  special  meaning  and  simply  match  themselves  literally  in  a  regular
expression.
If you can’t remember exactly which punctuation characters need to be escaped with
a backslash, you may safely place a backslash before any punctuation  character.  On
the other hand, note that many letters and numbers have special meaning when pre-
ceded by a backslash, so any letters or numbers that you want to match literally should
not be escaped with a backslash. To include a backslash character literally in a regular
expression, you must escape it with a backslash, of course. For example, the following
regular expression matches any string that includes a backslash: 
/\\/
.
10.1.2  Character Classes
Individual literal  characters  can  be  combined into character  classes by  placing them
within square brackets. A character class matches any one character that is contained
within it. Thus, the regular expression 
/[abc]/
matches any one of the letters a, b, or
c. Negated character classes can also be defined; these match any character except those
contained within the brackets. A negated character class is specified by placing a caret
(
^
) as the first character inside the left bracket. The regexp 
/[^abc]/
matches any one
character other than a, b, or c. Character classes can use a hyphen to indicate a range
of  characters.  To  match  any  one  lowercase  character  from  the  Latin  alphabet,
use 
/[a-z]/
and to match any letter or digit from the Latin alphabet, use 
/[a-zA-Z0-9]/
.
Because certain character classes are commonly used, the JavaScript regular-expression
syntax includes special  characters and  escape sequences to represent these  common
classes. For example, 
\s
matches the space character, the tab character, and any other
Unicode whitespace character; 
\S
matches  any character that is  not  Unicode white-
space. Table 10-2 lists these characters and summarizes character-class syntax. (Note
that several of these character-class escape sequences match only ASCII characters and
10.1  Defining Regular Expressions | 253
Core JavaScript
Add a link to a pdf - insert, remove PDF links in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Free C# example code is offered for users to edit PDF document hyperlink (url), like inserting and deleting
add hyperlink pdf document; pdf reader link
Add a link to a pdf - VB.NET PDF url edit library: insert, remove PDF links in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Help to Insert a Hyperlink to Specified PDF Document Page
adding a link to a pdf in preview; active links in pdf
have not been extended to work with Unicode characters. You can, however, explicitly
define your own Unicode character classes; for example, 
/[\u0400-\u04FF]/
matches
any one Cyrillic character.)
Table 10-2. Regular expression character classes
Character Matches
[...]
Any one character between the brackets.
[^...]
Any one character not between the brackets.
.
Any character except newline or another Unicode line terminator.
\w
Any ASCII word character. Equivalent to 
[a-zA-Z0-9_]
.
\W
Any character that is not an ASCII word character. Equivalent to 
[^a-zA-Z0-9_]
.
\s
Any Unicode whitespace character.
\S
Any character that is not Unicode whitespace. Note that 
\w
and 
\S
are not the same thing.
\d
Any ASCII digit. Equivalent to 
[0-9]
.
\D
Any character other than an ASCII digit. Equivalent to 
[^0-9]
.
[\b]
A literal backspace (special case).
Note  that the  special character-class escapes can be  used within square brackets. 
\s
matches any whitespace character, and 
\d
matches any digit, so 
/[\s\d]/
matches any
one whitespace character or digit. Note that there is one special case. As you’ll see later,
the 
\b
escape has a special meaning. When used within a character class, however, it
represents the backspace character. Thus, to represent a backspace character literally
in a regular expression, use the character class with one element: 
/[\b]/
.
10.1.3  Repetition
With the regular expression syntax you’ve learned so far, you can describe a two-digit
number as 
/\d\d/
and a four-digit number as 
/\d\d\d\d/
. But you don’t have any way
to describe, for example, a number that can have any number of digits or a string of
three letters followed by an optional digit. These more complex patterns use regular-
expression syntax that specifies  how  many times an element of a regular expression
may be repeated.
The characters that specify repetition always follow the pattern to which they are being
applied. Because certain types of repetition are quite commonly used, there are special
characters to represent these cases. For example, 
+
matches one or more occurrences
of the previous pattern. Table 10-3 summarizes the repetition syntax.
254 | Chapter 10: Pattern Matching with Regular Expressions
RasterEdge .NET Document Imaging Trial Package Download Link.
Extract; C# Read: PDF Image Extract; C# Write: Insert text into PDF; C# Write: Add Image to PDF; C# Protect: Add Password to PDF; C#
add hyperlink to pdf; add link to pdf acrobat
C# PDF Library SDK to view, edit, convert, process PDF file for C#
editing PDF document hyperlink (url) and quick navigation link in PDF bookmark. C#.NET: Edit PDF Metadata. PDF SDK for .NET allows you to read, add, edit, update
add links pdf document; adding hyperlinks to pdf
Table 10-3. Regular expression repetition characters
Character Meaning
{
n
,
m
}
Match the previous item at least 
n
times but no more than 
m
times.
{
n
,}
Match the previous item 
n
or more times.
{
n
}
Match exactly 
n
occurrences of the previous item.
?
Match zero or one occurrences of the previous item. That is, the previous item is optional. Equivalent to 
{0,1}
.
+
Match one or more occurrences of the previous item. Equivalent to 
{1,}
.
*
Match zero or more occurrences of the previous item. Equivalent to 
{0,}
.
The following lines show some examples:
/\d{2,4}/    // Match between two and four digits
/\w{3}\d?/   // Match exactly three word characters and an optional digit
/\s+java\s+/ // Match "java" with one or more spaces before and after
/[^(]*/      // Match zero or more characters that are not open parenthesis
Be careful when  using  the 
*
and 
?
repetition  characters. Since  these characters may
match zero instances of whatever precedes them, they are allowed to match nothing.
For example, the regular expression 
/a*/
actually matches the string “bbbb” because
the string contains zero occurrences of the letter a!
10.1.3.1  Nongreedy repetition
The repetition characters listed in Table 10-3 match as many times as possible while
still allowing any following parts of the regular expression to match. We say that this
repetition is “greedy.” It is also possible to specify that repetition should be done in a
nongreedy way. Simply follow the  repetition  character or characters with a question
mark: 
??
+?
*?
, or even 
{1,5}?
. For example, the regular expression 
/a+/
matches one
or more  occurrences of the letter a.  When applied to the string “aaa”, it matches all
three letters. But 
/a+?/
matches one or more occurrences of the letter a, matching as
few characters as necessary. When applied to the same string, this pattern matches only
the first letter a.
Using nongreedy repetition may not always produce the results you expect. Consider
the  pattern 
/a+b/
,  which  matches  one  or  more  a’s, followed  by  the  letter  b.  When
applied to the string “aaab”, it matches the entire string. Now let’s use the nongreedy
version: 
/a+?b/
. This should match the letter b preceded by the fewest number of a’s
possible. When applied to the same string “aaab”, you might expect it to match only
one a and the last letter b. In fact, however, this pattern matches the entire string, just
like the greedy version of the pattern. This is because regular-expression pattern match-
ing is done by finding the first position in the string at which a match is possible. Since
a match is possible starting at the first character of the string, shorter matches starting
at subsequent characters are never even considered.
10.1  Defining Regular Expressions | 255
Core JavaScript
C# PDF insert image Library: insert images into PDF in C#.net, ASP
C#.NET PDF SDK - Add Image to PDF Page in C#.NET. How to Insert & Add Image, Picture or Logo on PDF Page Using C#.NET. Add Image to PDF Page Using C#.NET.
add links to pdf in preview; add hyperlink in pdf
VB.NET PDF insert image library: insert images into PDF in vb.net
VB.NET PDF - Add Image to PDF Page in VB.NET. Guide VB.NET Programmers How to Add Images in PDF Document Using XDoc.PDF SDK for VB.NET.
add link to pdf; pdf edit hyperlink
10.1.4  Alternation, Grouping, and References
The regular-expression grammar includes special characters for specifying alternatives,
grouping  subexpressions, and referring  to  previous  subexpressions. The 
|
character
separates alternatives. For example, 
/ab|cd|ef/
matches the string “ab” or the string
“cd”  or  the  string  “ef”.  And 
/\d{3}|[a-z]{4}/
matches  either  three  digits  or  four
lowercase letters.
Note  that alternatives  are considered left  to  right  until a match is  found.  If the  left
alternative matches, the right alternative is ignored, even if it would have produced a
“better” match. Thus, when the pattern 
/a|ab/
is applied to the string “ab”, it matches
only the first letter.
Parentheses  have  several  purposes  in  regular  expressions.  One purpose  is  to group
separate items into a single subexpression so that the items can be treated as a single
unit by 
|
*
+
?
, and so on. For example, 
/java(script)?/
matches “java” followed by
the optional “script”. And 
/(ab|cd)+|ef/
matches either the string “ef” or one or more
repetitions of either of the strings “ab” or “cd”.
Another purpose of parentheses in regular expressions is to define subpatterns within
the  complete  pattern.  When  a  regular  expression  is  successfully  matched  against  a
target string, it is possible to extract the portions of the target string that matched any
particular parenthesized subpattern. (You’ll see how these matching substrings are ob-
tained  later in the  chapter.)  For  example,  suppose you  are  looking for  one  or  more
lowercase letters followed by one or more digits. You might use the pattern 
/[a-z]+\d
+/
. But suppose you only really care about the digits at the end of each match. If you
put that part of the pattern in parentheses 
(/[a-z]+(\d+)/)
, you can extract the digits
from any matches you find, as explained later.
A related use of parenthesized subexpressions is to allow you to refer back to a subex-
pression later in the same regular expression. This is done by following a 
\
character
by a digit or digits. The digits refer to the position of the parenthesized subexpression
within the regular expression. For example, 
\1
refers back to the first subexpression,
and 
\3
refers  to  the  third.  Note  that,  because  subexpressions  can  be  nested  within
others, it is the position of the left parenthesis that is counted. In the following regular
expression, for example, the nested subexpression 
([Ss]cript)
is referred to as 
\2
:
/([Jj]ava([Ss]cript)?)\sis\s(fun\w*)/
A reference to a  previous subexpression of a regular expression  does  not refer to the
pattern for that subexpression but rather to the text that matched the pattern. Thus,
references can be used to enforce a constraint that separate portions of a string contain
exactly the same  characters. For example,  the following  regular  expression matches
zero or more characters within single or double quotes. However, it does not require
the  opening  and  closing  quotes  to  match  (i.e.,  both  single  quotes  or  both  double
quotes):
/['"][^'"]*['"]/
256 | Chapter 10: Pattern Matching with Regular Expressions
VB.NET PDF Password Library: add, remove, edit PDF file password
VB: Add Password to PDF with Permission Settings Applied. This VB.NET example shows how to add PDF file password with access permission setting.
accessible links in pdf; adding hyperlinks to pdf documents
C# PDF Password Library: add, remove, edit PDF file password in C#
C# Sample Code: Add Password to PDF with Permission Settings Applied in C#.NET. This example shows how to add PDF file password with access permission setting.
add link to pdf file; add links to pdf online
To require the quotes to match, use a reference:
/(['"])[^'"]*\1/
The 
\1
matches whatever  the  first parenthesized subexpression matched.  In this  ex-
ample, it enforces the constraint that the closing quote match the opening quote. This
regular expression does not allow single quotes within double-quoted strings or vice
versa. It is not legal to use a reference within a character class, so you cannot write:
/(['"])[^\1]*\1/
Later  in  this  chapter,  you’ll  see  that  this  kind  of  reference  to  a  parenthesized
subexpression  is a powerful  feature  of  regular-expression search-and-replace  opera-
tions.
It is also possible to group items in a regular expression without creating a numbered
reference to those items. Instead of simply grouping the items within 
(
and 
)
, begin the
group with 
(?:
and end it with 
)
. Consider the following pattern, for example:
/([Jj]ava(?:[Ss]cript)?)\sis\s(fun\w*)/
Here, the subexpression 
(?:[Ss]cript)
is used simply for grouping, so the 
?
repetition
character can be applied to the group. These modified parentheses do not produce a
reference, so in this regular expression, 
\2
refers to the text matched by 
(fun\w*)
.
Table 10-4 summarizes the regular-expression alternation, grouping, and referencing
operators.
Table 10-4. Regular expression alternation, grouping, and reference characters
Character Meaning
|
Alternation. Match either the subexpression to the left or the subexpression to the right.
(...)
Grouping. Group items into a single unit that can be used with 
*
+
?
|
, and so on. Also remember the characters
that match this group for use with later references.
(?:...)
Grouping only. Group items into a single unit, but do not remember the characters that match this group.
\
n
Match the same characters that were matched when group number 
n
was first matched. Groups are subexpressions
within (possibly nested) parentheses. Group numbers are assigned by counting left parentheses from left to right.
Groups formed with 
(?:
are not numbered.
10.1.5  Specifying Match Position
As described earlier, many elements of a regular expression match a single character in
a string. For example, 
\s
matches a single character of whitespace. Other regular ex-
pression elements match the positions between characters, instead of actual characters.
\b
, for example, matches a word boundary—the boundary between a 
\w
(ASCII word
character)  and  a 
\W
(nonword  character),  or  the  boundary  between  an  ASCII word
character and the beginning or end of a string.
2
Elements such as 
\b
do not specify any
2. Except within a character class (square brackets), where 
\b
matches the backspace character.
10.1  Defining Regular Expressions | 257
Core JavaScript
Download from Wow! eBook <www.wowebook.com>
How to C#: Basic SDK Concept of XDoc.PDF for .NET
You may add PDF document protection functionality into your C# of PDF document, including editing PDF url links and quick navigation link in bookmark
add hyperlinks to pdf; pdf reader link
VB.NET PDF: Basic SDK Concept of XDoc.PDF
You may add PDF document protection functionality into your VB.NET of PDF document, including editing PDF url links and quick navigation link in bookmark
adding links to pdf; add url pdf
characters  to be used  in  a  matched string;  what  they do  specify,  however,  are  legal
positions  at  which  a match can occur.  Sometimes these  elements are called  regular-
expression anchors because they anchor the pattern to a specific position in the search
string. The most commonly used anchor elements are 
^
, which ties the pattern to the
beginning of the string, and 
$
, which anchors the pattern to the end of the string.
For example, to match the word “JavaScript” on a line by itself, you can use the regular
expression 
/^JavaScript$/
. If you want to search for “Java” as a word by itself (not as
a prefix, as it is in “JavaScript”), you can try the pattern 
/\sJava\s/
, which requires a
space before and after the word. But there are two problems with this solution. First,
it does not match “Java” at the beginning or the end of a string, but only if it appears
with space on either side. Second, when this pattern does find a match, the matched
string it returns has leading and trailing spaces, which is not quite what’s needed. So
instead of matching actual space characters with 
\s
, match (or anchor to) word boun-
daries  with 
\b
. The  resulting  expression is 
/\bJava\b/
.  The  element 
\B
anchors  the
match  to  a  location  that  is  not  a  word  boundary.  Thus,  the  pattern 
/\B[Ss]cript/
matches “JavaScript” and “postscript”, but not “script” or “Scripting”.
You can also use arbitrary regular expressions as anchor conditions. If you include an
expression within 
(?=
and 
)
characters, it is a lookahead assertion, and it specifies that
the enclosed characters must match, without actually matching them. For example, to
match the name of a common programming language, but only if it is followed by a
colon,  you  could  use 
/[Jj]ava([Ss]cript)?(?=\:)/
.  This pattern  matches  the word
“JavaScript” in  “JavaScript:  The Definitive Guide”, but it  does not  match  “Java”  in
“Java in a Nutshell”, because it is not followed by a colon.
If  you  instead  introduce an  assertion  with 
(?!
,  it  is  a  negative lookahead  assertion,
which specifies that the following characters must not match. For example, 
/Java(?!
Script)([A-Z]\w*)/
matches “Java”  followed  by  a  capital  letter and any number  of
additional  ASCII  word  characters,  as  long  as  “Java”  is  not  followed  by  “Script”.  It
matches “JavaBeans”  but not “Javanese”, and it matches “JavaScrip”  but not “Java-
Script” or “JavaScripter”.
Table 10-5 summarizes regular-expression anchors.
Table 10-5. Regular-expression anchor characters
Character Meaning
^
Match the beginning of the string and, in multiline searches, the beginning of a line.
$
Match the end of the string and, in multiline searches, the end of a line.
\b
Match a word boundary. That is, match the position between a 
\w
character and a 
\W
character or between a
\w
character and the beginning or end of a string. (Note, however, that 
[\b]
matches backspace.)
\B
Match a position that is not a word boundary.
(?=
p
)
A positive lookahead assertion. Require that the following characters match the pattern 
p
, but do not include
those characters in the match.
(?!
p
)
A negative lookahead assertion. Require that the following characters do not match the pattern 
p
.
258 | Chapter 10: Pattern Matching with Regular Expressions
10.1.6  Flags
There  is  one  final  element  of  regular-expression  grammar. Regular-expression  flags
specify high-level pattern-matching rules. Unlike the rest of regular-expression syntax,
flags are specified outside the 
/
characters; instead of appearing within the slashes, they
appear following the second slash. JavaScript supports three flags. The 
i
flag specifies
that  pattern  matching  should  be  case-insensitive.  The 
g
flag  specifies  that  pattern
matching should be global—that is, all matches within the searched string should be
found.  The 
m
flag performs pattern matching in multiline mode. In this  mode, if the
string to be searched contains newlines, the 
^
and 
$
anchors match the beginning and
end of a line in addition to matching the beginning and end of a string. For example,
the pattern 
/java$/im
matches “java” as well as “Java\nis fun”.
These flags may be specified in any combination. For example, to do a case-insensitive
search for the first occurrence of the word “java” (or “Java”, “JAVA”, etc.), you can
use the case-insensitive regular expression 
/\bjava\b/i
. And to find all occurrences of
the word in a string, you can add the 
g
flag: 
/\bjava\b/gi
.
Table 10-6 summarizes these regular-expression flags. Note that you’ll see more about
the 
g
flag later in this chapter, when the String and RegExp methods are used to actually
perform matches.
Table 10-6. Regular-expression flags
Character Meaning
i
Perform case-insensitive matching.
g
Perform a global match—that is, find all matches rather than stopping after the first match.
m
Multiline mode. 
^
matches beginning of line or beginning of string, and 
$
matches end of line or end of string.
10.2  String Methods for Pattern Matching
Until now, this chapter has discussed the grammar used to create regular expressions,
but it hasn’t examined how those regular expressions can actually be used in JavaScript
code. This section discusses methods of the String object that use regular expressions
to perform pattern matching and search-and-replace operations. The sections that fol-
low this one continue the discussion of pattern matching with JavaScript regular ex-
pressions by discussing the RegExp object and its methods and properties. Note that
the discussion that follows is merely an overview of the various methods and properties
related to regular expressions. As usual, complete details can be found in Part III.
Strings support four methods that use regular expressions. The simplest is 
search()
.
This method takes a regular-expression argument and returns either the character po-
sition of the start of the first matching substring or −1 if there is no match. For example,
the following call returns 4:
"JavaScript".search(/script/i);
10.2  String Methods for Pattern Matching | 259
Core JavaScript
If the argument to 
search()
is not a regular expression, it is first converted to one by
passing  it  to  the 
RegExp
constructor. 
search()
does  not  support  global  searches;  it
ignores the 
g
flag of its regular expression argument.
The 
replace()
method performs a search-and-replace operation. It takes a regular ex-
pression  as  its  first  argument  and  a  replacement  string  as  its  second  argument.  It
searches the string on which it is called for matches with the specified pattern. If the
regular expression has the 
g
flag set, the 
replace()
method replaces all matches in the
string with the replacement string; otherwise, it replaces only the first match it finds.
If the first argument to 
replace()
is a string rather than a regular expression, the method
searches for that string literally rather than converting it to a regular expression with
the 
RegExp()
constructor, as 
search()
does. As an example, you can use 
replace()
as
follows to provide uniform capitalization of the word “JavaScript” throughout a string
of text:
// No matter how it is capitalized, replace it with the correct capitalization
text.replace(/javascript/gi, "JavaScript");
replace()
is more powerful than this, however. Recall that parenthesized subexpres-
sions of a regular expression are numbered from left to right and that the regular ex-
pression remembers the text that each subexpression matches. If a 
$
followed by a digit
appears in the replacement string, 
replace()
replaces those two characters with the text
that matches the specified subexpression. This is a very useful feature. You can use it,
for example, to  replace straight quotes in a string with curly quotes, simulated with
ASCII characters:
// A quote is a quotation mark, followed by any number of
// nonquotation-mark characters (which we remember), followed
// by another quotation mark.
var quote = /"([^"]*)"/g;
// Replace the straight quotation marks with curly quotes,
// leaving the quoted text (stored in $1) unchanged.
text.replace(quote, '“$1”');
The 
replace()
method has other important features as well, which are described in the
String.replace()
reference  page  in Part III.  Most  notably,  the  second  argument  to
replace()
can be a function that dynamically computes the replacement string.
The 
match()
method is the most general of the String regular-expression methods. It
takes a regular expression as its only argument (or converts its argument to a regular
expression by passing it to the 
RegExp()
constructor) and returns an array that contains
the results of the match. If the regular expression has the 
g
flag set, the method returns
an array of all matches that appear in the string. For example:
"1 plus 2 equals 3".match(/\d+/g)  // returns ["1", "2", "3"]
If the regular expression does not have the 
g
flag set, 
match()
does not do a global search;
it simply searches for the first match. However, 
match()
returns an array even when it
does  not  perform  a  global  search.  In  this case,  the  first  element  of  the  array  is  the
matching string, and any remaining elements are the parenthesized subexpressions of
260 | Chapter 10: Pattern Matching with Regular Expressions
the regular expression. Thus, if 
match()
returns an array 
a
a[0]
contains the complete
match, 
a[1]
contains the substring that matched the first parenthesized expression, and
so on. To draw a parallel with the 
replace()
method, 
a[
n
]
holds the contents of 
$
n
.
For example, consider parsing a URL with the following code:
var url = /(\w+):\/\/([\w.]+)\/(\S*)/;
var text = "Visit my blog at http://www.example.com/~david";
var result = text.match(url);
if (result != null) {
var fullurl = result[0];   // Contains "http://www.example.com/~david"
var protocol = result[1];  // Contains "http"
var host = result[2];      // Contains "www.example.com"
var path = result[3];      // Contains "~david"
}
It is worth noting that passing a nonglobal regular expression to the 
match()
method
of a string is actually the same as passing the string to the 
exec()
method of the regular
expression:  the  returned  array  has 
index
and 
input
properties,  as  described  for  the
exec()
method below.
The last of the regular-expression methods of the String object is 
split()
. This method
breaks the string on which it is called into an array of substrings, using the argument
as a separator. For example:
"123,456,789".split(",");  // Returns ["123","456","789"]
The 
split()
method  can also  take  a regular expression  as its argument. This  ability
makes the method more powerful. For example, you can now specify a separator char-
acter that allows an arbitrary amount of whitespace on either side:
"1, 2, 3, 4, 5".split(/\s*,\s*/); // Returns ["1","2","3","4","5"]
The 
split()
method  has  other  features  as  well.  See  the 
String.split()
entry  in
Part III for complete details.
10.3  The RegExp Object
As mentioned at the beginning of this chapter, regular expressions are represented as
RegExp objects. In addition to the 
RegExp()
constructor, RegExp objects support three
methods and a number of properties. RegExp pattern-matching methods and proper-
ties are described in the next two sections.
The 
RegExp()
constructor takes one or two string arguments and creates a new RegExp
object. The first argument to this constructor is a string that contains the body of the
regular expression—the text that would appear within slashes in a regular-expression
literal.  Note  that  both  string literals  and regular  expressions  use  the 
\
character  for
escape sequences, so when you pass a regular expression to 
RegExp()
as a string literal,
you must replace each 
\
character with 
\\
. The second argument to 
RegExp()
is optional.
If supplied, it indicates the regular-expression flags. It should be 
g
i
m
, or a combination
of those letters.
10.3  The RegExp Object | 261
Core JavaScript
For example:
// Find all five-digit numbers in a string. Note the double \\ in this case.
var zipcode = new RegExp("\\d{5}", "g");
The 
RegExp()
constructor is useful when a regular expression is being dynamically cre-
ated  and  thus  cannot  be  represented with  the regular-expression  literal  syntax. For
example, to search for a string entered by the user, a regular expression must be created
at runtime with 
RegExp()
.
10.3.1  RegExp Properties
Each RegExp object has five properties. The 
source
property is a read-only string that
contains the text of the regular expression. The 
global
property is a read-only boolean
value that specifies whether the regular expression has the 
g
flag. The 
ignoreCase
prop-
erty is a read-only boolean value that specifies whether the regular expression has the
i
flag. The 
multiline
property is a read-only boolean value that specifies whether the
regular expression has the 
m
flag. The final property is 
lastIndex
, a read/write integer.
For patterns with the 
g
flag, this property stores the position in the string at which the
next search is to begin. It is used by the 
exec()
and 
test()
methods, described below.
10.3.2  RegExp Methods
RegExp objects define two methods that perform pattern-matching operations; they
behave  similarly  to the  String methods  described earlier. The main  RegExp  pattern-
matching  method  is 
exec()
. It  is  similar  to  the  String 
match()
method  described  in
§10.2, except that it is a RegExp method that takes a string, rather than a String method
that takes a RegExp. The 
exec()
method executes a regular expression on the specified
string. That is, it searches the string for a match. If it finds none, it returns 
null
. If it
does find one, however, it returns an array just like the array returned by the 
match()
method for nonglobal searches. Element 0 of the array contains the string that matched
the regular expression, and any subsequent array elements contain the substrings that
matched any parenthesized subexpressions. Furthermore, the 
index
property contains
the character position at which the match occurred, and the 
input
property refers to
the string that was searched.
Unlike the 
match()
method, 
exec()
returns the same kind of array whether or not the
regular expression has the global 
g
flag. Recall that 
match()
returns an array of matches
when passed a global regular expression. 
exec()
, by contrast, always returns a single
match and provides complete information about that match. When 
exec()
is called on
a regular expression that has the 
g
flag, it sets the 
lastIndex
property of the regular-
expression object to the character position  immediately  following the matched  sub-
string. When 
exec()
is invoked a second time for the same regular expression, it begins
its search at the character position indicated by the 
lastIndex
property. If 
exec()
does
not find a match, it resets 
lastIndex
to 0. (You can also set 
lastIndex
to 0 at any time,
which you should do whenever you quit a search before you find the last match in one
string and begin searching another string with the same RegExp object.) This special
262 | Chapter 10: Pattern Matching with Regular Expressions
Documents you may be interested
Documents you may be interested