Table 1.1 Special characters in
regular expressions.
|
Character
|
Meaning
|
|
\
|
For characters that are usually treated
literally, indicates that the next character is special and not
to be interpreted literally.
For example, /b/ matches the
character 'b'. By placing a backslash in front of b, that is by
using /\b/, the
character becomes special to mean match a word boundary.
-or-
For characters that are usually treated
specially, indicates that the next character is not special and
should be interpreted literally.
For example, * is a special
character that means 0 or more occurrences of the preceding
character should be matched; for example, /a*/ means match
0 or more a's. To match
*
literally, precede the it with a backslash; for example,
/a\*/
matches 'a*'.
|
|
^
|
Matches beginning of input. If the
multiline flag is set to true, also matches immediately after a
line break character.
For example, /^A/ does not
match the 'A' in "an A", but does match the first 'A' in "An
A."
|
|
$
|
Matches end of input. If the multiline
flag is set to true, also matches immediately before a line
break character.
For example, /t$/ does not
match the 't' in "eater", but does match it in "eat".
|
|
*
|
Matches the preceding item 0 or more
times.
For example, /bo*/ matches
'boooo' in "A ghost booooed" and 'b' in "A bird warbled", but
nothing in "A goat grunted".
|
|
+
|
Matches the preceding item 1 or more
times. Equivalent to {1,}.
For example, /a+/ matches the
'a' in "candy" and all the a's in "caaaaaaandy".
|
|
?
|
Matches the preceding item 0 or 1 time.
For example, /e?le?/ matches
the 'el' in "angel" and the 'le' in "angle."
If
used immediately after any of the quantifiers *,
+,
?, or
{}, makes
the quantifier non-greedy (matching the minimum number of
times), as opposed to the default, which is greedy
(matching the maximum number of times).
Also used in lookahead assertions,
described under (?=), (?!), and (?:)
in this table.
|
|
.
|
(The decimal point) matches any single
character except the newline character.
For example, /.n/ matches 'an'
and 'on' in "nay, an apple is on the tree", but not 'nay'.
|
|
(x)
|
Matches 'x' and remembers the match. These
are called capturing parentheses.
For example, /(foo)/ matches
and remembers 'foo' in "foo bar." The matched substring can be
recalled from the resulting array's elements [1], ...,
[n] or
from the predefined RegExp object's
properties $1, ...,
$9.
|
|
(?:x)
|
Matches 'x' but does not remember the
match. These are called non-capturing parentheses. The matched
substring can not be recalled from the resulting array's
elements [1], ...,
[n] or
from the predefined RegExp object's
properties $1, ...,
$9.
|
|
x(?=y)
|
Matches 'x' only if 'x' is followed by
'y'. For example, /Jack(?=Sprat)/
matches 'Jack' only if it is followed by 'Sprat'.
/Jack(?=Sprat|Frost)/matches
'Jack' only if it is followed by 'Sprat' or 'Frost'.
However, neither 'Sprat' nor 'Frost' is part of the match
results.
|
|
x(?!y)
|
Matches 'x' only if 'x' is not followed by
'y'. For example, /\d+(?!\.)/
matches a number only if it is not followed by a decimal
point.
/\d+(?!\.)/.exec("3.141")
matches 141 but not 3.141.
|
|
x|y
|
Matches either 'x' or 'y'.
For example, /green|red/
matches 'green' in "green apple" and 'red' in "red apple."
|
|
{n}
|
Where n is a positive
integer. Matches exactly n occurrences of
the preceding item.
For example, /a{2}/ doesn't
match the 'a' in "candy," but it matches all of the a's in
"caandy," and the first two a's in "caaandy."
|
|
{n,}
|
Where n is a positive
integer. Matches at least n occurrences of
the preceding item.
For example, /a{2,} doesn't
match the 'a' in "candy", but matches all of the a's in
"caandy" and in "caaaaaaandy."
|
|
{n,m}
|
Where n and
m
are positive integers. Matches at least n and at
most m
occurrences of the preceding item.
For example, /a{1,3}/ matches
nothing in "cndy", the 'a' in "candy," the first two a's in
"caandy," and the first three a's in "caaaaaaandy". Notice that
when matching "caaaaaaandy", the match is "aaa", even though
the original string had more a's in it.
|
|
[xyz]
|
A
character set. Matches any one of the enclosed characters. You
can specify a range of characters by using a hyphen.
For example, [abcd] is the
same as [a-c]. They match
the 'b' in "brisket" and the 'c' in "ache".
|
|
[^xyz]
|
A
negated or complemented character set. That is, it matches
anything that is not enclosed in the brackets. You can specify
a range of characters by using a hyphen.
For example, [^abc] is the
same as [^a-c]. They
initially match 'r' in "brisket" and 'h' in "chop."
|
|
[\b]
|
Matches a backspace. (Not to be confused
with \b.)
|
|
\b
|
Matches a word boundary, such as a space.
(Not to be confused with [\b].)
For example, /\bn\w/ matches
the 'no' in "noonday";/\wy\b/ matches
the 'ly' in "possibly yesterday."
|
|
\B
|
Matches a non-word boundary.
For example, /\w\Bn/ matches
'on' in "noonday", and /y\B\w/ matches
'ye' in "possibly yesterday."
|
|
\cX
|
Where X is a letter from A - Z.
Matches a control character in a string.
For example, /\cM/ matches
control-M in a string.
|
|
\d
|
Matches a digit character. Equivalent to
[0-9].
For example, /\d/ or
/[0-9]/ matches
'2' in "B2 is the suite number."
|
|
\D
|
Matches any non-digit character.
Equivalent to [^0-9].
For example, /\D/ or
/[^0-9]/ matches
'B' in "B2 is the suite number."
|
|
\f
|
Matches a form-feed.
|
|
\n
|
Matches a linefeed.
|
|
\r
|
Matches a carriage return.
|
|
\s
|
Matches a single white space character,
including space, tab, form feed, line feed. Equivalent to
[
\f\n\r\t\u00A0\u2028\u2029].
For example, /\s\w*/ matches '
bar' in "foo bar."
|
|
\S
|
Matches a single character other than
white space. Equivalent to
[^
\f\n\r\t\u00A0\u2028\u2029].
For example, /\S/\w* matches
'foo' in "foo bar."
|
|
\t
|
Matches a tab.
|
|
\v
|
Matches a vertical tab.
|
|
\w
|
Matches any alphanumeric character
including the underscore. Equivalent to [A-Za-z0-9_].
For example, /\w/ matches 'a'
in "apple," '5' in "$5.28," and '3' in "3D."
|
|
\W
|
Matches any non-word character. Equivalent
to [^A-Za-z0-9_].
For example, /\W/ or
/[^$A-Za-z0-9_]/
matches '%' in "50%."
|
|
\n
|
Where n is a positive integer. A
back reference to the last substring matching the n
parenthetical in the regular expression (counting left
parentheses).
For example, /apple(,)\sorange\1/
matches 'apple, orange', in "apple, orange, cherry, peach." A
more complete example follows this table.
|
|
\0
|
Matches a NUL character. Do not follow
this with another digit.
|
|
\xhh
|
Matches the character with the code hh
(two hexadecimal digits)
|
|
\uhhhh
|
Matches the character with code hhhh (four
hexadecimal digits).
|
The
literal notation provides compilation of the regular expression when
the expression is evaluated. Use literal notation when the regular
expression will remain constant. For example, if you use literal
notation to construct a regular expression used in a loop, the
regular expression won't be recompiled on each iteration.
The
constructor of the regular expression object, for example,
new RegExp("ab+c"),
provides runtime compilation of the regular expression. Use the
constructor function when you know the regular expression
pattern will be changing, or you don't know the pattern and are
getting it from another source, such as user input.
A
separate predefined RegExp object is
available in each window; that is, each separate thread of JavaScript
execution gets its own RegExp object. Because
each script runs to completion without interruption in a thread, this
assures that different scripts do not overwrite values of the
RegExp
object.
Property Summary
Note
that several of the RegExp properties have
both long and short (Perl-like) names. Both names always refer to the
same value. Perl is the programming language from which JavaScript
modeled its regular expressions.
|
Property
|
Description
|
|
constructor
|
Specifies the function that creates an
object's prototype.
|
|
global
|
Whether to test the regular expression
against all possible matches in a string, or only against the
first. As of JavaScript 1.5, a property of a RegExp instance,
not the RegExp object.
|
|
ignoreCase
|
Whether to ignore case while attempting a
match in a string. As of JavaScript 1.5, a property of a RegExp
instance, not the RegExp object.
|
|
lastIndex
|
The index at which to start the next
match. As of JavaScript 1.5, a property of a RegExp instance,
not the RegExp object.
|
|
multiline
|
Whether or not to search in strings across
multiple lines. As of JavaScript 1.5, a property of a RegExp
instance, not the RegExp object.
|
|
prototype
|
Allows the addition of properties to all
objects.
|
|
source
|
The text of the pattern. As of JavaScript
1.5, a property of a RegExp instance, not the RegExp object.
|
Method Summary
|
Method
|
Description
|
|
exec
|
Executes a search for a match in its
string parameter.
|
|
test
|
Tests for a match in its string parameter.
|
|
toSource
|
Returns an object literal representing the
specified object; you can use this value to create a new
object. Overrides the Object.toSource method.
|
|
toString
|
Returns a string representing the
specified object. Overrides the Object.toString method.
|
In
addition, this object inherits the watch and unwatch methods from Object.
Examples
Example 1. The following script uses the
replace
method to switch the words in the string. In the replacement text,
the script uses "$1" and "$2" to indicate the results of the
corresponding matching parentheses in the regular expression pattern.
<SCRIPT>
re = /(\w+)\s(\w+)/;
str = "John Smith";
newstr=str.replace(re, "$2, $1");
document.write(newstr)
</SCRIPT>
This
displays "Smith, John".
Example 2. In the following example,
RegExp.input
is set by the Change event. In the getInfo function, the
exec method
uses the value of RegExp.input as its
argument.
<HTML>
<SCRIPT>
function getInfo() {
re = /(\w+)\s(\d+)/;
var m = re.exec();
window.alert(m[] + ", your age is " + m[2]);
}
</SCRIPT>
Enter your first name and your age, and then
press Enter.
<FORM>
<INPUT TYPE:"TEXT" NAME="NameAge"
onChange="getInfo(this);">
</FORM>
</HTML>
constructor
Specifies the function that creates an object's
prototype. Note that the value of this property is a reference to the
function itself, not a string containing the function's
name.
|
Property of
|
RegExp
|
|
Implemented in
|
JavaScript 1.1, NES 2.0
|
|
ECMA version
|
ECMA-262
|
Description
See
Object.constructor.
exec
Executes
the search for a match in a specified string. Returns a result
array.
|
Method of
|
RegExp
|
|
Implemented in
|
JavaScript 1.2, NES 3.0
|
|
ECMA version
|
ECMA 262, Edition 3 (first syntax only)
|
Syntax
regexp.exec([str])
regexp([str])
Parameters
|
regexp
|
The
name of the regular expression. It can be a variable name or a
literal.
|
|
str
|
The string against which to match the
regular expression.
|
Description
As shown
in the syntax description, a regular expression's exec method can be
called either directly, (with regexp.exec(str)) or
indirectly (with regexp(str)).
If you
are executing a match simply to find true or
false,
use the test method or the
String
search method.
If the
match succeeds, the exec method returns an
array and updates properties of the regular expression object. If the
match fails, the exec method returns
null.
Consider
the following example:
<SCRIPT LANGUAGE="JavaScript1.2">
//Match one d followed by one or more b's followed by one d
//Remember matched b's and the following d
//Ignore case
myRe=/d(b+)(d)/ig;
myArray = myRe.exec("cdbBdbsbz");
</SCRIPT>
The
following table shows the results for this script:
|
Object
|
Property/Index
|
Description
|
Example
|
|
myArray
|
|
The contents of myArray.
|
["dbBd",
"bB", "d"]
|
|
index
|
The 0-based index of the match in the
string.
|
1
|
|
input
|
The original string.
|
cdbBdbsbz
|
|
[0]
|
The last matched characters.
|
dbBd
|
|
[1], ...[n]
|
The parenthesized substring matches, if
any. The number of possible parenthesized substrings is
unlimited.
|
[1] = bB
[2] = d
|
|
myRe
|
lastIndex
|
The index at which to start the next
match.
|
5
|
|
ignoreCase
|
Indicates if the "i" flag was used
to ignore case.
|
true
|
|
global
|
Indicates if the "g" flag was used
for a global match.
|
true
|
|
multiline
|
Indicates if the "m" flag was used
for a global match.
|
false
|
|
source
|
The text of the pattern.
|
d(b+)(d)
|
If your
regular expression uses the "g" flag, you can use
the exec
method multiple times to find successive matches in the same string.
When you do so, the search starts at the substring of
str
specified by the regular expression's lastIndex
property. For example, assume you have this script:
<SCRIPT LANGUAGE="JavaScript1.2">
myRe=/ab*/g;
str = "abbcdefabh";
myArray = myRe.exec(str);
document.writeln("Found " + myArray[0] +
". Next match starts at " + myRe.lastIndex)
mySecondArray = myRe.exec(str);
document.writeln("Found " + mySecondArray[0] +
". Next match starts at " + myRe.lastIndex)
</SCRIPT>
This
script displays the following text:
Found
abb. Next
match starts at 3
Found ab. Next match starts at 9
Examples
In the
following example, the user enters a name and the script executes a
match against the input. It then cycles through the array to see if
other names match the user's name.
This
script assumes that first names of registered party attendees are
preloaded into the array A, perhaps by gathering them from a party
database.
<HTML>
<SCRIPT LANGUAGE="JavaScript1.2">
A = ["Frank", "Emily", "Jane", "Harry", "Nick", "Beth", "Rick",
"Terrence", "Carol", "Ann",
"Terry", "Frank", "Alice", "Rick",
"Bill", "Tom", "Fiona", "Jane",
"William", "Joan", "Beth"]
function lookup() {
firstName = /\w+/i();
if (!firstName)
window.alert (RegExp.input + "
isn't a name!");
else {
count = 0;
for (i=0; i<A.length;
i++)
if
(firstName[0].toLowerCase() == A[i].toLowerCase()) count++;
if (count ==1)
midstring = "
other has ";
else
midstring = "
others have ";
window.alert ("Thanks, " + count
+ midstring + "the same name!")
}
}
</SCRIPT>
Enter your first name and then press Enter.
<FORM> <INPUT TYPE:"TEXT"
NAME="FirstName" onChange="lookup(this);"> </ FORM>
</HTML>
global
Whether
or not the "g" flag is used with
the regular expression.
|
Property of
|
RegExp
instances
|
|
Read-only
|
|
Implemented in
|
JavaScript 1.2, NES 3.0
|
|
ECMA version
|
ECMA 262, Edition 3
|
Description
global is a
property of an individual regular expression object.
The
value of global is
true
if the "g" flag was
used; otherwise, false. The
"g"
flag indicates that the regular expression should be tested
against all possible matches in a string.
You
cannot change this property directly.
ignoreCase
Whether
or not the "i" flag is used with
the regular expression.
|
Property of
|
RegExp
instances
|
|
Read-only
|
|
Implemented in
|
JavaScript 1.2, NES 3.0
|
|
ECMA version
|
ECMA 262, Edition 3
|
Description
ignoreCase
is a property of an individual regular expression object.
The
value of ignoreCase is
true if the
"i" flag was
used; otherwise, false. The
"i"
flag indicates that case should be ignored while attempting a
match in a string.
You
cannot change this property directly.
lastIndex
A
read/write integer property that specifies the index at which to
start the next match.
|
Property of
|
RegExp
instances
|
|
Implemented in
|
JavaScript 1.2, NES 3.0
|
|
ECMA version
|
ECMA 262, Edition 3
|
Description
lastIndex is
a property of an individual regular expression object.
This
property is set only if the regular expression used the
"g"
flag to indicate a global search. The following rules apply:
-
-
If lastIndex is greater
than the length of the string, regexp.test and
regexp.exec fail, and
lastIndex
is set to 0.
-
If lastIndex is equal to
the length of the string and if the regular expression matches the
empty string, then the regular expression matches input starting at
lastIndex
.
-
If lastIndex is equal to
the length of the string and if the regular expression does not
match the empty string, then the regular expression mismatches
input, and lastIndex is reset to
0.
-
Otherwise, lastIndex is set to
the next position following the most recent match.
For
example, consider the following sequence of statements:
|
re = /(hi)?/g
|
Matches the empty string.
|
|
re("hi")
|
Returns ["hi", "hi"] with
lastIndex equal
to 2.
|
|
re("hi")
|
Returns [""], an empty
array whose zeroth element is the match string. In this case,
the empty string because lastIndex was 2
(and still is 2) and "hi" has length
2.
|
multiline
Reflects
whether or not to search in strings across multiple lines.
|
Property of
|
RegExp
instances
|
|
Static
|
|
Implemented in
|
JavaScript 1.2, NES 3.0
|
|
ECMA version
|
ECMA 262, Edition 3
|
Description
multiline is
a property of an individual regular expression object..
The
value of multiline is
true
if the "m" flag was
used; otherwise, false. The
"m"
flag indicates that a multiline input string should be treated
as multiple lines. For example, if "m" is used,
"^"
and "$" change from
matching at only the start or end of the entire string to the
start or end of any line within the string.
You
cannot change this property directly.
prototype
Represents the prototype for this class. You can
use the prototype to add properties or methods to all instances of a
class. For information on prototypes, see Function.prototype.
|
Property of
|
RegExp
|
|
Implemented in
|
JavaScript 1.1, NES 2.0
|
|
ECMA version
|
ECMA-262
|
source
A
read-only property that contains the text of the pattern, excluding
the forward slashes.
|
Property of
|
RegExp
instances
|
|
Read-only
|
|
Implemented in
|
JavaScript 1.2, NES 3.0
|
|
ECMA version
|
ECMA 262, Edition 3
|
Description
source is a
property of an individual regular expression object.
You
cannot change this property directly.
test
Executes
the search for a match between a regular expression and a specified
string. Returns true or
false.
|
Method of
|
RegExp
|
|
Implemented in
|
JavaScript 1.2, NES 3.0
|
|
ECMA version
|
ECMA 262, Edition 3
|
Syntax
regexp.test([str])
Parameters
|
regexp
|
The
name of the regular expression. It can be a variable name or a
literal.
|
|
str
|
The string against which to match the
regular expression.
|
Description
When you
want to know whether a pattern is found in a string use the
test method
(similar to the String.search
method); for more information (but slower execution) use the
exec method (similar to the
String.match method).
Example
The
following example prints a message which depends on the success of
the test:
function testinput(re, str){
if (re.test(str))
midstring = " contains ";
else
midstring = " does not contain
";
document.write (str + midstring + re.source);
}
toSource
Returns
a string representing the source code of the object.
|
Method of
|
RegExp
|
|
Implemented in
|
JavaScript 1.3
|
Syntax
toSource()
Parameters
None
Description
The
toSource
method returns the following values:
This
method is usually called internally by JavaScript and not explicitly in
code.
See also
Object.toSource
toString
Returns
a string representing the specified object.
|
Method of
|
RegExp
|
|
Implemented in
|
JavaScript 1.1, NES 2.0
|
|
ECMA version
|
ECMA 262, Edition 3
|
Syntax
toString()
Parameters
None.
Description
The
RegExp object overrides the
toString
method of the Object object; it
does not inherit Object.toString.
For RegExp objects, the
toString
method returns a string representation of the object.
Examples
The
following example displays the string value of a RegExp object:
myExp = new RegExp("a+b+c");
alert(myExp.toString()) displays
"/a+b+c/"
See also
Object.toString
