| Character | Description |
| \ | Marks the next character as a special character, literal character, backreference, or octal escape. For example, "n" matches the character "n." "\n" matches a newline. The sequence "\\" matches "\" while "\(" matches "(". |
| ^ | Matches the start of the input string. If the Multiline property of the RegExp object is set, ^ also matches positions after "\n" or "\r". |
| $ | Matches the end of the input string. If the Multiline property of the RegExp object is set, $ also matches positions before "\n" or "\r". |
| * | Matches the preceding subexpression zero or more times. For example, "zo*" can match "z" and "zoo". * is equivalent to {0,}. |
| + | Matches the preceding subexpression one or more times. For example, "zo+" can match "zo" and "zoo", but not "z". + is equivalent to {1,}. |
| ? | Matches the preceding subexpression zero or one time. For example, "do(es)?" can match "do" or "does". ? is equivalent to {0,1}. |
| {n} | n is a non-negative integer. Matches exactly n times. For example, "o{2}" cannot match "o" in "Bob", but can match two o's in "food". |
| {n,} | n is a non-negative integer. Matches at least n times. For example, "o{2,}" cannot match "o" in "Bob", but can match 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 times and at most m times. For example, "o{1,3}" will match the first three o's in "fooooood". "o{0,1}" is equivalent to "o?". Note that there cannot be spaces between the comma and the two numbers. |
| ? | When this character follows any other quantifiers (*,+,?, {n}, {n,}, {n,m}), the pattern is non-greedy. The non-greedy mode matches as little of the search string as possible, while the default greedy mode matches as much as possible. For example, for the string "oooo", "o+?" will match a single "o", while "o+" will match all "o's". |
| . | Matches any single character except for "\n". To match any character including "\n", use a pattern like "[.\n]". |
| (pattern) | Matches pattern and captures the match. The captured match can be accessed from the resulting Matches collection. In VBScript, use the SubMatches collection, and in JScript, use $0…$9 properties. To match parentheses, use "\(” or “\)”. |
| (?:pattern) | Matches pattern but does not capture the match, meaning this is a non-capturing match. This is useful when using the alternation character “|” to combine different parts of a pattern. For example, "industr(?:y|ies)" is a more concise expression than "industry|industries". |
| (?=pattern) | Positive lookahead. Matches a string at the start of the input that matches pattern. This is a non-capturing match and does not require the match to be captured for later use. For example, "Windows(?=95|98|NT|2000)" matches "Windows" in "Windows2000" but not in "Windows3.1". Lookahead does not consume characters, meaning the next search for a match begins immediately after the last match rather than starting from the character after the lookahead. |
| (?!pattern) | Negative lookahead. Matches a string at the start of the input that does not match pattern. This is also a non-capturing match. For example, "Windows(?!95|98|NT|2000)" matches "Windows" in "Windows3.1" but not in "Windows2000". Like lookahead, it does not consume characters. |
| 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 contained characters. For example, "[abc]" can match "a" in "plain". |
| [^xyz] | Negative character class. Matches any character not contained. For example, "[^abc]" can match "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] | Negative character range. Matches any character not within the specified range. For example, "[^a-z]" matches any character not between "a" and "z". |
| \b | Matches a word boundary, i.e., the position between a word and a space. For example, "er\b" can match "er" in "never" but not in "verb". |
| \B | Matches a non-word boundary. "er\B" can match "er" in "verb" but not in "never". |
| \cx | Matches the control character indicated by x. For example, \cM matches a Control-M or carriage return. x must be a value from 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 character. Equivalent to \x0c and \cL. |
| \n | Matches a newline character. Equivalent to \x0a and \cJ. |
| \r | Matches a carriage return character. Equivalent to \x0d and \cM. |
| \s | Matches any whitespace character, including spaces, tabs, form feeds, 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 encoding can be used in regular expressions. |
| \num | Matches num, where num is a positive integer. References the captured match. For example, "(.)\1" matches two consecutive identical characters. |
| \n | Indicates an octal escape value or a backreference. If there are at least n captured subexpressions before n, n is a backreference. Otherwise, if n is an octal digit (0-7), n is an octal escape value. |
| \nm | Indicates an octal escape value or a backreference. If there are at least nm captured subexpressions before nm, nm is a backreference. If there are at least n captures, then n is a backreference followed by the literal m. If neither condition is met, if both n and m are octal digits (0-7), \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), it 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 (©). |