Only enter numbers: "^[0-9]*$".
Only n-digit numbers can be entered: "^\d{n}$".
Only numbers with at least n digits can be entered: "^\d{n,}$".
Only numbers in m~n are entered:. "^\d{m,n}$"
Only numbers starting with zero and non-zero are entered: "^(0|[1-9][0-9]*)$".
Only positive real numbers with two decimal places can be entered: "^[0-9]+(.[0-9]{2})?$".
Only positive real numbers with 1 to 3 decimal places can be entered: "^[0-9]+(.[0-9]{1,3})?$".
Only non-zero positive integers can be entered: "^\+?[1-9][0-9]*$".
Only non-zero negative integers can be entered: "^\-[1-9][]0-9"*$.
Only characters with length 3 can be entered: "^.{3}$".
Only strings composed of 26 English letters can be entered: "^[A-Za-z]+$".
Only strings composed of 26 capital English letters can be entered: "^[A-Z]+$".
Only strings composed of 26 lowercase English letters can be entered: "^[a-z]+$".
Only strings composed of numbers and 26 English letters can be entered: "^[A-Za-z0-9]+$".
Only strings composed of numbers, 26 English letters, or underscores can be entered: "^\w+$".
Verify user password: "^[a-zA-Z]\w{5,17}$" The correct format is: start with a letter, length between 6 and 18, and can only contain characters, numbers and underscores.
Verify that it contains characters such as ^%&’,;=?$\": "[^%&’,;=?$\x22]+".
Only enter Chinese characters: "^[\u4e00-\u9fa5]{0,}$"
Verify the email address: "^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$".
Verify InternetURL: "^http://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?$".
Verification phone number: "^(\(\d{3,4}-)|\d{3.4}-)?\d{7,8}$"The correct format is: "XXX-XXXXXXX", "XXX-XXXXXXXXXX", "XXX-XXXXXXXXXXX", "XXX-XXXXXXXXXXXX, "XXXXXXXXXXXXXX, and "XXXXXXXXXXXXXXX".
The 12 months of verification for one year: "^(0?[1-9]|1[0-2])$" is correct format: "01"~"09" and "1"~"12".
Verify that the 31 days of one month: "^((0?[1-9])|((1|2)[0-9])|30|31)$" is correct format: "01"~"09" and "1"~"31".
Use regular expressions to restrict the input content in the text box in the web form:
Use regular expressions to restrict only Chinese: onkeyup="value=(/[^\u4E00-\u9FA5]/g,’’)" onbeforepaste="(’text’,(’text’).replace(/[^\u4E00-\u9FA5]/g,’’))"
Use regular expressions to restrict only full-width characters: onkeyup="value=(/[^\uFF00-\uFFFF]/g,’’)" onbeforepaste="(’text’,(’text’).replace(/[^\uFF00-\uFFF]/g,’’))"
Use regular expressions to limit only numeric input: onkeyup="value=(/[^\d]/g,’’) "onbeforepaste="(’text’,(’text’).replace(/[^\d]/g,’’))"
Use regular expressions to restrict only numeric and English: onkeyup="value=(/[\W]/g,’’) "onbeforepaste="(’text’,(’text’).replace(/[^\d]/g,’’))"
You need to use regular expressions to extract file names from URL address, as shown in page1
s=
s=(/(.*\/){0,}([^\.]+).*/ig,"$2")
alert(s)
Match double-byte characters (including Chinese characters): [^\x00-\xff]
Application: Calculate the length of the string (one double-byte character length meter 2, ASCII character meter 1)
=function(){return ([^\x00-\xff]/g,"aa").length;}
Regular expression matching blank lines: \n[\s| ]*\r
Regular expression matching HTML tags: /<(.*)>.*<\/\1>|<(.*) \//
Regular expression matching the beginning and end spaces: (^\s*)|(\s*$)
= function()
{
return (/(^\s*)|(\s*$)/g, "");
}
Decompose and convert IP addresses using regular expressions:
The following is a Javascript program that uses regular expressions to match IP addresses and converts the IP addresses into corresponding values:
function IP2V(ip)
{
re=/(\d+)\.(\d+)\.(\d+)\.(\d+)/g // Regular expression matching IP address if((ip))
{
return RegExp.$1*(255,3))+RegExp.$2*(255,2))+RegExp.$3*255+RegExp.$4*1
}
else
{
throw new Error("Not a valid IP address!")
}
}
However, if the above program does not use regular expressions, but uses the split function to decompose it directly. The program is as follows:
var ip="10.100.20.168" ip=(".")
alert("IP value is: "+(ip[0]*255*255*255+ip[1]*255*255+ip[2]*255+ip[3]*1))
Symbol explanation:
\
Mark the next character as a special character, or an primitive 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 start position 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 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 previous subexpression zero or multiple times. For example, zo* can match "z" and "zoo". * is equivalent to {0,}.
+
Matches the previous subexpression once or more times. For example, 'zo+' can match "zo" and "zoo", but not "z". + is equivalent to {1,}.
?
Matches the previous subexpression zero or once. For example, "do(es)?" can match "do" in "do" or "does". ? is equivalent to {0,1}.
{n}
n is a non-negative integer. Match the n times that are determined. For example, 'o{2}' cannot match 'o' in "Bob", but can match two os 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 os in "fooooood". ’o{1,}’ is equivalent to ’o+’. ’o{0,}’ is equivalent to ’o*’.
{n,m}
m and n are non-negative integers, where n <= m. Match at least n times and match up to m times. For example, "o{1,3}" will match the first three os in "fooooooood". ’o{0,1}’ is equivalent to ’o?’. Please note that there cannot be spaces between commas and two numbers.
?
The matching pattern is non-greedy when the character is immediately followed by any other restriction character (*, +, ?, {n}, {n,}, {n,m}). The non-greedy pattern matches as few strings as possible, while the default greedy pattern matches as many strings as possible. For example, for the string "oooo", 'o+?' will match a single "o", and 'o+' will match all 'o'.
.
Match any single character except "\n". To match any characters including '\n', use a pattern like '[.\n]'.
(pattern)
Match pattern and get this match. The obtained matches can be obtained from the generated Matches collection, using the SubMatches collection in VBScript, and the $0…$9 attribute in JScript. To match parentheses characters, use '\(’ or '\)'.
(?:pattern)
Match pattern but does not get the matching result, that is, this is a non-get match and is not stored for future use. This is useful when using the "or" character (|) to combine various parts of a pattern. For example, ’industr(?:y|ies) is a simpler expression than ’industry|industries’.
(?=pattern)
Forward pre-check, match the lookup string at the beginning of any string matching pattern. This is a non-get match, that is, the match does not need to be retrieved for later use. For example, 'Windows (?=95|98|NT|2000)' can match "Windows" in "Windows 2000", but cannot match "Windows" in "Windows 3.1". Pre-checking does not consume characters, that is, after a match occurs, the next match's search begins immediately after the last match, rather than after the characters containing the pre-checking.
(?!pattern)
Negative pre-check, matching the lookup string at the beginning of any string that does not match the pattern. This is a non-get match, that is, the match does not need to be retrieved for later use. For example, 'Windows (?!95|98|NT|2000)' can match "Windows" in "Windows 3.1", but cannot match "Windows" in "Windows 2000". Pre-checking does not consume characters, that is, after a match occurs, the next match search begins immediately after the last match, rather than after the characters containing the pre-checking
x|y
Match x or y. For example, 'z|food' can match "z" or "food". ’(z|f)ood’ matches "zood" or "food".
[xyz]
Character collection. Match any character contained. For example, '[abc]' can match 'a' in "plain".
[^xyz]
A collection of negative values characters. Match any characters not included. For example, '[^abc]' can match 'p' in "plain".
[a-z]
Character range. Match any character in the specified range. For example, '[a-z]' can match any lowercase alphabetical characters in the range 'a' to 'z'.
[^a-z]
Negative value character range. Match any arbitrary characters that are not within the specified range. For example, '[^a-z]' can match any arbitrary character that is not in the range of 'a' to 'z'.
\b
Match a word boundary, which means the position between the word and space. For example, 'er\b' can match 'er' in "never", but not 'er' in "verb".
\B
Match non-word boundaries. ’er\B’ can match ’er’ in “verb”, but not ’er’ in “never”.
\cx
Matches the control characters 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 an original 'c' character.
\d
Match a numeric character. Equivalent to [0-9].
\D
Match a non-numeric character. Equivalent to [^0-9].
\f
Match a page break. Equivalent to \x0c and \cL.
\n
Match a newline character. Equivalent to \x0a and \cJ.
\r
Match a carriage return character. Equivalent to \x0d and \cM.
\s
Match any whitespace characters, including spaces, tabs, page breaks, etc. Equivalent to [ \f\n\r\t\v].
\S
Match any non-whitespace characters. Equivalent to [^ \f\n\r\t\v].
\t
Match a tab character. Equivalent to \x09 and \cI.
\v
Match a vertical tab. Equivalent to \x0b and \cK.
\w
Match any word character that includes an underscore. Equivalent to ’[A-Za-z0-9_]’.
\W
Match any non-word characters. Equivalent to ’[^A-Za-z0-9_]’.
\xn
Match n, where n is a hexadecimal escape value. The hexadecimal escape value must be the length of two numbers that are determined. For example, '\x41' matches "A". ’\x041’ is equivalent to ’\x04’ & "1". ASCII encoding can be used in regular expressions. .
\num
Match num, where num is a positive integer. Reference to the obtained match. For example, ’(.)\1’ matches two consecutive identical characters.
\n
Identifies an octal escape value or a backward reference. If \n has at least n obtained subexpressions before, n is a backward reference. Otherwise, if n is an octal number (0-7), n is an octal escape value.
\nm
Identifies an octal escape value or a backward reference. If there are at least nm obtaining subexpressions before \nm, nm is a backward reference. If there are at least n retrieves before \nm, n is a backward reference followed by the literal m. If none of the previous conditions are satisfied, if both n and m are octal numbers (0-7), then \nm will match the octal escape value nm.
\nml
If n is an octal number (0-3), and both 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 (?).