MuShan Tools
explainregular expression
Website URL[a-zA-z]+://[^\s]*
IP address(IP Address)((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)
Email address\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*
QQ number[1-9]\d{4,}
HTML tags (including content or self-closing)<(.*)(.*)>.*<\/\1>|<(.*) \/>
Password (composed of numbers/uppercase letters/lowercase letters/punctuation marks, all four must be present, more than 8 digits)(?=^.{8,}$)(?=.*\d)(?=.*\W+)(?=.*[A-Z])(?=.*[a-z])(?!.*\n).*$
date (year-month-day)(\d{4}|\d{2})-((1[0-2])|(0?[1-9]))-(([12][0-9])|(3[01])|(0?[1-9]))
date (month/day/year)((1[0-2])|(0?[1-9]))/(([12][0-9])|(3[01])|(0?[1-9]))/(\d{4}|\d{2})
Time (hour:minute, 24-hour clock)((1|0?)[0-9]|2[0-3]):([0-5][0-9])
Chinese characters (characters)[\u4e00-\u9fa5]
Chinese and full-width punctuation marks (characters)[\u3000-\u301e\ufe10-\ufe19\ufe30-\ufe44\ufe50-\ufe6b\uff01-\uffee]
Mainland China fixed phone number(\d{4}-|\d{3}-)?(\d{8}|\d{7})
Mainland Chinamobile number1\d{10}
Mainland ChinaPostcode[1-9]\d{5}
Mainland ChinaID number(15-bit or 18-bit)\d{15}(\d\d[0-9xX])?
Non-negative integer (positive integer or zero)\d+
positive integer[0-9]*[1-9][0-9]*
negative integer-[0-9]*[1-9][0-9]*
integer-?\d+
decimal(-?\d+)(\.\d+)?
Words that do not contain abc\b((?!abc)\w)+\b
explainregular expression
username/^[a-z0-9_-]{3,16}$/
password/^[a-z0-9_-]{6,18}$/
Hexadecimal value/^#?([a-f0-9]{6}|[a-f0-9]{3})$/
E-mail/^([a-z0-9_\.-]+)@([\da-z\.-]+)\.([a-z\.]{2,6})$/
URL/^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$/
IP address/^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/
HTML tag/^<([a-z]+)([^<]+)*(?:>(.*)<\/\1>|\s+\/>)$/
The range of Chinese characters in Unicode encoding/^[u4e00-u9fa5],{0,}$/
regular expression matching Chinese characters[\u4e00-\u9fa5]
Comment: Matching Chinese is really a headache, with this expression it's easy to handle
match double-byte characters (including Chinese characters)[^\x00-\xff]
Comment: can be used to calculate the length of the string (a double-byte character length counts 2, ASCII character counts 1)
regular expression matching blank lines\n\s*\r
Comment: can be used to delete blank lines
regular expression matching HTML tags<(\S*?)[^>]*>.*?</\1>|<.*?/>
Comment: The version circulating on the Internet is too bad, the above can only match part, it is still powerless for complex nested tags
regular expression matching leading and trailing whitespace characters^\s*|\s*$
Comment: It can be used to delete whitespace characters (including spaces, tabs, form feeds, etc.) at the beginning and end of a line, a very useful expression
regular expression matching email address\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*
Comment: form validation is very useful
Regular expression matching URL[a-zA-z]+://[^\s]*
Comment: The version circulating on the Internet has very limited functions, the above can basically meet the needs
Whether the matching account number is legal (beginning with letters, allowing 5-16 bytes, allowing alphanumeric underscores)^[a-zA-Z][a-zA-Z0-9_]{4,15}$
Comment: form validation is very useful
Matches domestic phone numbers\d{3}-\d{8}|\d{4}-\d{7}
Comment: matching form such as 0511-4405222 or 021-87888822
match Tencent QQ number[1-9][0-9]{4,}
Comment: Tencent QQ number starts from 10000
matchMainland ChinaPostcode[1-9]\d{5}(?!\d)
Comment: The postal code of mainland China is 6 digits
match ID card\d{15}|\d{18}
Comment: ID cards in mainland China are 15 or 18 digits
matchIP address\d+\.\d+\.\d+\.\d+
Comment: useful when extracting IP addresses
match a specific number：
^[1-9]\d*$//matchpositive integer
^-[1-9]\d*$//matchnegative integer
^-?[1-9]\d*$//match integer
^[1-9]\d*|0$//Matches non-negative integers (positive integers + 0)
^-[1-9]\d*|0$//Matches non-positive integers (negative integers +0)
^[1-9]\d*\.\d*|0\.\d*[1-9]\d*$//match positive floating point numbers
^-([1-9]\d*\.\d*|0\.\d*[1-9]\d*)$//Matches negative floating point numbers
^-?([1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0)$//match floating point numbers
^[1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0$//Matches non-negative floating point numbers (positive floating point numbers + 0)
^(-([1-9]\d*\.\d*|0\.\d*[1-9]\d*))|0?\.0+|0$//Matches non-positive floating point numbers (negative floating point numbers + 0)
Comment: Useful when dealing with a large amount of data, pay attention to correction when applying it
match a specific string
^[A-Za-z]+$//match a string consisting of 26 English letters
^[A-Z]+$//match a string consisting of 26 uppercase English letters
^[a-z]+$//match a string consisting of 26 lowercase English letters
^[A-Za-z0-9]+$//match a string consisting of numbers and 26 English letters
^\w+$//match a string consisting of numbers, 26 English letters or underscores
characterdescription
\Mark the next character as a special character, or a literal character, or a backreference, or an octal escape. For example, "n" matches the character "n". "\n" matches a newline. The sequence "\" matches "\" and "\(" matches "(".
^Matches the beginning of the input string. If the Multiline property of the RegExp object is set, ^ also matches the position after "\n" or "\r".
$Match the end 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" as well as "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)?" can match "do" or "do" in "does". ? is equivalent to {0,1}.
{n}n is a non-negative integer. Match a certain number of n times. For example, "o{2}" cannot match the "o" in "Bob", but can match the two o's in "food".
{n,}n is a non-negative integer. Match at least n times. For example, "o{2,}" would not match the "o" in "Bob", but would 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?". Note that there can be no spaces between the comma and the two numbers.
?When the character immediately follows any one of the other qualifiers (*,+,?,{n},{n,},{n,m}), the matching pattern is non-greedy. The 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+?" would match a single "o", and "o+" would match all "o"s.
.Matches any single character except '\n'. To match any character including "\n", use a pattern like "[.\n]".
(pattern)Match pattern and get this match. The retrieved matches can be obtained from the resulting Matches collection, using the SubMatches collection in VBScript and the $0…$9 properties in JScript. To match parentheses characters, use "\(" or "\)".
(?:pattern)Matches the pattern but does not get the matching result, which means that this is a non-acquiring 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)Forward pre-check, match the search string at the beginning of any string matching pattern. This is a non-acquisition match, that is, the match does not need to be acquired for later use. For example, "Windows(?=95|98|NT|2000)" can match "Windows" in "Windows2000", but not "Windows" in "Windows3.1". Lookahead consumes no characters, that is, 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, match the search string at the beginning of any string that does not match pattern. This is a non-acquisition match, that is, the match does not need to be acquired for later use. For example, "Windows(?!95|98|NT|2000)" can match "Windows" in "Windows3.1", but not "Windows" in "Windows2000". Lookahead consumes no characters, that is, after a match occurs, the search for the next match begins immediately after the last match, not after the character containing the lookahead
x|yMatches x or y. For example, "z|food" can match "z" or "food". "(z|f)ood" matches "zood" or "food".
[xyz]Character set. Matches any one of the included characters. For example, "[abc]" can match "a" in "plain".
[^xyz]Negative character set. Matches any character not included. For example, "[^abc]" can match "p" in "plain".
[a-z]Character range. Matches any character in the specified range. For example, "[a-z]" matches any lowercase alphabetic character in the range "a" to "z".
[^a-z]Negative character range. Matches any arbitrary character not in the specified range. For example, "[^a-z]" matches any character not in the range "a" to "z".
\bMatches a word boundary, that is, the position between a word and a space. For example, "er\b" can match "er" in "never", but not "er" in "verb".
\BMatches non-word boundaries. "er\B" can match "er" in "verb", but not "er" in "never".
\cxMatches the control character specified by x. For example, \cM matches a Control-M or carriage return. The value of x must be one of A-Z or a-z. Otherwise, treat c as a literal "c" character.
\dMatches a digit character. Equivalent to [0-9].
\DMatches a non-numeric character. Equivalent to [^0-9].
\fMatches a form feed. Equivalent to \x0c and \cL.
\nMatches a newline. Equivalent to \x0a and \cJ.
\rMatches a carriage return. Equivalent to \x0d and \cM.
\sMatches any whitespace character, including spaces, tabs, form feeds, etc. Equivalent to [\f\n\r\t\v].
\SMatches any non-whitespace character. Equivalent to [^\f\n\r\t\v].
\tMatches a tab. Equivalent to \x09 and \cI.
\vMatches a vertical tab. Equivalent to \x0b and \cK.
\wMatches any word character including underscore. Equivalent to "[A-Za-z0-9_]".
\WMatches any non-word character. Equivalent to "[^A-Za-z0-9_]".
\xnMatches n, where n is the hexadecimal escape value. The hexadecimal escape value must be a certain two digits long. For example, "\x41" matches "A". "\x041" is equivalent to "\x04&1". ASCII encoding can be used in regular expressions. .
\numMatches num, where num is a positive integer. A reference to the fetched match. For example, "(.)\1" matches two consecutive identical characters.
\nIdentifies an octal escape value or a backreference. If \n is preceded by at least n fetched subexpressions, n is a backreference. Otherwise, if n is an octal digit (0-7), then n is an octal escape value.
\nmIdentifies an octal escape value or a backreference. nm is a backreference if there are at least nm gain subexpressions before \nm. If there are at least n acquisitions before \nm, then n is a backreference followed by the literal m. If none of the preceding conditions are met, then \nm will match the octal escape value nm if both n and m are octal digits (0-7).
\nmlIf n is an octal number (0-3), and m and l are both octal numbers (0-7), then match the octal escape value nml.
\unMatches n, where n is a Unicode character represented by four hexadecimal digits. For example, \u00A9 matches the copyright symbol (?).
Your visited history：

MuShan ToolsNavigation

Friend Link： 沐杉软件