A regular expression is a pattern of text that consists of ordinary characters (for example, letters a through z) and special characters, known as metacharacters. The pattern describes one or more strings to match when searching text. The following table contains the complete list of metacharacters and their behavior in the context of regular expressions (regular expressions syntax):
| Metacharacter | 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 character. The sequence \\ matches \ and \( matches (. |
^ | Matches the position at the beginning of the input string. Also matches the position following \n or \r. |
$ | Matches the position at the end of the input string. Also matches the position preceding \n or \r. |
* | Matches the preceding character or sub-expression zero or more times. For example, zo* matches z and zoo. * is equivalent to {0,}. |
+ | Matches the preceding character or sub-expression one or more times. For example, zo+ matches zo and zoo, but not z. + is equivalent to {1,}. |
? | Matches the preceding character or sub-expression zero or one time. For example, do(es)? matches 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 and matches all the 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 you cannot put a space between the comma and the numbers. |
? | When this character immediately follows any of the other quantifiers (*, +, ?, {n}, {n,}, {n,m}), the matching pattern is non-greedy. A non-greedy pattern matches as little of the searched string as possible, whereas the default greedy pattern matches as much of the searched string as possible. For example, in the string oooo, o+? matches a single o, while o+ matches all os. |
. | Matches any single character. |
(pattern) | A sub-expression that matches pattern and captures the match. To match parentheses characters ( ), use \( or \). |
(?:pattern) | A sub-expression that matches pattern but does not capture the match, that is, it is a non-capturing match that is not stored for possible later use. This is useful for combining parts of a pattern with the “or” character |. For example, industr(?:y|ies) is a more economical expression than industry|industries. |
(?=pattern) | A sub-expression that performs a positive lookahead search, which matches the string at any point where a string matching pattern begins. This is a non-capturing match, that is, the match is not captured for possible later use. For example Windows (?=95|98|NT|2000) matches Windows in Windows 2000 but not Windows in Windows 3.1. Look-aheads do not consume characters, that is, after a match occurs, the search for the next match begins immediately following the last match, not after the characters that comprised the lookahead. |
(?!pattern) | A sub-expression that performs a negative lookahead search, which matches the search string at any point where a string not matching pattern begins. This is a non-capturing match, that is, the match is not captured for possible later use. For example Windows (?!95|98|NT|2000) matches Windows in Windows 3.1 but does not match Windows in Windows 2000. Look-aheads do not consume characters, that is, after a match occurs, the search for the next match begins immediately following the last match, not after the characters that comprised the lookahead. |
(?>pattern) | Independent sub-expression, match pattern and turn off backtracking. |
(?<=pattern) | Positive look-behind assertion, match if after pattern but don't include pattern in the match. (pattern must be constant-width). |
(?<!pattern) | Negative look-behind assertion, match if not after pattern. (pattern must be constant-width). |
(?i:pattern) | Match pattern disregarding case. Allows to temporary turn off case sensitiveness during pattern matching. |
(?$name) | Reference a named regular expression class. A class must be defined in the Regular Expressions Settings, otherwise, the error will be generated. |
x|y | Matches either x or y. For example, z|food matches z or food. (z|f)ood matches zood or food. |
[xyz] | A character set. Matches any one of the enclosed characters. For example, [abc] matches the a in plain. |
[^xyz] | A negative character set. Matches any character not enclosed. For example, [^abc] matches the p in plain. |
[a-z] | A range of characters. Matches any character in the specified range. For example, [a-z] matches any lowercase alphabetic character in the range a through z. |
[^a-z] | A negative range characters. Matches any character not in the specified range. For example, [^a-z] matches any character not in the range a through z. |
\b | Matches a word boundary, that is, the position between a word and a space. For example, er\b matches the er in never but not the er in verb. |
\B | Matches a non-word boundary. er\B matches the er in verb but not the er in never. |
\cx | Matches the control character indicated by x. For example, \cM matches a Control-M or carriage return character. The value of x must be in the range of A-Z or a-z. If not, c is assumed to be 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 white space character including space, tab, form-feed, and so on. Equivalent to [ \f\n\r\t\v]. |
\S | Matches any non-white space 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. Hexadecimal escape values must be exactly two digits long. For example, \x41 matches A. \x041 is equivalent to \x04 & 1. Allows ASCII codes to be used in regular expressions. |
\num | Matches num, where num is a positive integer. A reference back to captured matches. For example, (.)\1 matches two consecutive identical characters. |
\n | Identifies either an octal escape value or a back-reference. If \n is preceded by at least n captured sub-expressions, n is a back-reference. Otherwise, n is an octal escape value if n is an octal digit (0-7). |
\nm | Identifies either an octal escape value or a back-reference. If \nm is preceded by at least nm captured sub-expressions, nm is a back-reference. If \nm is preceded by at least n captures, n is a back-reference followed by literal m. If neither of the preceding conditions exists, \nm matches octal escape value nm when n and m are octal digits (0-7). |
\nml | Matches octal escape value nml when n is an octal digit (0-3) and m and l are octal digits (0-7). |
\un | Matches n, where n is a Unicode character expressed as four hexadecimal digits. For example, \u00A9 matches the copyright symbol (©). |