Table 4.3
Results of regular expression execution.
|
Object
|
Property or index
|
Description
|
In this example
|
|
myArray
|
|
The matched string and all remembered
substrings.
|
["dbbd",
"bb"]
|
|
index
|
The 0-based index of the match in the
input string.
|
1
|
|
input
|
The original string.
|
"cdbbdbsbz"
|
|
[0]
|
The last matched characters.
|
"dbbd"
|
|
myRe
|
lastIndex
|
The index at which to start the next
match. (This property is set only if the regular expression
uses the g option,
described in Executing a
Global Search, Ignoring Case, and Considering Multiline
Input.)
|
5
|
|
source
|
The text of the pattern.Updated at the
time that the regular expression is created, not executed.
|
"d(b+)d"
|
As
shown in the second form of this example, you can use the a
regular expression created with an object initializer without
assigning it to a variable. If you do, however, every occurrence
is a new regular expression. For this reason, if you use this
form without assigning it to a variable, you cannot subsequently
access the properties of that regular expression. For example,
assume you have this script:
<SCRIPT LANGUAGE="JavaScript1.2">
myRe=/d(b+)d/g;
myArray = myRe.exec("cdbbdbsbz");
document.writeln("The value of lastIndex is " +
myRe.lastIndex);
</SCRIPT>
This
script displays:
-
-
The value of lastIndex is 5
However, if you have this script:
<SCRIPT LANGUAGE="JavaScript1.2">
myArray = /d(b+)d/g.exec("cdbbdbsbz");
document.writeln("The value of lastIndex is " +
/d(b+)d/g.lastIndex);
</SCRIPT>
It
displays:
-
-
The value of lastIndex is 0
The
occurrences of /d(b+)d/g in the two
statements are different regular expression objects and hence have
different values for their lastIndex property.
If you need to access the properties of a regular expression
created with an object initializer, you should first assign it to a
variable.
Using
Parenthesized Substring Matches
Including parentheses in a regular
expression pattern causes the corresponding submatch to be
remembered. For example, /a(b)c/ matches the
characters 'abc' and remembers 'b'. To recall these parenthesized
substring matches, use the Array elements
[1],
..., [n].
The
number of possible parenthesized substrings is unlimited. The
returned array holds all that were found. The following examples
illustrate how to use parenthesized substring matches.
Example 1.
The
following script uses the replace method to
switch the words in the string. For the replacement text, the
script uses the $1 and
$2
in the replacement to denote the first string and second
parenthesized substring match.
<SCRIPT LANGUAGE="JavaScript1.2">
re = /(\w+)\s(\w+)/;
str = "John Smith";
newstr = str.replace(re, "$2, $1");
document.write(newstr)
</SCRIPT>
This
prints "Smith, John".
Example 2.
In
the following example, RegExp.input is set
by the Change event. In the getInfo function,
the exec
method, called using the () shortcut notation, uses the value of
RegExp.input as its
argument.
<HTML>
<SCRIPT LANGUAGE="JavaScript1.2">
function getInfo(){
a = /(\w+)\s(\d+)/();
window.alert(a[1] + ", your age is " +
a[2]);
}
</SCRIPT>
Enter your first name and your age, and then
press Enter.
<FORM>
<INPUT TYPE="text" NAME="NameAge"
onChange="getInfo(this);">
</FORM>
</HTML>
Executing a Global Search, Ignoring Case, and
Considering Multiline Input
Regular expressions have three optional
flags that allow for global and case insensitive searching. To
indicate a global search, use the g flag. To indicate
a case-insensitive search, use the i flag. To indicate
a multi-line search, use the m flag. These flags
can be used separately or together in any order, and are included
as part of the regular expression.
To
include a flag with the regular expression, use this syntax:
re = /pattern/flags
re = new RegExp("pattern", ["flags"])
Note
that the flags are an integral part of a regular expression. They
cannot be added or removed later.
For
example, re = /\w+\s/g
creates a regular expression that looks for one or more
characters followed by a space, and it looks for this combination
throughout the string.
<SCRIPT LANGUAGE="JavaScript1.2">
re = /\w+\s/g;
str = "fee fi fo fum";
myArray = str.match(re);
document.write(myArray);
</SCRIPT>
This
displays ["fee ", "fi ", "fo "]. In this example, you could
replace the line:
re = /\w+\s/g;
with:
re = new RegExp("\\w+\\s", "g");
and
get the same result.
The
m flag
is used to specify that a multiline input string should be
treated as multiple lines. If the m flag is used,
^ and
$ match
at the start or end of any line within the input string instead
of the start or end of the entire string.
Examples
The
following examples show some uses of regular expressions.
Changing
the Order in an Input String
The
following example illustrates the formation of regular
expressions and the use of string.split() and
string.replace().
It cleans a roughly formatted input string containing names
(first name first) separated by blanks, tabs and exactly one
semicolon. Finally, it reverses the name order (last name first)
and sorts the list.
<SCRIPT LANGUAGE="JavaScript1.2">
// The name string contains multiple spaces
and tabs,
// and may have multiple spaces between first and last
names.
names = new String ( "Harry Trump ;Fred Barney; Helen Rigby
;\
Bill Abel ;Chris Hand ")
document.write ("---------- Original String"
+ "<BR>" + "<BR>");
document.write (names + "<BR>" + "<BR>");
// Prepare two regular expression patterns
and array storage.
// Split the string into array elements.
// pattern: possible white space then
semicolon then possible white space
pattern = /\s*;\s*/;
// Break the string into pieces separated by
the pattern above and
// and store the pieces in an array called nameList
nameList = names.split (pattern);
// new pattern: one or more characters then
spaces then characters.
// Use parentheses to "memorize" portions of the pattern.
// The memorized portions are referred to later.
pattern = /(\w+)\s+(\w+)/;
// New array for holding names being
processed.
bySurnameList = new Array;
// Display the name array and populate the
new array
// with comma-separated names, last first.
//
// The replace method removes anything matching the pattern
// and replaces it with the memorized string—second
memorized portion
// followed by comma space followed by first memorized
portion.
//
// The variables $1 and $2 refer to the portions
// memorized while matching the pattern.
document.write ("---------- After Split by
Regular Expression" + "<BR>");
for ( i = 0; i < nameList.length; i++) {
document.write (nameList[i] +
"<BR>");
bySurnameList[i] = nameList[i].replace
(pattern, "$2, $1")
}
// Display the new array.
document.write ("---------- Names Reversed" + "<BR>");
for ( i = 0; i < bySurnameList.length; i++) {
document.write (bySurnameList[i] +
"<BR>")
}
// Sort by last name, then display the sorted
array.
bySurnameList.sort();
document.write ("---------- Sorted" + "<BR>");
for ( i = 0; i < bySurnameList.length; i++) {
document.write (bySurnameList[i] +
"<BR>")
}
document.write ("---------- End" +
"<BR>")
</SCRIPT>
Using
Special Characters to Verify Input
In
the following example, a user enters a phone number. When the
user presses Enter, the script checks the validity of the number.
If the number is valid (matches the character sequence specified
by the regular expression), the script posts a window thanking
the user and confirming the number. If the number is invalid, the
script posts a window informing the user that the phone number is
not valid.
The
regular expression looks for zero or one open parenthesis
\(?,
followed by three digits \d{3}, followed by
zero or one close parenthesis \)?, followed by
one dash, forward slash, or decimal point and when found,
remember the character ([-\/\.]), followed
by three digits \d{3}, followed by
the remembered match of a dash, forward slash, or decimal point
\1,
followed by four digits \d{4}.
The
Change event activated when the user presses Enter sets the value
of RegExp.input.
<HTML>
<SCRIPT LANGUAGE = "JavaScript1.2">
re = /\(?\d{3}\)?([-\/\.])\d{3}\1\d{4}/;
function testInfo() {
OK = re.exec();
if (!OK)
window.alert (RegExp.input
+
" isn't a
phone number with area code!")
else
window.alert ("Thanks, your
phone number is " + OK[0])
}
</SCRIPT>
Enter your phone number (with area code) and
then press Enter.
<FORM>
<INPUT TYPE="text" NAME="Phone"
onChange="testInfo(this);">
</FORM>
</HTML>
Expressions and Operators
Contents