Detailed explanation of regular expression \v metacharacter

This article mainly shares with you the detailed explanation of the regular expression \v metacharacter, I hope it can help you. A regular expression is a pattern of text that includes ordinary characters (for example, the letters a through z) and special characters (called "metacharacters"). A pattern describes one or more strings to match when searching for text. The \v metacharacter can match vertical tab characters. Let me introduce to you the regular expression \v metacharacter. Friends who are interested should take a look.

The following table contains the complete list of metacharacters and their behavior in the context of regular expressions:

##(?Reverse negative pre-check is similar to forward negative pre-check, but in the opposite direction. For example, "

Characters	Description
\	Mark the next character as a special character, or a literal character, or a backward reference, or an octal escape character. For example, 'n' matches the character "n". '\n' matches a newline character. The sequence '\\' matches "\" and "\(" matches "(".
^	Matches the beginning of the input string. If the RegExp object's Multiline property is set, ^ also matches the position after '\n' or '\r'.
$	Matches the end position of the input string. If the Multiline property of the RegExp object is set, $ also matches the position before '\n' or '\r'.
*	Matches the preceding subexpression zero or more times. For example, zo* matches "z" and "zoo". * 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)?" matches "do" or "does" . ? Equivalent to {0,1}.
{n}	n is a non-negative integer. Match a certain number of n times. For example, 'o{2}' does not match the 'o' in "Bob", but it does match both o's in "food".
{n,}	n is a non-negative integer. Match at least n times. For example, 'o{2,}' does not match the 'o' in "Bob" but does match all o's in "foooood". 'o{1,}' is equivalent to 'o+'. 'o{0,}' is equivalent to 'o*'.
{n,m}	m and n are both non-negative integers, where n <= m. Match 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?'. Please note that there cannot be a space between the comma and the two numbers.
?	When this character is immediately followed by any other limiter (*, +, ?, {n}, {n, }, {n,m}), the matching pattern is non-greedy. Non-greedy mode matches as little of the searched string as possible, while the default greedy mode matches as much of the searched string 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 newlines (\n, \r). To match any character including '\n', use a pattern like "(.|\n)".
(pattern)	Match pattern and get this match. The matches obtained can be obtained from the generated Matches collection, using the SubMatches collection in VBScript or the $0…$9 properties in JScript. To match parentheses characters, use '\(' or '\)'.
(?:pattern)	Matches pattern but does not obtain the matching result, which means that this is a non-acquisition match and is not stored. for later use. This is useful when using the "or" character (|) to combine parts of a pattern. For example, 'industr(?:y|ies) is a shorter expression than 'industry|industries'.
(?=pattern)	Look ahead positive assert, match the search character at the beginning of any string matching pattern string. This is a non-fetch match, that is, the match does not need to be fetched for later use. For example, "Windows(?=95|98|NT|2000)" can match "Windows" in "Windows2000", but cannot match "Windows" in "Windows3.1". Prefetching does not consume characters, that is, after a match occurs, the search for the next match begins immediately after the last match, rather than starting after the character containing the prefetch.
(?!pattern)	Positive negative assert (negative assert), matches at the beginning of any string that does not match pattern Find string. This is a non-fetch match, that is, the match does not need to be fetched for later use. For example, "Windows(?!95|98|NT|2000)" can match "Windows" in "Windows3.1", but cannot match "Windows" in "Windows2000". Prefetching does not consume characters, that is, after a match occurs, the search for the next match begins immediately after the last match, rather than starting after the character containing the prefetch.
(?<=pattern)	Reverse (look behind) positive lookup is similar to forward positive lookup, but in the opposite direction. For example, "<span style="color:#333333;font-size:12px;font-family:NSimsun">(?<=95|98|NT|2000)Windows</span>" matches " in "<span style="color:#333333;font-size:12px;font-family:NSimsun">2000Windows</span>" <span style="color:#333333;font-size:12px;font-family:NSimsun">Windows</span>", but cannot match "<span style="color:#333333;font-size:12px;font-family:NSimsun">Windows</span>" in "<span style="color:#333333;font-size:12px;font-family:NSimsun">3.1Windows</span>" ".
(?<!95|98|NT|2000)Windows<span style="color:#333333;font-size:12px;font-family:NSimsun"></span>" can match " in "3.1Windows<span style="color:#333333;font-size:12px;font-family:NSimsun"></span>" Windows<span style="color:#333333;font-size:12px;font-family:NSimsun"></span>", but cannot match "Windows<span style="color:#333333;font-size:12px;font-family:NSimsun"></span>" in "2000Windows<span style="color:#333333;font-size:12px;font-family:NSimsun"></span>" .
x|y	Matches x or y. For example, 'z|food' matches "z" or "food". '(z|f)ood' matches "zood" or "food".
[xyz]	character set. Matches any one of the characters contained. For example, '[abc]' matches 'a' in "plain".
[^xyz]	Negative value character set. Matches any character not included. For example, '[^abc]' matches 'p', 'l', 'i', 'n' in "plain".
[a-z]	Character range. Matches any character within the specified range. For example, '[a-z]' matches any lowercase alphabetic character in the range 'a' through 'z'.
[^a-z]	Negative character range. Matches any character not within the specified range. For example, '[^a-z]' matches any character that is not in the range 'a' to 'z'.
\b	Matches a word boundary, which refers to the position between a word and a space. For example, 'er\b' matches 'er' in "never" but not in "verb".
\B	Matches non-word boundaries. 'er\B' matches 'er' in "verb", but not in "never".
\cx	Matches the control character specified by x. For example, \cM matches a Control-M or carriage return character. The value of x must be one of A-Z or a-z. Otherwise, c is treated as a literal 'c' character.
\d	Matches a numeric character. Equivalent to [0-9].
\D	Matches a non-numeric 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 letters, numbers, and underscores. Equivalent to '[A-Za-z0-9_]'.
\W	Matches non-letters, numbers, and underscores. Equivalent to '[^A-Za-z0-9_]'.
\xn	Matches n, where n is the 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. A reference to the match obtained. For example, '(.)\1' matches two consecutive identical characters.
\n	Identifies an octal escape value or a backreference. If \n is preceded by at least n fetched subexpressions, n is a backward reference. Otherwise, if n is an octal number (0-7), then n is an octal escape value.
\nm	Identifies an octal escape value or a backreference. If \nm is preceded by at least nm get-subexpressions, nm is a backward reference. If \nm is preceded by at least n obtains, n is a backward reference followed by a literal m. If neither of the previous conditions is true, then \nm will match the octal escape value nm if n and m are both octal digits (0-7).
\nml	If n is an octal number (0-3), and m and l are both octal numbers (0-7) , then matches the octal escape value nml.
\un	匹配 n，其中 n 是一个用四个十六进制数字表示的 Unicode 字符。例如， \u00A9 匹配版权符号 (?)。

\v元字符可以匹配垂直制表符。

语法结构:

（1）.构造函数方式:

new RegExp(\\v)

（2）.对象直接量方式:

/\v/

浏览器支持:

（1）.IE浏览器支持此方法。

（2）.火狐浏览器支持此方法。

（3）.谷歌浏览器支持此方法。

（4）.opera浏览器支持此方法。

（5）.safria浏览器支持此方法。

实例代码:

var str="This is an \v good antzone";
var reg=/\v/;

相关推荐：

正则表达式 \D 元字符(等价于"[^0-9]")详解

正则表达式元字符和普通字符详解

正则的元字符介绍和应用

The above is the detailed content of Detailed explanation of regular expression \v metacharacter. For more information, please follow other related articles on the PHP Chinese website!