Metacharacters |
Description |
\ |
Mark the next character as a special character, a literal character, or a backward reference, or an octal escape character. For example, "\ n" matches \ n. "\ N" matches the line break. The sequence "\" matches "\", and "\ (" matches "(". It is equivalent to the concept of "Escape Character" in multiple programming languages. |
^ |
Matches the start position of the input string. If the Multiline attribute of the RegExp object is set, ^ matches the position after "\ n" or "\ r. |
$ |
Matches the end position of the input string. If the Multiline attribute of the RegExp object is set, $ also matches the position before "\ n" or "\ r. |
* |
Match the previous subexpression any time. For example, zo * can match "z", "zo", and "zoo ". * Is equivalent to {0 ,}. |
+ |
Match the previous subexpression once or multiple times (greater than or equal to 1 time ). For example, "zo +" can match "zo" and "zoo", but cannot match "z ". + Is equivalent to {1 ,}. |
? |
Match the previous subexpression zero or once. For example, "do (es )?" It can match "do" in "do" or "does ".? It is equivalent to {0, 1 }. |
{N} |
N is a non-negative integer. Match n times. For example, "o {2}" cannot match "o" in "Bob", but can match two o in "food. |
{N ,} |
N is a non-negative integer. Match at least n times. For example, "o {2,}" cannot match "o" in "Bob", but can match all o in "foooood. "O {1,}" is equivalent to "o + ". "O {0,}" is equivalent to "o *". |
{N, m} |
Both m and n are non-negative integers, where n <= m. Match at least n times and at most m times. For example, "o {1, 3}" matches the first three o in "fooooood. "O {0, 1}" is equivalent to "o ?". Note that there must be no space between a comma and two numbers. |
? |
When this character is followed by any other delimiter (*, + ,?, The matching mode after {n}, {n ,}, {n, m}) is not greedy. The non-Greedy mode matches as few searched strings as possible, while the default greedy mode matches as many searched strings as possible. For example, for strings "oooo", "o + ?" A single "o" will be matched, while "o +" will match all "o ". |
. |
Match any single character except "\ r \ n. To match any character including "\ r \ n", use a pattern like "[\ s \ S. |
(Pattern) |
Match pattern and obtain this match. The obtained match can be obtained from the generated Matches set. The SubMatches set is used in VBScript, and $0… is used in JScript... $9 attribute. To match the parentheses, use "\ (" or "\)". |
(? : Pattern) |
Matches pattern but does not get the matching result. That is to say, this is a non-get match and is not stored for future use. This is useful when you use the "(|)" character to combine all parts of a pattern. For example, "industr (? : Y | ies) "is a simpler expression than" industry | industrial. |
(? = Pattern) |
Forward validation pre-query: matches the search string at the beginning of any string that matches pattern. This is a non-get match, that is, the match does not need to be obtained for future use. For example (? = 95 | 98 | NT | 2000) "can match" Windows "in" Windows2000 ", but cannot match" Windows "in" Windows3.1 ". Pre-query does not consume characters, that is, after a match occurs, the next matching search starts immediately after the last match, instead of starting after the pre-query characters. |
(?! Pattern) |
Forward negative pre-query: matches the search string at the beginning of any string that does not match pattern. This is a non-get match, that is, the match does not need to be obtained for future use. For example, "Windows (?! 95 | 98 | NT | 2000) "can match" Windows "in" Windows3.1 ", but cannot match" Windows "in" Windows2000 ". |
(? <= Pattern) |
The reverse direction must be pre-check, which is similar to positive pre-check, but in the opposite direction. For example, <= 95 | 98 | NT | 2000) Windows can match Windows in 2000Windows, but cannot match Windows in 3.1Windows ". |
(? <! Pattern) |
Reverse negative pre-query, similar to forward negative pre-query, is in the opposite direction. For example, "(? <! 95 | 98 | NT | 2000) Windows can match "Windows" in "3.1Windows", but cannot match "Windows" in "2000Windows ". |
X | y |
Match x or y. For example, "z | food" can match "z", "food", or "zood" (Exercise caution here ). "(Z | f) ood" matches "zood" or "food ". |
[Xyz] |
Character Set combination. Match any character in it. For example, "[abc]" can match "a" in "plain ". |
[^ Xyz] |
Negative value character set combination. Match any character not included. For example, "[^ abc]" can match "plin" in "plain ". |
[A-z] |
Character range. Matches any character in the specified range. For example, "[a-z]" can match any lowercase letter in the range of "a" to "z. Note: only when a hyphen is in a character group and appears between two characters can the range of the characters be expressed. If a group starts with a hyphen, it can only represent the character itself. |
[^ A-z] |
Negative character range. Matches any character that is not within the specified range. For example, "[^ a-z]" can match any character that is not in the range of "a" to "z. |
\ B |
Match A Word boundary, that is, the position between a word and a space (that is, the regular expression "match" has two concepts: matching characters and matching positions, here \ B is the matching position ). For example, "er \ B" can match "er" in "never", but cannot match "er" in "verb ". |
\ B |
Match non-word boundary. "Er \ B" can match "er" in "verb", but cannot match "er" in "never ". |
\ Cx |
Match the control characters specified by x. For example, \ cM matches a Control-M or carriage return character. The value of x must be either a A-Z or a-z. Otherwise, c is treated as a literal "c" character. |
\ D |
Match a numeric character. It is equivalent to [0-9]. |
\ D |
Match a non-numeric character. It is equivalent to [^ 0-9]. |
\ F |
Match a form feed. It is equivalent to \ x0c and \ cL. |
\ N |
Match A linefeed. It is equivalent to \ x0a and \ cJ. |
\ R |
Match a carriage return. It is equivalent to \ x0d and \ cM. |
\ S |
Match any invisible characters, including spaces, tabs, and page breaks. It is equivalent to [\ f \ n \ r \ t \ v]. |
\ S |
Match any visible characters. It is equivalent to [^ \ f \ n \ r \ t \ v]. |
\ T |
Match a tab. It is equivalent to \ x09 and \ cI. |
\ V |
Match a vertical tab. It is equivalent to \ x0b and \ cK. |
\ W |
Match any word characters that contain underscores. Similar to but not equivalent to "[A-Za-z0-9 _]", here the "word" character uses the Unicode Character Set. |
\ W |
Match any non-word characters. It is equivalent to "[^ A-Za-z0-9 _]". |
\ Xn |
Match n, where n is the hexadecimal escape value. The hexadecimal escape value must be determined by the length of two numbers. For example, "\ x41" matches "". "\ X041" is equivalent to "\ x04 & 1 ". The regular expression can be ASCII encoded. |
\ Num |
Matches num, where num is a positive integer. References to the obtained matching. For example, "(.) \ 1" matches two consecutive identical characters. |
\ N |
Identifies an octal escape value or a backward reference. If at least n subexpressions are obtained before \ n, n is backward referenced. Otherwise, if n is an octal digit (0-7), n is an octal escape value. |
\ Nm |
Identifies an octal escape value or a backward reference. If at least one child expression is obtained before \ nm, the nm is backward referenced. If at least n records are obtained before \ nm, n is a backward reference followed by text m. If none of the preceding conditions are met, if n and m are Octal numbers (0-7), \ nm matches the octal escape value nm. |
\ Nml |
If n is an octal number (0-7) and m and l are Octal numbers (0-7), the octal escape value nml is matched. |
\ Un |
Match n, where n is a Unicode character represented by four hexadecimal numbers. For example, \ u00A9 matches the copyright symbol (). |
\ <\> |
Start (\ <) and end (\>) of the match word (word ). For example, the regular expression \ <the \> can match the "the" in the string "for the wise", but cannot match the "the" in the string "otherwise ". Note: This metacharacter is not supported by all software. |
\(\) |
Define the expressions between \ (and \) as "group ), and save the characters matching this expression to a temporary region (a regular expression can save up to 9 characters). They can be referenced using the \ 1 to \ 9 symbols. |
| |
Perform logical "Or" (Or) operations on the two matching conditions. For example, the regular expression (him | her) matches "it belongs to him" and "it belongs to her", but does not match "it belongs to them .". Note: This metacharacter is not supported by all software. |
+ |
Match one or more characters that match exactly before it. For example, the regular expression 9 + matches 9, 99, and 999. Note: This metacharacter is not supported by all software. |
? |
Match 0 or 1 character that is exactly before it. Note: This metacharacter is not supported by all software. |
{I} {I, j} |
Matches a specified number of characters defined in the previous expression. For example, the regular expression A [0-9] {3} can match the character "A" followed by A string of exactly three numeric characters, such as A123 and A348, but does not match A1234. The regular expression [0-9] {} matches any four, five, or six consecutive numbers. |