| Character |
Description |
| \ |
Marks the next character as a special character, a literal, a backreference, or an octal escape. For example, "n" matches the character "n". "\n" matches a newline. The sequence "\\" matches "\" and "\(" matches "(". |
| ^ |
Matches the position at the start of the input string. If the RegExp object's Multiline property is set, ^ also matches positions after "\n" or "\r". |
| $ |
Matches the position at the end of the input string. If the RegExp object's Multiline property is set, $ also matches positions before "\n" or "\r". |
| * |
Matches the preceding subexpression zero or more times. For example, zo* matches "z" and "zoo". * is equivalent to {0,}. |
| + |
Matches the preceding subexpression one or more times. For example, "zo+" matches "zo" and "zoo", but not "z". + is equivalent to {1,}. |
| ? |
Matches the preceding subexpression zero or one time. For example, "do(es)?" can match the "do" in "do" or "does". ? is equivalent to {0,1}. |
| {n} |
n is a non-negative integer. Matches exactly n times. For example, "o{2}" does not match the "o" in "Bob" but matches the two o's in "food". |
| {n,} |
n is a non-negative integer. Matches at least n times. For example, "o{2,}" does not match the "o" in "Bob" but matches all o's in "foooood". "o{1,}" is equivalent to "o+". "o{0,}" is equivalent to "o*". |
| {n,m} |
m and n are non-negative integers, where n <= m. Matches at least n and at most m times. For example, "o{1,3}" matches the first three o's in "fooooood". "o{0,1}" is equivalent to "o?". Note that there cannot be a space between the comma and the numbers. |
| ? |
When this character follows any of the other quantifiers (*, +, ?, {n}, {n,}, {n,m}), the matching behavior is non-greedy. The non-greedy mode matches as few characters as possible, whereas the default greedy mode matches as many characters as possible. For example, with the string "oooo", "o+?" will match a single "o", whereas "o+" will match all "o"s. |
| . |
Matches any single character except "\n". To match any character including "\n", use a pattern like "[.\n]". |
| (pattern) |
Matches pattern and captures the match. The captured match can be obtained from the resulting Matches collection, in VBScript use the SubMatches collection, and in JScript use the $0…$9 properties. To match parenthesis characters, use "\(" or "\)". |
| (?:pattern) |
Matches pattern but does not capture the match, meaning it is a non-capturing match that is not stored for later use. This is useful when using the alternation character “(|)” to combine parts of a pattern. For example, “industr(?:y|ies)” is a more concise expression than “industry|industries”. |
| (?=pattern) |
Positive lookahead, matches the search string at any position where a string matching pattern begins. This is a non-capturing match, meaning the match is not needed for later use. For example, “Windows(?=95|98|NT|2000)” matches “Windows” in “Windows2000” but not in “Windows3.1”. Lookaheads do not consume characters, meaning after a match occurs, the search for the next match begins immediately after the last match, not after the character containing the lookahead. |
| (?!pattern) |
Negative lookahead, matches the search string at any position where a string not matching pattern begins. This is a non-capturing match, meaning the match is not needed for later use. For example, “Windows(?!95|98|NT|2000)” matches “Windows” in “Windows3.1” but not in “Windows2000”. Lookaheads do not consume characters, meaning after a match occurs, the search for the next match begins immediately after the last match, not after the character containing the lookahead. |
| x|y |
Matches x or y. For example, “z|food” matches “z” or “food”. “(z|f)ood” matches “zood” or “food”. |
| [xyz] |
Character class. Matches any one of the enclosed characters. For example, “[abc]” matches “a” in “plain”. |
| [^xyz] |
Negated character class. Matches any character not enclosed. For example, “[^abc]” matches “p” in “plain”. |
| [a-z] |
Character range. Matches any character within the specified range. For example, “[a-z]” matches any lowercase letter from “a” to “z”. |
| [^a-z] |
Negated character range. Matches any character not within the specified range. For example, “[^a-z]” matches any character not from “a” to “z”. |
| \b |
Matches a word boundary, which is the position between a word and a space. For example, “er\b” matches “er” in “never” but not in “verb”. |
| \B |
Matches a non-word boundary. “er\B” matches “er” in “verb” but not in “never”. |
| \cx |
Matches a control character indicated by x. For example, \cM matches a Control-M or carriage return. The value of x must be A-Z or a-z. Otherwise, c is treated as a literal “c” character. |
| \d |
Matches a digit character. Equivalent to [0-9]. |
| \D |
Matches a non-digit character. Equivalent to [^0-9]. |
| \f |
Matches a form feed. Equivalent to \x0c and \cL. |
| \n |
Matches a newline character. Equivalent to \x0a and \cJ. |
| \r |
Matches a carriage return. Equivalent to \x0d and \cM. |
| \s |
Matches any whitespace character, including space, tab, form feed, etc. Equivalent to [\f\n\r\t\v]. |
| \S |
Matches any non-whitespace character. Equivalent to [^\f\n\r\t\v]. |
| \t |
Matches a tab character. Equivalent to \x09 and \cI. |
| \v |
Matches a vertical tab character. Equivalent to \x0b and \cK. |
| \w |
Matches any word character including underscore. Equivalent to “[A-Za-z0-9_]”. |
| \W |
Matches any non-word character. Equivalent to “[^A-Za-z0-9_]”. |
| \xn |
Matches n, where n is a hexadecimal escape value. The hexadecimal escape value must be exactly two digits long. For example, “\x41” matches “A”. “\x041” is equivalent to “\x04&1”. ASCII codes can be used in regular expressions. |
| \num |
Matches num, where num is a positive integer. This is a reference to a previously captured match. For example, “(.)\1” matches two consecutive identical characters. |
| \n |
Denotes an octal escape value or a backreference. If \n is preceded by at least n captured subexpressions, then n is a backreference. Otherwise, if n is an octal digit (0-7), then n is an octal escape value. |
| \nm |
Denotes an octal escape value or a backreference. If \nm is preceded by at least nm captured subexpressions, then nm is a backreference. If \nm is preceded by at least n captures, then n is a backreference followed by the literal m. If neither of the previous conditions is met, and if n and m are octal digits (0-7), then \nm matches the octal escape value nm. |
| \nml |
If n is an octal digit (0-3) and m and l are octal digits (0-7), then matches the octal escape value nml. |
| \un |
Matches n, where n is a Unicode character represented by four hexadecimal digits. For example, \u00A9 matches the copyright symbol (©). |