JSON Online Parser
Description regular expression
Web address (URL) [a-zA-z]+://[^\s]*
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 tag (contains content or self-closing) <(.*)(.*)>.*<\/\1>|<(.*)\/>
Password (composed of numbers/uppercase letters/lowercase letters/punctuation marks, all four must have, more than 8 characters) (?=^.{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 (MM/DD/YYYY) ((1[0-2])|(0?[1-9]))/(([12][0-9])|(3[01])|(0 ?[1-9]))/(\d{4}|\d{2})
Time (hour:minute, 24-hour format) ((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]
Fixed telephone numbers in Mainland China (\d{4}-|\d{3}-)?(\d{8}|\d{7})
Mobile phone number in mainland China 1\d{10}
Mainland China postal code [1-9]\d{5}
Chinese mainland ID number (15 or 18 digits) \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
Description regular expression
Username /^[a-z0-9_-]{3,16}$/
Password /^[a-z0-9_-]{6,18}$/
Hex value /^#?([a-f0-9]{6}|[a-f0-9]{3})$/
Email /^([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 tags /^<([a-z]+)([^<]+)*(?:>(.*)<\/\1>|\s+\/>)$/
The range of Chinese characters in Unicode encoding /^[u4e00-u9fa5],{0,}$/
Regular expression for matching Chinese characters [\u4e00-\u9fa5]
Comment: Matching Chinese is really a headache, with this expression it will be easier
Match double-byte characters (including Chinese characters) [^\x00-\xff]
Comment: It can be used to calculate the length of a string (a double-byte character counts as 2, and an ASCII character counts as 1)
Regular expression to match blank lines \n\s*\r
Comment: can be used to remove blank lines
Regular expression to match HTML tags <(\S*?)[^>]*>.*?</\1>|<.*?/>
Comment: The version circulating on the Internet is too bad, the above one can only match part, and it is still powerless for complex nested tags
A regular expression that matches leading and trailing whitespace characters ^\s*|\s*$
Comment: It can be used to delete blank characters at the beginning and end of the line (including spaces, tabs, form feeds, etc.), a very useful expression
Regular expression to match email addresses \w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*
Comment: Useful for form validation
Regular expression to match URL [a-zA-z]+://[^\s]*
Comment: The functions of the version circulated on the Internet are very limited, and the above one can basically meet the needs
Whether the matching account is legal (starting with a letter, allowing 5-16 bytes, allowing alphanumeric underscores) ^[a-zA-Z][a-zA-Z0-9_]{4,15}$
Comment: Useful for form validation
Match domestic phone numbers \d{3}-\d{8}|\d{4}-\d{7}
评注：匹配形式如 0511-4405222 或 021-87888822
Match Tencent QQ number [1-9][0-9]{4,}
Commentary: Tencent QQ number starts from 10000
Match the zip code of mainland China [1-9]\d{5}(?!\d)
Commentary: The postal code of mainland China is 6 digits
Match ID \d{15}|\d{18}
Comment: The ID card in mainland China is 15 or 18 digits
Match ip address \d+\.\d+\.\d+\.\d+
Comment: Useful when extracting ip address
Match specific numbers:
^[1-9]\d*$ //Match positive integer
^-[1-9]\d*$ //Match negative integers
^-?[1-9]\d*$ //Match integer
^[1-9]\d*|0$ //Match non-negative integer (positive integer + 0)
^-[1-9]\d*|0$ //Match 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*)$ //Match 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$ //Match non-negative floating-point numbers (positive floating-point numbers +0)
^(-([1-9]\d*\.\d*|0\.\d*[1-9]\d*))|0?\.0+|0$ //Match non-positive floating-point numbers (negative floating-point numbers +0)
Comment: It is useful when dealing with a large amount of data, please pay attention to correction in specific applications
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
Character Description
\ Marks 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 character. 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".
$ matches 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". * is 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 zero or one occurrence of the preceding subexpression. For example, "do(es)?" can match "do" in "do" or "does". ? is equivalent to {0,1}.
{n} n is a non-negative integer. Match determined n times. For example, "o{2}" would not match the "o" in "Bob", but would match both 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 this character immediately follows any other limiter (*,+,?, {n}, {n,}, {n,m}), the matching pattern is non-greedy. The non-greedy mode matches the search string as little as possible, while the default greedy mode matches the search string as much as possible. For example, for the string "oooo", "o+?" will match a single "o", and "o+" will match all "o".
. matches any single character except "\n". To match any character including "\n", use a pattern like "[.\n]".
(pattern) matches pattern and retrieves this match. The acquired matches can be obtained from the generated Matches collection, using the SubMatches collection in VBScript, and using the $0...$9 properties in JScript. To match parenthesis characters, use "\(" or "\)".
(?:pattern) matches pattern but does not get the matching result, which means it is a non-getting 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 lookahead, matches the search string at the beginning of any string matching pattern. This is a non-acquiring match, that is, the match does not need to be acquired for later use. For example, "Windows(?=95|98|NT|2000)" matches "Windows" in "Windows2000", but not "Windows" in "Windows3.1". Lookaheads don't consume 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, matches the search string at the beginning of any string that does not match pattern. This is a non-acquiring 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 cannot match "Windows" in "Windows2000". Lookahead does not consume 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|y matches x or y. For example, "z|food" would match either "z" or "food". "(z|f)ood" matches "zood" or "food".
[xyz] character set. Matches any one of the contained characters. For example, "[abc]" would match the "a" in "plain".
[^xyz] Negative character set. Matches any character not contained. For example, "[^abc]" would match the "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" through "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" through "z".
\b matches 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".
\B matches non-word boundaries. "er\B" matches "er" in "verb", but not "er" in "never".
\cx matches the control character indicated 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.
\d matches a single digit character. Equivalent to [0-9].
\D matches a non-digit character. Equivalent to [^0-9].
\f matches a form break. Equivalent to \x0c and \cL.
\n matches a newline character. Equivalent to \x0a and \cJ.
\r matches a carriage return. Equivalent to \x0d and \cM.
\s matches any whitespace character, including spaces, tabs, form feeds, and so on. 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 an 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 escaped value. Hex escape values 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. .
\num matches num, where num is a positive integer. A reference to the hit that was fetched. 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, then n is a backreference. Otherwise, if n is an octal digit (0-7), then n is an octal escape value.
\nm identifies an octal escape value or a backreference. nm is a backreference if \nm is preceded by at least nm obtained subexpressions. If \nm is preceded by at least n fetches, 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).
\nml If n is an octal digit (0-3), and both m and l are octal digits (0-7), then match 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 (?).
Your Footsteps:

Online tool navigation

Popular tools：