RegExp constructor
function, the predefined RegExp object has static properties that
are set whenever any regular expression is used.
|
JavaScript 1.3: added | |
RegExp constructor function.
The literal format is used as follows:
/pattern/flagsThe constructor function is used as follows:
new RegExp("pattern"[, "flags"])
pattern | |
flags |
/ab+c/i
new RegExp("ab+c", "i")
re = new RegExp("\\w+")
re = /\w+/The following table provides a complete list and description of the
special characters that can be used in regular expressions.
Table 1.3 Special characters in regular expressions.
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. Once you have a defined
regular expression, and if the regular expression is used throughout the script
and may change, you can use the compile
method to compile a new regular expression for efficient reuse.
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.
The predefined RegExp object contains the
static properties input,
multiline,
lastMatch,
lastParen,
leftContext,
rightContext,
and $1 through $9. The input
and multiline
properties can be preset. The values for the other static properties are set
after execution of the exec
and test
methods of an individual regular expression object, and after execution of the
match
and replace
methods of String.
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.
watch
and unwatch
methods from Object.
replace method to switch the words in the string. For the
replacement text, the script uses the values of the $1 and
$2 properties of the global RegExp object. Note
that the RegExp object name is not be prepended to the
$ properties when they are passed as the second argument to the
replace method.
<SCRIPT LANGUAGE="JavaScript1.2">This displays "Smith, John". Example 2. In the following example,
re = /(\w+)\s(\w+)/;
str = "John Smith";
newstr=str.replace(re, "$2, $1");
document.write(newstr)
</SCRIPT>
RegExp.input is set by the Change event. In the
getInfo function, the exec method uses the value of
RegExp.input as its argument. Note that RegExp is
prepended to the $ properties.
<HTML>
<SCRIPT LANGUAGE="JavaScript1.2">
function getInfo() {
re = /(\w+)\s(\d+)/;
re.exec();
window.alert(RegExp.$1 + ", your age is " + RegExp.$2);
}
</SCRIPT>
Enter your first name and your age, and then press Enter.
<FORM>
<INPUT TYPE:"TEXT" NAME="NameAge" onChange="getInfo(this);">
</FORM>
</HTML>
input is static, it is not a property of an
individual regular expression object. Instead, you always use it as
RegExp.input.
The number of possible parenthesized substrings is
unlimited, but the predefined RegExp object can only hold the last
nine. You can access all parenthesized substrings through the returned array's
indexes.
These properties can be used in the replacement text for
the String.replace
method. When used this way, do not prepend them with RegExp. The
example below illustrates this. When parentheses are not included in the regular
expression, the script interprets $n's literally (where
n is a positive integer).
replace method to switch the words in the
string. For the replacement text, the script uses the values of the
$1 and $2 properties of the global
RegExp object. Note that the RegExp object name is not
be prepended to the $ properties when they are passed as the second
argument to the replace method.
<SCRIPT LANGUAGE="JavaScript1.2">This displays "Smith, John".
re = /(\w+)\s(\w+)/;
str = "John Smith";
newstr=str.replace(re, "$2, $1");
document.write(newstr)
</SCRIPT>
input.
multiline.
lastMatch.
lastParen.
leftContext.
rightContext.
regexp.compile(pattern[, flags])
regexp |
|
pattern | |
flags |
compile method to compile a regular expression created with the
RegExp constructor function. This forces compilation of the regular
expression once only which means the regular expression isn't compiled each time
it is encountered. Use the compile method when you know the regular
expression will remain constant (after getting its pattern) and will be used
repeatedly throughout the script.
You can also use the compile method to
change the regular expression during execution. For example, if the regular
expression changes, you can use the compile method to recompile the
object for more efficient repeated use.
Calling this method changes the value of the regular
expression's source,
global,
and ignoreCase
properties.
Object.constructor.
regexp.exec([str])
regexp([str])
regexp |
|
str |
The string against which to match the regular
expression. If omitted, the value of |
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 and the
predefined regular expression object, RegExp. If the match fails,
the exec method returns null.
Consider the following example:
<SCRIPT LANGUAGE="JavaScript1.2">The following table shows the results for this script:
//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>
| Object | Property/Index | Description | Example |
|---|---|---|---|
myArray | |||
index | |||
input | |||
[0] | |||
[1], ...[n] | |||
myRe | lastIndex | ||
ignoreCase | |||
global | |||
source | |||
RegExp | lastMatch | ||
leftContext | |||
rightContext | |||
$1, ...$9 | |||
lastParen |
"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">This script displays the following text: Found
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>
abb. Next match starts at 3<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>
"g" flag is used with the regular
expression.
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. However,
calling the compile
method changes the value of this property.
"i" flag is used with the regular
expression.
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. However,
calling the compile
method changes the value of this property.
$_ is another
name for the same property.
input is static, it is not a property of an
individual regular expression object. Instead, you always use it as
RegExp.input.
If no string argument is provided to a regular
expression's exec or test methods, and if
RegExp.input has a value, its value is used as the argument to that
method.
The script or the browser can preset the
input property. If preset and if no string argument is explicitly
provided, the value of input is used as the string argument to the
exec or test methods of the regular expression object.
input is set by the browser in the following cases:
TEXT
form element, input is set to the value of the contained text.
TEXTAREA form element, input is set to the value of
the contained text. Note that multiline is also set to
true so that the match can be executed over the multiple lines of
text.
SELECT
form element, input is set to the value of the selected text.
Link
object, input is set to the value of the text between <A
HREF=...> and </A>. input property is cleared after the
event handler completes.
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:
lastIndex is greater than the length of
the string, regexp.test and regexp.exec fail, and
lastIndex is set to 0.
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.
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.
lastIndex is set to the next
position following the most recent match.
re = /(hi)?/g | |
re("hi") | |
re("hi") |
$& is another name for the same
property.
lastMatch is static, it is not a property of
an individual regular expression object. Instead, you always use it as
RegExp.lastMatch.
$+ is another name for
the same property.
lastParen is static, it is not a property of
an individual regular expression object. Instead, you always use it as
RegExp.lastParen.
$` is
another name for the same property.
leftContext is static, it is not a property of
an individual regular expression object. Instead, you always use it as
RegExp.leftContext.
multiline is static, it is not a property of
an individual regular expression object. Instead, you always use it as
RegExp.multiline.
The value of multiline is true
if multiple lines are searched, false if searches must stop at line
breaks.
The script or the browser can preset the
multiline property. When an event handler is called for a
TEXTAREA form element, the browser sets multiline to
true. multiline is cleared after the event handler
completes. This means that, if you've preset multiline to true, it
is reset to false after the execution of any event handler.
Function.prototype.
$' is
another name for the same property.
rightContext is static, it is not a property
of an individual regular expression object. Instead, you always use it as
RegExp.rightContext.
"g" or "i" flags.
source is a property of an individual regular
expression object.
You cannot change this property directly. However,
calling the compile
method changes the value of this property.
true or false.
regexp.test([str])
regexp |
|
str |
The string against which to match the regular
expression. If omitted, the value of |
test method (similar to the String.search
method); for more information (but slower execution) use the exec
method (similar to the String.match
method).
function testinput(re, str){
if (re.test(str))
midstring = " contains ";
else
midstring = " does not contain ";
document.write (str + midstring + re.source);
}
toSource()
toSource method returns the following values:
RegExp object,
toSource returns the following string indicating that the source
code is not available: function Boolean() {
[native code]
}
RegExp,
toSource returns a string representing the source code.
Object.toSource
toString()
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.
myExp = new RegExp("a+b+c");
alert(myExp.toString()) displays "/a+b+c/"
Object.toString
valueOf()
valueOf method of RegExp
returns the primitive value of a RegExp object as a string data type. This value
is equivalent to RegExp.toString.
This method is usually called internally by JavaScript
and not explicitly in code.
myExp = new RegExp("a+b+c");
alert(myExp.valueOf()) displays "/a+b+c/"
RegExp.toString,
Object.valueOf
Last Updated: 05/28/99 12:00:15