JS正则表达式基础

正则表达式的作用: 
    测试字符串的某个模式
    替换文本
    根据模式匹配从字符串中提取一个子字符串。可以用来在文本或输入字段中查找特定文字

[^\d]/g
这是一个正则表达式,在JS中正则表达式用//表示，跟在其后的是匹配选项，比如是g表示匹配全局。比如是i则表示忽略大小写，等等，这是匹配模式。
[]则是定界符，其中的字符会出现一次，而[^]则是一个否定运算，表示其中的字符不能出现！如[A-Z]就表示出现一次A-Z中的任何一个字符（当然是大写）如果是[AZ]则表示出现A或Z。[^A-Z]则表示出现的字符不能是A-Z中的任何一个！
而[^0-9]则表示不能出现0-9中的任何一个！其实咱也可以换一种说法，不能出现任何一个数字，那么就可以表示成为[^\d]，其中\d是元字符，表示一个数字。那么这里就是不能出现任何一个数字而已！


Java代码  :
var re = new RegExp();//RegExp是一个对象,和Aarray一样       
//但这样没有任何效果,需要将正则表达式的内容作为字符串传递进去       
re =new RegExp("a");//最简单的正则表达式,将匹配字母a       
re=new RegExp("a","i");//第二个参数,表示匹配时不分大小写     
var re = new RegExp();//RegExp是一个对象,和Aarray一样    
//但这样没有任何效果,需要将正则表达式的内容作为字符串传递进去    
re =new RegExp("a");//最简单的正则表达式,将匹配字母a    
re=new RegExp("a","i");//第二个参数,表示匹配时不分大小写   

RegExp构造函数第一个参数为正则表达式的文本内容,而第一个参数则为可选项标志.标志可以组合使用

g （全文查找）
i （忽略大小写）
m （多行查找）

var re = new RegExp("a","gi");//匹配所有的a或A   

正则表达式还有另一种正则表达式字面量的声明方式
var re = /a/gi;  

正则表达式对象的方法
test,返回一个 Boolean 值，它指出在被查找的字符串中是否存在模式。如果存在则返回 true，否则就返回 false。
exec,用正则表达式模式在字符串中运行查找，并返回包含该查找结果的一个数组。
compile,把正则表达式编译为内部格式，从而执行得更快。

正则表达式对象的属性
source,返回正则表达式模式的文本的复本。只读。
lastIndex,返回字符位置，它是被查找字符串中下一次成功匹配的开始位置。

match,找到一个或多个正则表达式的匹配。
replace,替换与正则表达式匹配的子串。
search,检索与正则表达式相匹配的值。
split,把字符串分割为字符串数组。

Java代码  :
var re = /he/;//最简单的正则表达式,将匹配he这个单词       
var str = "he";       
alert(re.test(str));//true       
str = "we";       
alert(re.test(str));//false  
str = "HE";       
alert(re.test(str));//false,大写,如果要大小写都匹配可以指定i标志(i是ignoreCase或case-insensitive的表示)     
re = /he/i;       
alert(re.test(str));//true  
str = "Certainly!He loves her!";       
alert(re.test(str));//true,只要包含he(HE)就符合,如果要只是he或HE,不能有其它字符,则可使用^和$   
re = /^he/i;//脱字符(^)代表字符开始位置       
alert(re.test(str));//false,因为he不在str最开始       
str = "He is a good boy!";       
alert(re.test(str));//true,He是字符开始位置,还需要使用$       
re = /^he$/i;//$表示字符结束位置       
alert(re.test(str));//false       
str = "He";       
alert(re.test(str));//true  
re = /\s/;// \s匹配任何空白字符，包括空格、制表符、换页符等等      
str= "user Name";//用户名包含空格       
alert(re.test(str));//true       
str = "user     Name";//用户名包含制表符       
alert(re.test(str));//true       
 
re = /\s/;// \s匹配任何空白字符，包括空格、制表符、换页符等等       
str= "user Name";//用户名包含空格       
alert(re.test(str));//true       
str = "user     Name";//用户名包含制表符       
alert(re.test(str));//true       
re=/^[a-z]/i;//[]匹配指定范围内的任意字符,这里将匹配英文字母,不区分大小写       
str="variableName";//变量名必须以字母开头       
alert(re.test(str));//true       
str="123abc";       
alert(re.test(str));//false   
var re = /he/;//最简单的正则表达式,将匹配he这个单词    
var str = "he";    
alert(re.test(str));//true    
str = "we";    
alert(re.test(str));//false
str = "HE";    
alert(re.test(str));//false,大写,如果要大小写都匹配可以指定i标志(i是ignoreCase或case-insensitive的表示)  
re = /he/i;    
alert(re.test(str));//true
str = "Certainly!He loves her!";    
alert(re.test(str));//true,只要包含he(HE)就符合,如果要只是he或HE,不能有其它字符,则可使用^和$
re = /^he/i;//脱字符(^)代表字符开始位置    
alert(re.test(str));//false,因为he不在str最开始    
str = "He is a good boy!";    
alert(re.test(str));//true,He是字符开始位置,还需要使用$    
re = /^he$/i;//$表示字符结束位置    
alert(re.test(str));//false    
str = "He";    
alert(re.test(str));//true
re = /\s/;// \s匹配任何空白字符，包括空格、制表符、换页符等等   
str= "user Name";//用户名包含空格    
alert(re.test(str));//true    
str = "user     Name";//用户名包含制表符    
alert(re.test(str));//true    

re = /\s/;// \s匹配任何空白字符，包括空格、制表符、换页符等等    
str= "user Name";//用户名包含空格    
alert(re.test(str));//true    
str = "user     Name";//用户名包含制表符    
alert(re.test(str));//true    
re=/^[a-z]/i;//[]匹配指定范围内的任意字符,这里将匹配英文字母,不区分大小写    
str="variableName";//变量名必须以字母开头    
alert(re.test(str));//true    
str="123abc";    
alert(re.test(str));//false   
    
+号表示字符至少要出现1次,\d表示一个数字
Java代码  :
var osVersion = "Ubuntu 8";//其中的8表示系统主版本号      
var re = /^[a-z]+\s+\d+$/i;  
alert(re.test(osVersion));  
 
re=/^[a-z]+\s+\d+$/i;       
arr = re.exec(osVersion);       
alert(arr[0]);//将osVersion完整输出,因为整个字符串刚好匹配re  
 
re=/\d+/;       
var arr = re.exec(osVersion);       
alert(arr[0]);//8     
var osVersion = "Ubuntu 8";//其中的8表示系统主版本号   
var re = /^[a-z]+\s+\d+$/i;
alert(re.test(osVersion));

re=/^[a-z]+\s+\d+$/i;    
arr = re.exec(osVersion);    
alert(arr[0]);//将osVersion完整输出,因为整个字符串刚好匹配re

re=/\d+/;    
var arr = re.exec(osVersion);    
alert(arr[0]);//8   

用()来创建子匹配

Java代码  :
re=/^[a-z]+\s+(\d+)$/i;      
arr =re.exec(osVersion);       
alert(arr[0]);//整个osVersion,也就是正则表达式的完整匹配       
alert(arr[1]);//8,第一个子匹配,事实也可以这样取出主版本号  
alert(arr.length);//2   
re=/^[a-z]+\s+(\d+)$/i;   
arr =re.exec(osVersion);    
alert(arr[0]);//整个osVersion,也就是正则表达式的完整匹配    
alert(arr[1]);//8,第一个子匹配,事实也可以这样取出主版本号
alert(arr.length);//2   

.是正则表达式元字符之一,若要用它的字面意义须转义
Java代码  :
osVersion = "Ubuntu 8.10";//取出主版本号和次版本号       
re = /^[a-z]+\s+(\d+)\.(\d+)$/i;       
arr = re.exec(osVersion);       
alert(arr[0]);//完整的osVersion       
alert(arr[1]);//8       
alert(arr[2]);//10    
osVersion = "Ubuntu 8.10";//取出主版本号和次版本号    
re = /^[a-z]+\s+(\d+)\.(\d+)$/i;    
arr = re.exec(osVersion);    
alert(arr[0]);//完整的osVersion    
alert(arr[1]);//8    
alert(arr[2]);//10  

注意,当字符串不匹配re时,exec方法将返回null

String对象的一些和正则表达式有关的方法

Java代码  :
var str ="some money";       
alert(str.replace("some","much"));//much money    
 
var re = /\s/;//空白字符       
alert(str.replace(re,"%"));//some%money  
var str ="some money";    
alert(str.replace("some","much"));//much money 

var re = /\s/;//空白字符    
alert(str.replace(re,"%"));//some%money    

//在不知道字符串中有多少空白字符时,正则表达式极为方便    
str ="some some             \tsome\t\f";    
re = /\s+/;    
alert(str.replace(re,"#"));

//但这样只会将第一次出现的一堆空白字符替换掉
//因为一个正则表达式只能进行一次匹配,\s+匹配了第一个空格后就退出了

re = /\s+/g;//g,全局标志,将使正则表达式匹配整个字符串
alert(str.replace(re,"@"));//some@some@some@

split:分割
var str = "a-bd-c";    
var arr = str.split("-");//返回["a","bd","c"]    

re=/[^a-z]/i;//前面我们说^表示字符开始,但在[]里它表示一个负字符集      
//匹配任何不在指定范围内的任意字符,这里将匹配除字母处的所有字符

str = "a_db-c";
arr = str.split(re);//仍返回["a","bd","c"];

//在字符串中查找时我们常用indexOf,与之对应用于正则查找的方法是search    
str = "My age is 18.Golden age!";//年龄不是一定的,我们用indexOf不能查找它的位置    
re = /\d+/;    
alert(str.search(re));//返回查找到的字符串开始下标10    
//注意,因为查找本身就是出现第一次就立即返回,所以无需在search时使用g标志
当search方法没有找到匹配时,将返回-1

类似于exec方法,String对象的match方法也用于将字符串与正则表达式进行匹配并返回结果数组

Java代码  :
var str = "My name is CJ.Hello everyone!";       
var re = /[A-Z]/;//匹配所有大写字母       
var arr = str.match(re);//返回数组       
alert(arr);//数组中只会包含一个M,因为我们没有使用全局匹配       
re = /[A-Z]/g;       
arr = str.match(re);       
alert(arr);//M,C,J,H 
var str = "My name is CJ.Hello everyone!";    
var re = /[A-Z]/;//匹配所有大写字母    
var arr = str.match(re);//返回数组    
alert(arr);//数组中只会包含一个M,因为我们没有使用全局匹配    
re = /[A-Z]/g;    
arr = str.match(re);    
alert(arr);//M,C,J,H\b表示单词边界
   
//从字符串中抽取单词    

Java代码  :
re = /\b[a-z]*\b/gi;//      
str = "one two three four";       
alert(str.match(re));//one,two,three,four 
re = /\b[a-z]*\b/gi;//   
str = "one two three four";    
alert(str.match(re));//one,two,three,four

var re = /[a-z]/i;    
alert(re.source);//将[a-z]字符串输出
//请注意,直接alert(re)会将正则表达式连同前向斜线与标志输出,这是re.toString方法定义的   

每个RegExp对象的实例具有lastIndex属性,它是被查找字符串中下一次成功匹配的开始位置,
默认值是-1。 lastIndex 属性被 RegExp 对象的 exec 和 test 方法修改.并且它是可写的.

Java代码  :
var re = /[A-Z]/;       
//exec方法执行后,修改了re的lastIndex属性,       
var str = "Hello,World!!!";       
var arr = re.exec(str);       
alert(re.lastIndex);//0,因为没有设置全局标志       
re = /[A-Z]/g;       
arr = re.exec(str);       
alert(re.lastIndex);//1       
arr = re.exec(str);       
alert(re.lastIndex);//7   
var re = /[A-Z]/;    
//exec方法执行后,修改了re的lastIndex属性,    
var str = "Hello,World!!!";    
var arr = re.exec(str);    
alert(re.lastIndex);//0,因为没有设置全局标志    
re = /[A-Z]/g;    
arr = re.exec(str);    
alert(re.lastIndex);//1    
arr = re.exec(str);    
alert(re.lastIndex);//7   
当匹配失败（后面没有匹配），或lastIndex值大于字符串长度时，再执行exec等方法会将lastIndex设为0(开始位置)
Js代码 

Java代码  :
var re = /[A-Z]/;       
var str = "Hello,World!!!";       
re.lastIndex = 120;       
var arr = re.exec(str);       
alert(re.lastIndex);//0     
var re = /[A-Z]/;    
var str = "Hello,World!!!";    
re.lastIndex = 120;    
var arr = re.exec(str);    
alert(re.lastIndex);//0   
RegExp对象的静态属性
//input 最后用于匹配的字符串（传递给test,exec方法的字符串）

Java代码  :
var re = /[A-Z]/;       
var str = "Hello,World!!!";       
var arr = re.exec(str);       
alert(RegExp.input);//Hello,World!!!       
re.exec("tempstr");       
alert(RegExp.input);//仍然是Hello,World!!!,因为tempstr不匹配      
var re = /[A-Z]/;    
var str = "Hello,World!!!";    
var arr = re.exec(str);    
alert(RegExp.input);//Hello,World!!!    
re.exec("tempstr");    
alert(RegExp.input);//仍然是Hello,World!!!,因为tempstr不匹配     //lastMatch 最后匹配的字符    
re = /[a-z]/g;    
str = "hi";    
re.test(str);    
alert(RegExp.lastMatch);//h    
re.test(str);    
alert(RegExp["$&"]);//i  ,$&是lastMatch的短名字，但由于它不是合法变量名，所以要。。

    
//lastParen 最后匹配的分组    
Java代码  :
re = /[a-z](\d+)/gi;       
str = "Class1 Class2 Class3";       
re.test(str);       
alert(RegExp.lastParen);//1       
re.test(str);       
alert(RegExp["$+"]);//2    
re = /[a-z](\d+)/gi;    
str = "Class1 Class2 Class3";    
re.test(str);    
alert(RegExp.lastParen);//1    
re.test(str);    
alert(RegExp["$+"]);//2    

//leftContext  返回被查找的字符串中从字符串开始位置到最后匹配之前的位置之间的字符    
//rigthContext 返回被搜索的字符串中从最后一个匹配位置开始到字符串结尾之间的字符    

Java代码  :
re = /[A-Z]/g;       
str = "123ABC456";       
re.test(str);       
alert(RegExp.leftContext);//123       
alert(RegExp.rightContext);//BC456       
re.test(str);       
alert(RegExp["$`"]);//123A       
alert(RegExp["$‘"]);//C456   
re = /[A-Z]/g;    
str = "123ABC456";    
re.test(str);    
alert(RegExp.leftContext);//123    
alert(RegExp.rightContext);//BC456    
re.test(str);    
alert(RegExp["$`"]);//123A    
alert(RegExp["$‘"]);//C456   

元字符：
元字符是正则表达式的一部分，当我们要匹配正则表达式本身时，必须对这些元字符转义.
下面是正则表达式用到的所有元字符 ，( [ { \ ^ $ | ) ? * + .

Java代码  :
var str = "?";       
var re = /?/;       
alert(re.test(str));//出错，因为？是元字符，必须转义       
re = /\?/;       
alert(re.test(str));//true  
    var str = "?";    
    var re = /?/;    
    alert(re.test(str));//出错，因为？是元字符，必须转义    
    re = /\?/;    
    alert(re.test(str));//true   

使用RegExp构造函数与使用正则表达式字面量创建正则表达式注意点

Java代码  :
var str = "\?";       
alert(str);//只会输出?       
var re = /\?/;//将匹配?       
alert(re.test(str));//true       
re = new RegExp("\?");//出错,因为这相当于re = /?/       
re = new RegExp("\\?");//正确，将匹配？       
alert(re.test(str));//true    
var str = "\?";    
alert(str);//只会输出?    
var re = /\?/;//将匹配?    
alert(re.test(str));//true    
re = new RegExp("\?");//出错,因为这相当于re = /?/    
re = new RegExp("\\?");//正确，将匹配？    
alert(re.test(str));//true  

既然双重转义这么不友好，所以还是用正则表达式字面量的声明方式

如何在正则表达式中使用特殊字符？

//ASCII方式用十六进制数来表示特殊字符    

Java代码  :
var re = /^\x43\x4A$/;//将匹配CJ       
alert(re.test("CJ"));//true       
//也可使用八进制方式       
re = /^\103\112$/;//将匹配CJ       
alert(re.test("CJ"));//true       
//还可以使用Unicode编码       
re =/^\u0043\u004A$/;//使用 Unicode，必须使用u开头，接着是字符编码的四位16进制表现形式       
alert(re.test("CJ"));     
var re = /^\x43\x4A$/;//将匹配CJ    
alert(re.test("CJ"));//true    
//也可使用八进制方式    
re = /^\103\112$/;//将匹配CJ    
alert(re.test("CJ"));//true    
//还可以使用Unicode编码    
re =/^\u0043\u004A$/;//使用 Unicode，必须使用u开头，接着是字符编码的四位16进制表现形式    
alert(re.test("CJ"));   

ASCII方式用十六进制数来表示特殊字符

Java代码  :
var re = /^\x43\x4A$/;//将匹配CJ    
alert(re.test("CJ"));//true  
    
也可使用八进制方式    
re = /^\103\112$/;//将匹配cj    
alert(re.test("CJ"));//true    
 
//还可以使用Unicode编码    
re =/^\u0043\u004A$/;//使用 Unicode，必须使用u开头，接着是字符编码的四位16进制表现形式    
alert(re.test("CJ"));   
var re = /^\x43\x4A$/;//将匹配CJ 
alert(re.test("CJ"));//true
 
也可使用八进制方式 
re = /^\103\112$/;//将匹配cj 
alert(re.test("CJ"));//true 

//还可以使用Unicode编码 
re =/^\u0043\u004A$/;//使用 Unicode，必须使用u开头，接着是字符编码的四位16进制表现形式 
alert(re.test("CJ")); 

其它特殊字符
\n      换行符
\r      回车符
\t      制表符
\f      换页符（Tab）
\cX     与X对应的控制字符
\b      退格符(BackSpace)
\v      垂直制表符
\0      空字符("")

//简单类    
var re = /[abc123]/;//将匹配abc123这6个字符中一个    
//负向类    
re = /[^abc]/;//将匹配除abc之外的一个字符

//范围类    
re = /[a-b]/;//将匹配小写a-b 26个字母    

re = /[^0-9]/;//将匹配除0-9 10个字符之处的一个字符   

//组合类    
re = /[a-b0-9A-Z_]/;//将匹配字母，数字和下划线       

\d    [0-9]                   匹配数字
\D    [^0-9]                  匹配非数字字符
\s    [ \n\r\t\f\x0B]         匹配一个空白字符
\S    [^ \n\r\t\f\x0B]        匹配一个非空白字符
\w    [a-zA-Z0-9_]            匹配字母数字和下划线
\W    [^a-zA-Z0-9_]           匹配除字母数字下划线之外的字符

量词：
*     匹配前面的子表达式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"。 * 等价于{0,}。
+     匹配前面的子表达式一次或多次。例如，‘zo+‘ 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等价于 {1,}。
?     匹配前面的子表达式零次或一次。例如，"do(es)?" 可以匹配 "do" 或 "does" 中的"do" 。? 等价于 {0,1}。
{n}   n 是一个非负整数。匹配确定的 n 次。例如，‘o{2}‘ 不能匹配 "Bob" 中的 ‘o‘，但是能匹配 "food" 中的两个 o。
{n,}  n 是一个非负整数。至少匹配n 次。例如，‘o{2,}‘ 不能匹配 "Bob" 中的 ‘o‘，但能匹配 "foooood" 中的所有 o。‘o{1,}‘ 等价于 ‘o+‘。‘o{0,}‘ 则等价于 ‘o*‘。
{n,m} m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。刘， "o{1,3}" 将匹配 "fooooood" 中的前三个 o。‘o{0,1}‘ 等价于 ‘o?‘。请注意在逗号和两个数之间不能有空格。

用贪婪量词进行匹配时，它首先会将整会字符串当成一个匹配，如果匹配的话就退出，
如果不匹配，就截去最后一个字符进行匹配，如果不匹配，继续将最后一个字符截去进行匹配，直到有匹配为止。
直到现在我们遇到的量词都是贪婪量词

用惰性量词进行匹配时，它首先将第一个字符当成一个匹配，如果成功则退出，
如果失败，则测试前两个字符，依些增加，直到遇到合适的匹配为止

惰性量词仅仅在贪婪量词后面加个"?"而已,如"a+"是贪婪匹配的,"a+?"则是惰性的

Java代码  :
var str = "abc";       
var re = /\w+/;//将匹配abc       
re = /\w+?/;//将匹配a      
 
 
var re = /[a-z]$/;       
var str = "ab\ncdef";       
alert(str.replace(re,"#"));//ab\ncde#       
re =/[a-z]$/m;       
alert(str.replace(re,"#"));//a#\ncde#      
 
 
re = /abc{2}/;//将匹配abcc       
re = /(abc){2}/;//将匹配abcabc       
//上面的分组都是捕获性分组       
str = "abcabc ###";       
arr = re.exec(str);       
alert(arr[1]);//abc  
       
//非捕获性分组 (?:)       
re = /(?:abc){2}/;       
arr = re.exec(str);       
alert(arr[1]);//undefined      
 
   
 
 re = /^a|bc$/;//将匹配开始位置的a或结束位置的bc       
str ="add";       
alert(re.test(str));//true       
re = /^(a|bc)$/;//将匹配a或bc       
str ="bc";       
alert(re.test(str));//true 
var str = "abc";    
var re = /\w+/;//将匹配abc    
re = /\w+?/;//将匹配a   

var re = /[a-z]$/;    
var str = "ab\ncdef";    
alert(str.replace(re,"#"));//ab\ncde#    
re =/[a-z]$/m;    
alert(str.replace(re,"#"));//a#\ncde#   

re = /abc{2}/;//将匹配abcc    
re = /(abc){2}/;//将匹配abcabc    
//上面的分组都是捕获性分组    
str = "abcabc ###";    
arr = re.exec(str);    
alert(arr[1]);//abc
    
//非捕获性分组 (?:)    
re = /(?:abc){2}/;    
arr = re.exec(str);    
alert(arr[1]);//undefined   

 re = /^a|bc$/;//将匹配开始位置的a或结束位置的bc    
str ="add";    
alert(re.test(str));//true    
re = /^(a|bc)$/;//将匹配a或bc    
str ="bc";    
alert(re.test(str));//true
当包含分组的正则表达式进行过test,match,search这些方法之后，每个分组都被放在一个特殊的地方以备将来使用，
这些存储是分组中的特殊值，我们称之为反向引用。

Java代码  :
var re = /(A?(B?(C?)))/;       
/*上面的正则表达式将依次产生三个分组    
(A?(B?(C?))) 最外面的    
(B?(C?))    
(C?)*/       
str = "ABC";       
re.test(str);//反向引用被存储在RegExp对象的静态属性$1—$9中       
alert(RegExp.$1+"\n"+RegExp.$2+"\n"+RegExp.$3);       
//反向引用也可以在正则表达式中使用\1 ,\2...这类的形式使用       
re = /\d+(\D)\d+\1\d+/;       
str = "2008-1-1";       
alert(re.test(str));//true       
str = "2008-4_3";       
alert(re.test(str));//false     
var re = /(A?(B?(C?)))/;    
/*上面的正则表达式将依次产生三个分组  
(A?(B?(C?))) 最外面的  
(B?(C?))  
(C?)*/    
str = "ABC";    
re.test(str);//反向引用被存储在RegExp对象的静态属性$1—$9中    
alert(RegExp.$1+"\n"+RegExp.$2+"\n"+RegExp.$3);    
//反向引用也可以在正则表达式中使用\1 ,\2...这类的形式使用    
re = /\d+(\D)\d+\1\d+/;    
str = "2008-1-1";    
alert(re.test(str));//true    
str = "2008-4_3";    
alert(re.test(str));//false       

使用反向引用可以要求字符串中某几个位置上的字符必须相同.另外，在replace这类方法中可用特殊字符序列来表示反向引用
re = /(\d)\s(\d)/;    
str = "1234 5678";    
alert(str.replace(re,"$2 $1"));//在这个里面$1表示第一个分组1234,$2则表示5678

构建一个验证电子邮箱地址有效性的正则表达式
  要求：用户名只能包含字母数字以及下划线，最少一位，最多25位，
  用户名后面紧跟@，后面是域名，
  域名名称要求只能包含字母数字和减号（-），并且不能以减号开头或结尾，然后后面是域名后缀（可以有多个），域名后缀必须是点号连上2-4位英文字母
  var re = /^\w{2,15}(?:@(?!-))(?:(?:[a-z0-9-]*)(?:[a-z0-9](?!-))(?:\.(?!-)))+[a-z]{2,4}$/;

常用正则表达式：
匹配中文字符的正则表达式： [u4e00-u9fa5]
匹配双字节字符(包括汉字在内)：[^x00-xff]
匹配HTML标记的正则表达式：< (S*?)[^>]*>.*?|< .*? />
匹配Email地址的正则表达式：w+([-+.]w+)*@w+([-.]w+)*.w+([-.]w+)*
匹配网址URL的正则表达式：[a-zA-z]+://[^s]*
匹配国内电话号码：d{3}-d{8}|d{4}-d{7}

匹配腾讯QQ号：[1-9][0-9]{4,}
评注：腾讯QQ号从10000开始

匹配身份证：d{15}|d{18}
评注：中国的身份证为15位或18位

匹配中国邮政编码：[1-9]d{5}(?!d)
评注：中国邮政编码为6位数字

匹配ip地址：d+.d+.d+.d+
评注：提取ip地址时有用

验证InternetURL：“^http://([w-]+.)+[w-]+(/[w-./?%&=]*)?$”

(x) 匹配x保存x在名为$1...$9的变量中
[xyz] 字符集(character set)，匹配这个集合中的任一一个字符(或元字符)
[\b] 匹配一个退格符
b 匹配一个单词的边界
\B 匹配一个单词的非边界
\ f 换页符