A small summary of regular expressions

1. Regular expression basic syntax

Two special symbols ' ^ ' and ' $ '. Their role is to indicate the beginning and end of a string, respectively. Examples are as follows:

"^the": denotes all strings starting with "the" ("There", "the Cat", etc.);
"Of despair$": denotes a string that ends with "of despair";
"^abc$": the Start and end are "ABC" string--hehe, only "abc" himself;
"Notice": represents any string that contains "notice".

Like the last example, if you don't use two special characters, you're in any part of the string that represents the look-up-you're
Do not position it on a certain top.

Others have ' * ', ' + ' and '? ' These three symbols represent the number of occurrences of a character or sequence of characters. They say "no or
More "," once or more "there is" no or once ". Here are a few examples:

"ab*": Indicates that a string has an a followed by 0 or several B. ("A", "AB", "ABBB",...... ）；
"ab+": Indicates that a string has an a followed by at least one B or more;
"Ab?" : Indicates that a string has an a followed by 0 or a B;
"a?b+$": indicates that there are 0 or one a followed by one or several B at the end of the string.

You can also use ranges, enclosed in curly braces, to indicate the range of repetitions.

"Ab{2}": Indicates that a string has a followed by 2 B ("ABB");
"Ab{2,}": Indicates that a string has a followed by at least 2 B;
"ab{3,5}": Indicates that a string has a followed by 3 to 5 B.

Note that you must specify the lower bound of the range (for example: "{0,2}" instead of "{, 2}"). Also, you may have noticed, ' * ', ' + ' and
‘?‘ Equivalent to "{0,}", "{1,}" and "{0,1}".
There is also a ' | ', which means "or" action:

"Hi|hello": Indicates a string with "hi" or "hello";
"(B|CD) EF": denotes "bef" or "cdef";
"(a|b) *c": Represents a String "a" "B" mixed strings followed by a "C";

‘.‘ Can replace any character:

"A.[0-9]": Indicates that a string has a "a" followed by an arbitrary character and a number;
"^. {3}$ ": A string representing any three characters (3 characters in length);

Square brackets indicate that certain characters allow a particular position in a string to appear:

"[AB]": Indicates that a string has a "a" or "B" (equivalent to "a|b");
"[A-d]": Indicates a string containing a lowercase ' a ' to ' d ' one (equivalent to "a|b|c|d" or "[ABCD]");
"^[a-za-z]": Represents a string that begins with a letter;
"[0-9]%": A number that represents a percent before a semicolon;
", [a-za-z0-9]$]: Indicates that a string ends with a comma followed by a letter or number.

You can also use ' ^ ' in square brackets to indicate unwanted characters, ' ^ ' should be the first in square brackets. (For example: "%[^a-za-z]%" table
No letters should appear in the two percent sign).

In order to express it verbatim, you must be in "^.$ () |*+?" {\ ' These characters are preceded by the transfer character ' \ '.
Note that in square brackets, you do not need to escape characters.

2. Regular expression validation controls the input character type of the text box
1. Enter only numbers and English:
<input onkeyup= "Value=value.replace (/[\w]/g, ')" onbeforepaste= "Clipboarddata.setdata (' text ', Clipboarddata.getdata (' text '). Replace (/[^\d]/g, ') "id=" Text1 "name=" Text1 ">

2. Only numbers can be entered:
<input onkeyup= "Value=value.replace (/[^\d]/g, ')" onbeforepaste= "Clipboarddata.setdata (' text ', Clipboarddata.getdata (' text '). Replace (/[^\d]/g, ') "id=" Text2 "name=" Text2 ">

3. Only full-width input:
<input onkeyup= "Value=value.replace (/[^\uff00-\uffff]/g, ')" onbeforepaste= "Clipboarddata.setdata (' text ', Clipboarddata.getdata (' text '). Replace (/[^\uff00-\uffff]/g, ') "id=" Text3 "name=" Text3 ">

4. Only the Chinese characters can be entered:
<input onkeyup= "Value=value.replace (/[^\u4e00-\u9fa5]/g, ')" onbeforepaste= "Clipboarddata.setdata (' text ', Clipboarddata.getdata (' text '). Replace (/[^\u4e00-\u9fa5]/g, ') "id=" Text4 "name=" TEXT4 ">

3. Application examples of regular expressions popular description

*******************************************************************************

Whether the checksum is all made up of numbers

/^[0-9]{1,20}$/

^ indicates that the beginning character matches the rule immediately following the ^

$ indicates the first character to match the rule immediately preceding the $

The content in [] is an optional character set

[0-9] indicates a range of characters is required between 0-9

{1,20} indicates that the numeric string length is valid from 1 to 20, that is, the number of occurrences of the character in [0-9] is 1 to 20 times.

/^ and $/should be used to represent a rule that requires an exact match to be defined for the entire string, rather than just one substring in the string.

*******************************************************************************

Check login name: Only 5-20 entries begin with a letter, can be numbered, "_", "." The string

/^[a-za-z]{1} ([a-za-z0-9]|[. _]) {4,19}$/

^[a-za-z]{1} indicates that the first character requirement is a letter.

([a-za-z0-9]| [._]) {4,19} represents a string from 4 to 9 bits in length starting from the second bit (since it immediately follows the previous expression), and it is required to consist of uppercase and lowercase letters, numbers, or special character set [. _].

*******************************************************************************

Verify user name: Only 1-30 strings beginning with a letter can be entered

/^[a-za-z]{1,30}$/

*******************************************************************************

Check password: Only 6-20 letters, numbers, underscores can be entered

/^ (\w) {6,20}$/

\w: Used to match letters, numbers, or underscore characters

*******************************************************************************

Verify the regular phone, fax number: can be "+" or the beginning of the number, can contain "-" and ""

/^[+]{0,1} (\d) {1,3}[]? ([-]? ((\d) | []) {1,12}) +$/

\d: Used to match numbers from 0 to 9;

“?” Metacharacters stipulate that their leading objects must appear consecutively 0 or one time in the target object

Can match the string such as: +123-999 999; +123-999 999; 123 999 999; +123 999999 etc.

*******************************************************************************

Verifying URLs

/^http[s]{0,1}:\/\/.+$/or/^http[s]{0,1}:\/\/.{ 1,n}$/(indicates the length of the URL string ("https://") + N)

\/: Denotes the character "/".

. Represents the set of all characters

+ equals {1,}, 1 to infinity.

*******************************************************************************

Verifying Pure Chinese characters

/^[\u4e00-\u9fa5]+$/

[\U4E00-\U9FA5]: estimated to be the range of Chinese character set

The above expressions are tested in the following JavaScript

<script language= "JavaScript" >

<!--

function regx (r,s)

{

if (r = = NULL | | r = = "") {

return false;

}

var patrn= new RegExp (R);

if (Patrn.exec (s))

return True

return False

}

-

</script>

<body>

<form>

Rule expression: <input type= "input" name= "Regxstr" value= "" > (fill in//Expression)

<br>

Checksum string: <input type= "input" name= "str" value= "" >

<input type= "button" name= "Match" value= "match" onclick= "alert (REGX (Regxstr.value,str.value));" >

</form>

</body>

4. The regular form of the use

"^\d+$"//nonnegative integer (positive integer + 0)
"^[0-9]*[1-9][0-9]*$"//Positive integer
"^ ((-\d+) | (0+)) $ "//non-positive integer (negative integer + 0)
"^-[0-9]*[1-9][0-9]*$"//Negative integer
"^-?\d+$"//Integer
"^\d+ (\.\d+)? $"//non-negative floating-point number (positive floating point + 0)
^ ([0-9]+\]. [0-9]*[1-9][0-9]*) | ([0-9]*[1-9][0-9]*\. [0-9]+) | ([0-9]*[1-9][0-9]*)) $ "//positive floating-point number
"^ ((-\d+ (\.\d+)?) | (0+ (\.0+)?)) $ "//non-positive floating-point number (negative floating-point number + 0)
^ (-([0-9]+\]. [0-9]*[1-9][0-9]*) | ([0-9]*[1-9][0-9]*\. [0-9]+) | ([0-9]*[1-9][0-9]*))) $ "//negative floating-point number
^ (-?\d+) (\.\d+)? $ "//floating-point number
"^[a-za-z]+$"//A string consisting of 26 English letters
"^[a-z]+$"//A string consisting of 26 uppercase letters in English
"^[a-z]+$"//String consisting of 26 English letters in lowercase
"^[a-za-z0-9]+$"//string consisting of a number and 26 English letters
"^\w+$"//A string consisting of numbers, 26 letters or underscores
"^[\w-]+ (\.[ \w-]+) *@[\w-]+ (\.[ \w-]+) +$ "//email address
"^[a-za-z]+://(\w+ (-\w+) *) (\. ( \w+ (-\w+) *) * (\?\s*)? $ "//url
/^ (D{2}|d{4})-((0 ([1-9]{1})) | ( 1[1|2])-(([0-2] ([1-9]{1})] | ( 3[0|1]) $///year-month-day
/^ ((0 ([1-9]{1})) | (1[1|2])) /([0-2] ([1-9]{1}) | (3[0|1])) /(D{2}|d{4}) $///month/day/year
^ ([w.] +) @ ([[[0-9]{1,3}. [0-9] {1,3}. [0-9] {1,3}.) | ([w-]+.) +)) ([a-za-z]{2,4}| [0-9] {1,3}) (]?) $ "//emil
"(d+-)?" (d{4}-?d{7}|d{3}-?d{8}|^d{7,8}) (-d+)? " Phone number
"^ (d{1,2}|1dd|2[0-4]d|25[0-5]). (D{1,2}|1dd|2[0-4]d|25[0-5]). (D{1,2}|1dd|2[0-4]d|25[0-5]). (D{1,2}|1dd|2[0-4]d|25[0-5]) $ "//IP address

^ ([0-9a-f]{2}) (-[0-9a-f]{2}) {5}$//mac address regular expression
^[-+]?\d+ (\.\d+)? $//value-type regular expression

5.javascript Regular Expression validation
Whether the checksum is all made up of numbers
function IsDigit (s)
{
var patrn=/^[0-9]{1,20}$/;
if (!patrn.exec (s)) return false
return True
}

Check login name: Only 5-20 entries begin with a letter, can be numbered, "_", "." The string
function Isregisterusername (s)
{
var patrn=/^[a-za-z]{1} ([a-za-z0-9]|[. _]) {4,19}$/;
if (!patrn.exec (s)) return false
return True
}

Verify user name: Only 1-30 strings beginning with a letter can be entered
function Istruename (s)
{
var patrn=/^[a-za-z]{1,30}$/;
if (!patrn.exec (s)) return false
return True
}

Check password: Only 6-20 letters, numbers, underscores can be entered
function ispasswd (s)
{
var patrn=/^ (\w) {6,20}$/;
if (!patrn.exec (s)) return false
return True
}

Check the ordinary telephone, fax number: Can "+" start, in addition to the number, can contain "-"
function Istel (s)
{
var patrn=/^[+]{0,1} (\d) {1,3}[]? ([-]? (\d) {1,12}) +$/;
var patrn=/^[+]{0,1} (\d) {1,3}[]? ([-]? ((\d) | []) {1,12}) +$/;
if (!patrn.exec (s)) return false
return True
}

Check mobile phone Number: Must start with a number, except the number, can contain "-"
function Ismobil (s)
{
var patrn=/^[+]{0,1} (\d) {1,3}[]? ([-]? ((\d) | []) {1,12}) +$/;
if (!patrn.exec (s)) return false
return True
}

Verifying ZIP Codes
function Ispostalcode (s)
{
var patrn=/^[a-za-z0-9]{3,12}$/;
var patrn=/^[a-za-z0-9]{3,12}$/;
if (!patrn.exec (s)) return false
return True
}

Verifying search Keywords
function Issearch (s)
{
var patrn=/^[^ ' [email protected]#$%^&* () +=|\\\][\]\{\}:;\ ' \,.<>/?] {1} [^ ' [email protected]$%^& () +=|\\\] [\]\{\}:;\ ' \,.<>?] {0,19}$/;
if (!patrn.exec (s)) return false
return True
}

Function IsIP (s)//by zergling
{
var patrn=/^[0-9. {1,20}$/;
if (!patrn.exec (s)) return false
return True
}


/*********************************************
* Function:isbetween
* Parameters:val as any value
* Lo as Lower limit to Check
* Hi as higher limit to check
* calls:nothing
* returns:true If Val are between Lo and hi both inclusive, otherwise false.
**********************************************************************************/
Function IsBetween ( Val, lo, hi) {
if (Val < lo) | | (val > Hi)) {return (false);}
Else {return (true);}
}

/*********************************************************************************
* Function:isdate checks a valid date
* Parameters:thestr as String
* Calls:isbetween, Isint
* Returns:true If THESTR is a valid date otherwise false.
**********************************************************************************/
function IsDate (THESTR) {
var the1st = thestr.indexof ('-');
var the2nd = thestr.lastindexof ('-');

if (the1st = = the2nd) {return (false);}
else {
var y = thestr.substring (0,the1st);
var m = thestr.substring (the1st+1,the2nd);
var d = thestr.substring (the2nd+1,thestr.length);
var maxdays = 31;

if (Isint (m) ==false | | isint (d) ==false | | isint (y) ==false) {
return (false); }
else if (Y.length < 4) {return (false);}
else if (!isbetween (M, 1,)) {return (false);}
else if (m==4 | | m==6 | | m==9 | | m==11) maxdays = 30;
else if (m==2) {
if (y% 4 > 0) maxdays = 28;
else if (y% = = 0 && y% > 0) maxdays = 28;
else maxdays = 29;
}
if (Isbetween (d, 1, maxdays) = = False) {return (false);}
else {return (true);}
}
}
/*********************************************************************************
* Function:iseudate checks a valid date in British format
* Parameters:thestr as String
* Calls:isbetween, Isint
* Returns:true If THESTR is a valid date otherwise false.
**********************************************************************************/
function Iseudate (THESTR) {
if (Isbetween (Thestr.length, 8,) = = False) {return (false);}
else {
var the1st = thestr.indexof ('/');
var the2nd = thestr.lastindexof ('/');

if (the1st = = the2nd) {return (false);}
else {
var m = thestr.substring (the1st+1,the2nd);
var d = thestr.substring (0,the1st);
var y = thestr.substring (the2nd+1,thestr.length);
var maxdays = 31;

if (Isint (m) ==false | | isint (d) ==false | | isint (y) ==false) {
return (false); }
else if (Y.length < 4) {return (false);}
else if (Isbetween (M, 1,) = = False) {return (false);}
else if (m==4 | | m==6 | | m==9 | | m==11) maxdays = 30;
else if (m==2) {
if (y% 4 > 0) maxdays = 28;
else if (y% = = 0 && y% > 0) maxdays = 28;
else maxdays = 29;
}

if (Isbetween (d, 1, maxdays) = = False) {return (false);}
else {return (true);}
}
}

}
/********************************************************************************
* Function:compare date! Which is the latest!
* Parameters:lessdate,moredate as String
* Calls:isdate,isbetween
* Returns:true If Lessdate<moredate
*********************************************************************************/
function Iscomdate (lessdate, Moredate)
{
if (!isdate (lessdate)) {return (false);}
if (!isdate (moredate)) {return (false);}
var less1st = lessdate.indexof ('-');
var less2nd = lessdate.lastindexof ('-');
var more1st = moredate.indexof ('-');
var more2nd = moredate.lastindexof ('-');
var Lessy = lessdate.substring (0,less1st);
var LESSM = lessdate.substring (less1st+1,less2nd);
var LESSD = lessdate.substring (less2nd+1,lessdate.length);
var morey = moredate.substring (0,more1st);
var morem = moredate.substring (more1st+1,more2nd);
var mored = moredate.substring (more2nd+1,moredate.length);
var Date1 = new Date (LESSY,LESSM,LESSD);
var Date2 = new Date (morey,morem,mored);
if (Date1>date2) {return (false);}
return (true);

}

/*********************************************************************************
* FUNCTION IsEmpty checks if the parameter is empty or null
* PARAMETER str as String
**********************************************************************************/
function IsEmpty (str) {
if ((str==null) | | | (str.length==0)) return true;
else return (false);
}

/*********************************************************************************
* Function:isint
* Parameter:thestr as String
* Returns:true If the passed parameter is an integer, otherwise FALSE
* Calls:isdigit
**********************************************************************************/
function Isint (THESTR) {
var flag = true;

if (IsEmpty (THESTR)) {flag=false;}
Else
{for (var i=0; i<thestr.length; i++) {
if (IsDigit (thestr.substring (i,i+1)) = = False) {
Flag = false; Break
}
}
}
return (flag);
}

/*********************************************************************************
* Function:isreal
* Parameter:hestr as String
Declen as Integer (how many digits after period)
* Returns:true If Thestr is a float, otherwise FALSE
* Calls:isint
**********************************************************************************/
function Isreal (THESTR, Declen) {
var dot1st = Thestr.indexof ('. ');
var dot2nd = Thestr.lastindexof ('. ');
var OK = true;

if (IsEmpty (THESTR)) return false;

if (dot1st = =-1) {
if (!isint (THESTR)) return (false);
else return (true);
}

else if (dot1st! = dot2nd) return (false);
else if (dot1st==0) return (false);
else {
var intpart = thestr.substring (0, dot1st);
var Decpart = thestr.substring (dot2nd+1);

if (Decpart.length > Declen) return (false);
else if (!isint (intpart) | |!isint (DECPART)) return (false);
else if (IsEmpty (Decpart)) return (false);
else return (true);
}
}

/*********************************************************************************
* Function:isemail
* Parameter:string (Email Address)
* Returns:true If the String is a valid Email address
* FALSE If the passed string is not a valid Email Address
* Email FORMAT: [email protected] e.g; [Email protected]
* @ sign can appear only once in the email address.
*********************************************************************************/
function Isemail (THESTR) {
var atindex = thestr.indexof (' @ ');
var dotindex = Thestr.indexof ('. ', Atindex);
var flag = true;
Thesub = thestr.substring (0, dotindex+1)

if ((Atindex < 1) | | (Atindex! = Thestr.lastindexof (' @ ')) | | (Dotindex < Atindex + 2) | | (Thestr.length <= thesub.length))
{return (false);}
else {return (true);}
}
/*********************************************************************************
* Function:newwindow
* Parameters:doc, Document to open in the new window
Hite, Height of the new window
Wide-Width of the new window
Bars-1-scroll bars = YES 0-scroll bars = NO
Resize-1-resizable = YES 0-resizable = NO
* Calls:none
* Returns:new Window instance
**********************************************************************************/
function NewWindow (doc, Hite, wide, bars, resize) {
var winnew= "_blank";
var opt= "toolbar=0,location=0,directories=0,status=0,menubar=0,";
opt+= ("scrollbars=" +bars+ ",");
opt+= ("resizable=" +resize+ ",");
opt+= ("width=" +wide+ ",");
opt+= ("height=" +hite);
Winhandle=window.open (doc,winnew,opt);
Return
}
/*********************************************************************************
* Function:decimalformat
* Parameters:paramvalue, Field value
* Calls:none
* Returns:formated String
**********************************************************************************/
function DecimalFormat (paramvalue) {
var Intpart = parseint (paramvalue);
var decpart =parsefloat (paramvalue)-Intpart;

str = "";
if ((Decpart = = 0) | | (Decpart = = null)) str + = (Intpart + ". 00");
else str + = (Intpart + decpart);

return (str);
}

"^\\d+$"//nonnegative integer (positive integer + 0)
"^[0-9]*[1-9][0-9]*$"//Positive integer
"^ ((-\\d+) | (0+)) $ "//non-positive integer (negative integer + 0)
"^-[0-9]*[1-9][0-9]*$"//Negative integer
"^-?\\d+$"//Integer
"^\\d+ (\\.\\d+)? $"//non-negative floating-point number (positive floating point + 0)
^ ([0-9]+\\]. [0-9]*[1-9][0-9]*) | ([0-9]*[1-9][0-9]*\\. [0-9]+) | ([0-9]*[1-9][0-9]*)) $ "//positive floating-point number
"^ ((-\\d+ (\\.\\d+)?) | (0+ (\\.0+)?)) $ "//non-positive floating-point number (negative floating-point number + 0)
^ (-([0-9]+\\]. [0-9]*[1-9][0-9]*) | ([0-9]*[1-9][0-9]*\\. [0-9]+) | ([0-9]*[1-9][0-9]*))) $ "//negative floating-point number
^ (-?\\d+) (\\.\\d+)? $ "//floating-point number
"^[a-za-z]+$"//A string consisting of 26 English letters
"^[a-z]+$"//A string consisting of 26 uppercase letters in English
"^[a-z]+$"//String consisting of 26 English letters in lowercase
"^[a-za-z0-9]+$"//string consisting of a number and 26 English letters
"^\\w+$"//A string consisting of numbers, 26 letters or underscores
"^[\\w-]+ (\\.[ \\w-]+) *@[\\w-]+ (\\.[ \\w-]+) +$ "//email address
"^[a-za-z]+://(\\w+ (-\\w+) *) ( \\w+ (-\\w+) *) * (\\?\\s*)? $ "//url

A small summary of regular expressions