regular expression | NN 4 IE 4 ECMA 3
A regular expression object is an instance of the RegExp object. Each regular expression object consists of a pattern that is used to locate matches within a string. Patterns for a regular expression can be simple strings or significantly more powerful expressions that use a notation that is essentially a language unto itself. The implementation of regular expressions in JavaScript 1.2 is very similar to the way they are implemented in Perl. You can read more about these concepts in books covering JavaScript 1.2 or later.
To create a regular expression object, surround the pattern with forward slashes, and assign the whole expression to a variable. For example, the following statement creates a regular expression with a pattern that is a simple word:
The re variable can then be used as a parameter in a variety of methods that search for the pattern within some string (you may also use an expression directly as a method parameter, rather than assigning it to a variable).
Regular expression notation also consists of a number of metacharacters that stand in for sometimes complex ideas, such as the boundary on either side of a word, any numeral, or one or more characters. For example, to search for the pattern of characters shown above but only when the pattern is a word (and not part of a word such as greetings), the regular expression notation uses the metacharacters to indicate that the pattern includes word boundaries on both sides of the pattern:
The following table shows a summary of the regular expression notation used in JavaScript 1.2.
When you create a regular expression, you may optionally wire the expression to work globally (as you probably do if the regular expression is doing a search-and-replace operation with a method, and your goal is a "replace all" result) and to ignore case in its matches. The modifiers that turn on these switches are the letters g and i. They may be used by themselves or together as gi.
Once you have established a pattern with the regular expression notation, all the action takes place in the regular expression object methods and the String object methods that accept regular expression parameters.
Character | Matches | Example
--- | --- | ---
\b | Word boundary | /\bto/ matches "tomorrow"/to\b/ matches "Soweto"
\B | Word nonboundary | /\Bto/ matches "stool" and "Soweto"/to\B/ matches "stool" and "tomorrow"
\d | Numeral 0 through 9 | /\d\d/ matches "42"
\D | Nonnumeral | /\D\D/ matches "to"
\s | Single whitespace | /under\sdog/ matches "under dog"
\S | Single nonwhitespace | /under\Sdog/ matches "under-dog"
\w | Letter, numeral, or underscore | /1\w/ matches "1A"
\W | Not a letter, numeral, or underscore | /1\W/ matches "1%"
. | Any character except a newline | /../ matches "Z3"
[...] | Any one of the character set in brackets | /J[aeiou]y/ matches "Joy"
[^...] | Negated character set | /J[^eiou]y/ matches "Jay"
* | Zero or more times | /\d*/ matches "", "5", or "444"
? | Zero or one time | /\d?/ matches "" or "5"
+ | One or more times | /\d+/ matches "5" or "444"
{n} | Exactly n times | /\d{2}/ matches "55"
{n,} | n or more times | /\d{2,}/ matches "555"
{n,m} | At least n, at most m times | /\d{2,4}/ matches "5555"
^ | At beginning of a string or line | /^Sally/ matches "Sally says..."
$ | At end of a string or line | /Sally.$/ matches "Hi, Sally."
Properties
constructor | global | ignoreCase | lastIndex | source
Methods
compile( ) | exec( ) | test( )
Creating a regular expression Object
    var regExpressionObj = /pattern/ [g | i | gi];
    var regExpressionObj = new RegExp(["pattern", ["g" | "i" | "gi"]]);

constructor | NN 4 IE 4 ECMA 3
| Read/Write
See this property for the Array object.

global, ignoreCase | NN 4 IE 5(Mac)/5.5(Win) ECMA 3
| Read-only
Returns Boolean true if the regular expression object instance had the g or i modifiers (respectively) set when it was created. If a regular expression object has both modifiers set (gi), you must still test for each property individually.
Example
    if (myRE.global && myRE.ignoreCase) {
        ...
    }
Value
Boolean value: true | false.

lastIndex | NN 4 IE 4 ECMA 3
| Read/Write
This is the zero-based index value of the character within the string where the next search for the pattern begins. In a new search, the value is zero. You can also set the value manually if you wish to start at a different location or skip some characters.
Example
    myRE.lastIndex = 30;
Value
Integer.

source | NN 4 IE 4 ECMA 3
| Read-only
Returns a string version of the characters used to create the regular expression. The value does not include the forward slash delimiters that surround the expression.
Example
    var myREasString = myRE.source;
Value
String.

compile( ) | NN 4 IE 4 ECMA n/a
compile("pattern"[, "g" | "i" | "gi"]) |
Compiles a regular expression pattern into a genuine regular expression object. This method is used primarily to recompile a regular expression with a pattern that may change during the execution of a script.
Parameters
Any regular expression pattern as a quoted string. Modifiers for global, ignore case, or both must be supplied as a separate quoted parameter.
Returned Value
Reference to a regular expression instance.

exec( ) | NN 4 IE 4 ECMA 3
exec(string) |
Performs a search through the string passed as a parameter for the current regular expression pattern. A typical sequence follows the format:
Properties of both the static RegExp and regular expression instance (myRE in the example) objects are updated with information about the results of the search. In addition, the exec( ) method returns an array of data, much of it similar to RegExp object properties. The returned array includes the following properties:
You can stow away the results of the exec( ) method in a variable, whereas the RegExp property values change with the next regular expression operation. If the regular expression is set for global searching, a subsequent call to myRE.exec("someString") continues the search from the position of the previous match.
If no match is found for a given call to exec( ), it returns null.
| Zero-based index of starting character in the string that matches the pattern
| The original string being searched
| String of the characters matching the pattern
| Strings of the results of the parenthesized component matches
Parameters
The string to be searched.
Returned Value
An array of match information if successful; null if there is no match.

test( ) | NN 4 IE 4 ECMA 3
test(string) |
Returns Boolean true if there is a match of the regular expression anywhere in the string passed as a parameter, false if not. No additional information is available about the results of the search. This is the fastest way to find out if a string contains a match for a pattern.
Parameters
The string to be searched.
Returned Value
Boolean value: true | false.