`
阅读更多
正则表达式详解   以一个简单例子开始此文档,详细解析参见下面内容: var str = "windows 98 windows 2000 windows 2003"; var reg=/windows 2000|98|2003/; var result = str.match(reg); document.write("windows 2000|98|2003 : "+result+ "<br/>"); var reg1=/windows (98|2000|2003)/; var result = str.match(reg1); document.write("windows (2000|98|2003) : "+result+ "<br/>"); var reg1_1=/(windows (98|2000|2003))/; var result = str.match(reg1_1); document.write("(windows (98|2000|2003)) : "+result+ "<br/>"); var reg2=/windows (?:98|2000|2003)/; var result = str.match(reg2); document.write("windows (?:98|2000|2003) : "+result+ "<br/>"); var reg3=/windows (?=98|2000)/; var result = str.match(reg3); document.write("windows (?=98|2000) : "+result+ "<br/>"); var reg4=/windows (?!98|2000)/; var result = str.match(reg4); document.write("windows (?!98|2000): "+result+ "<br/>"); //输出结果 /* windows 2000|98|2003 : 98 //其中windwos 2000与98处于同等地位,即windwos 2000是一组,98是一组 //解析以下两个实例:当match函数在满足如下条件下将越俎代庖,实现和exec一样的功能: 1、正则表达式中含有分组(括号) 2、返回唯一的匹配 详细解析可参照http://maoting.iteye.com/admin/blogs/1554477 windows (2000|98|2003) : windows 98,98 (windows (98|2000|2003)) : windows 98,windows 98,98 //为输出分组(非捕获数组) windows (?:98|2000|2003) : windows 98 //?=向前正向匹配 windows (?=98|2000) : windows ?:向前负向匹配 windows (?!98|2000): windows */     var str = "html windows 98 windows 98 windows 2003"; var reg3=/(?=(windows 98([\s])))\1\2/; var result = str.match(reg3); document.write("(?=(windows 98([\s])))\1\2 : "+result+ "<br/>"); //其中分组2 为[\s],而不是windows 98([\s])。?=、?!、?:都属于非捕获组(从上个例子中总结出来的,因为match没有返回分组的信息)    以下内容转自:http://www.iteye.com/topic/481228  正则表达式可以: 
•测试字符串的某个模式。例如,可以对一个输入字符串进行测试,看在该字符串是否存在一个电话号码模式或一个信用卡号码模式。这称为数据有效性验证 
•替换文本。可以在文档中使用一个正则表达式来标识特定文字,然后可以全部将其删除,或者替换为别的文字 
•根据模式匹配从字符串中提取一个子字符串。可以用来在文本或输入字段中查找特定文字 

正则表达式语法 
一个正则表达式就是由普通字符(例如字符 a 到 z)以及特殊字符(称为元字符)组成的文字模式。该模式描述在查找文字主体时待匹配的一个或多个字符串。正则表达式作为一个模板,将某个字符模式与所搜索的字符串进行匹配。 

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


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

•g (全文查找) 
•i (忽略大小写) 
•m (多行查找)
Js代码   收藏代码
  1. var  re =  new  RegExp( "a" , "gi" ); //匹配所有的a或A   

正则表达式还有另一种正则表达式字面量的声明方式
Js代码   收藏代码
  1. var  re = /a/gi;  


和正则表达式相关的方法和属性 


正则表达式对象的方法 

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

•source,返回正则表达式模式的文本的复本。只读。 
•lastIndex,返回字符位置,它是被查找字符串中下一次成功匹配的开始位置。 
•$1...$9,返回九个在模式匹配期间找到的、最近保存的部分。只读。 
•input ($_),返回执行规范表述查找的字符串。只读。 
•lastMatch ($&),返回任何正则表达式搜索过程中的最后匹配的字符。只读。 
•lastParen ($+),如果有的话,返回任何正则表达式查找过程中最后括的子匹配。只读。 
•leftContext ($`),返回被查找的字符串中从字符串开始位置到最后匹配之前的位置之间的字符。只读。 
•rightContext ($'),返回被搜索的字符串中从最后一个匹配位置开始到字符串结尾之间的字符。只读。 
String对象一些和正则表达式相关的方法  

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


测试正则表达式是如何工作的!
Js代码   收藏代码
  1. //test方法,测试字符串,符合模式时返回true,否则返回false   
  2. var  re = /he/; //最简单的正则表达式,将匹配he这个单词   
  3. var  str =  "he" ;  
  4. alert(re.test(str));//true   
  5. str = "we" ;  
  6. alert(re.test(str));//false   
  7. str = "HE" ;  
  8. alert(re.test(str));//false,大写,如果要大小写都匹配可以指定i标志(i是ignoreCase或case-insensitive的表示)   
  9. re = /he/i;  
  10. alert(re.test(str));//true   
  11. str = "Certainly!He loves her!" ;  
  12. alert(re.test(str));//true,只要包含he(HE)就符合,如果要只是he或HE,不能有其它字符,则可使用^和$   
  13. re = /^he/i;//脱字符(^)代表字符开始位置   
  14. alert(re.test(str));//false,因为he不在str最开始   
  15. str = "He is a good boy!" ;  
  16. alert(re.test(str));//true,He是字符开始位置,还需要使用$   
  17. re = /^he$/i;//$表示字符结束位置   
  18. alert(re.test(str));//false   
  19. str = "He" ;  
  20. alert(re.test(str));//true   
  21. //当然,这样不能发现正则表达式有多强大,因为我们完全可以在上面的例子中使用==或indexOf   
  22. re = /\s/;// \s匹配任何空白字符,包括空格、制表符、换页符等等   
  23. str= "user Name" ; //用户名包含空格   
  24. alert(re.test(str));//true   
  25. str = "user     Name" ; //用户名包含制表符   
  26. alert(re.test(str));//true   
  27. re=/^[a-z]/i;//[]匹配指定范围内的任意字符,这里将匹配英文字母,不区分大小写   
  28. str="variableName" ; //变量名必须以字母开头   
  29. alert(re.test(str));//true   
  30. str="123abc" ;  
  31. alert(re.test(str));//false   


当然,仅仅知道了字符串是否匹配模式还不够,我们还需要知道哪些字符匹配了模式
Js代码   收藏代码
  1. var  osVersion =  "Ubuntu 8" ; //其中的8表示系统主版本号   
  2. var  re = /^[a-z]+\s+\d+$/i;  //+号表示字符至少要出现1次,\s表示空白字符,\d表示一个数字   
  3. alert(re.test(osVersion));//true,但我们想知道主版本号   
  4. //另一个方法exec,返回一个数组,数组的第一个元素为完整的匹配内容   
  5. re=/^[a-z]+\s+\d+$/i;  
  6. arr = re.exec(osVersion);  
  7. alert(arr[0]);//将osVersion完整输出,因为整个字符串刚好匹配re   
  8. //我只需要取出数字   
  9. re=/\d+/;  
  10. var  arr = re.exec(osVersion);  
  11. alert(arr[0]);//8   


更复杂的用法,使用子匹配
Js代码   收藏代码
  1. //exec返回的数组第1到n元素中包含的是匹配中出现的任意一个子匹配   
  2. re=/^[a-z]+\s+(\d+)$/i;//用()来创建子匹配   
  3. arr =re.exec(osVersion);  
  4. alert(arr[0]);//整个osVersion,也就是正则表达式的完整匹配   
  5. alert(arr[1]);//8,第一个子匹配,事实也可以这样取出主版本号   
  6. alert(arr.length);//2   
  7. osVersion = "Ubuntu 8.10" ; //取出主版本号和次版本号   
  8. re = /^[a-z]+\s+(\d+)\.(\d+)$/i;//.是正则表达式元字符之一,若要用它的字面意义须转义   
  9. arr = re.exec(osVersion);  
  10. alert(arr[0]);//完整的osVersion   
  11. alert(arr[1]);//8   
  12. alert(arr[2]);//10   


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

String对象的一些和正则表达式有关的方法
Js代码   收藏代码
  1. //replace方法,用于替换字符串   
  2. var  str = "some money" ;  
  3. alert(str.replace("some" , "much" )); //much money   
  4. //replace的第一个参数可以为正则表达式   
  5. var  re = /\s/; //空白字符   
  6. alert(str.replace(re,"%" )); //some%money   
  7. //在不知道字符串中有多少空白字符时,正则表达式极为方便   
  8. str ="some some             \tsome\t\f" ;  
  9. re = /\s+/;  
  10. alert(str.replace(re,"#" )); //但这样只会将第一次出现的一堆空白字符替换掉   
  11. //因为一个正则表达式只能进行一次匹配,\s+匹配了第一个空格后就退出了   
  12. re = /\s+/g;//g,全局标志,将使正则表达式匹配整个字符串   
  13. alert(str.replace(re,"@" )); //some@some@some@   
  14. //另一个与之相似的是split   
  15. var  str =  "a-bd-c" ;  
  16. var  arr = str.split( "-" ); //返回["a","bd","c"]   
  17. //如果str是用户输入的,他可能输入a-bd-c也可能输入a bd c或a_bd_c,但不会是abdc(这样就说他输错了)   
  18. str = "a_db-c" ; //用户以他喜欢的方式加分隔符s   
  19. re=/[^a-z]/i;//前面我们说^表示字符开始,但在[]里它表示一个负字符集   
  20. //匹配任何不在指定范围内的任意字符,这里将匹配除字母处的所有字符   
  21. arr = str.split(re);//仍返回["a","bd","c"];   
  22. //在字符串中查找时我们常用indexOf,与之对应用于正则查找的方法是search   
  23. str = "My age is 18.Golden age!" ; //年龄不是一定的,我们用indexOf不能查找它的位置   
  24. re = /\d+/;  
  25. alert(str.search(re));//返回查找到的字符串开始下标10   
  26. //注意,因为查找本身就是出现第一次就立即返回,所以无需在search时使用g标志   
  27. //下面的代码虽然不出错,但g标志是多余的   
  28. re=/\d+/g;  
  29. alert(str.search(re));//仍然是10   

注意,当search方法没有找到匹配时,将返回-1  

类似于exec方法,String对象的match方法也用于将字符串与正则表达式进行匹配并返回结果数组
Js代码   收藏代码
  1. var  str =  "My name is CJ.Hello everyone!" ;  
  2. var  re = /[A-Z]/; //匹配所有大写字母   
  3. var  arr = str.match(re); //返回数组   
  4. alert(arr);//数组中只会包含一个M,因为我们没有使用全局匹配   
  5. re = /[A-Z]/g;  
  6. arr = str.match(re);  
  7. alert(arr);//M,C,J,H   
  8. //从字符串中抽取单词   
  9. re = /\b[a-z]*\b/gi;//\b表示单词边界   
  10. str = "one two three four" ;  
  11. alert(str.match(re));//one,two,three,four   


RegExp对象实例的一些属性
Js代码   收藏代码
  1. var  re = /[a-z]/i;  
  2. alert(re.source);//将[a-z]字符串输出   
  3. //请注意,直接alert(re)会将正则表达式连同前向斜线与标志输出,这是re.toString方法定义的   


每个RegExp对象的实例具有lastIndex属性,它是被查找字符串中下一次成功匹配的开始位置,默认值是-1。 lastIndex 属性被 RegExp 对象的 exec 和 test 方法修改.并且它是可写的.
Js代码   收藏代码
  1. var  re = /[A-Z]/;  
  2. //exec方法执行后,修改了re的lastIndex属性,   
  3. var  str =  "Hello,World!!!" ;  
  4. var  arr = re.exec(str);  
  5. alert(re.lastIndex);//0,因为没有设置全局标志   
  6. re = /[A-Z]/g;  
  7. arr = re.exec(str);  
  8. alert(re.lastIndex);//1   
  9. arr = re.exec(str);  
  10. alert(re.lastIndex);//7   


当匹配失败(后面没有匹配),或lastIndex值大于字符串长度时,再执行exec等方法会将lastIndex设为0(开始位置)
Js代码   收藏代码
  1. var  re = /[A-Z]/;  
  2. var  str =  "Hello,World!!!" ;  
  3. re.lastIndex = 120;  
  4. var  arr = re.exec(str);  
  5. alert(re.lastIndex);//0   


RegExp对象的静态属性
Js代码   收藏代码
  1. //input 最后用于匹配的字符串(传递给test,exec方法的字符串)   
  2. var  re = /[A-Z]/;  
  3. var  str =  "Hello,World!!!" ;  
  4. var  arr = re.exec(str);  
  5. alert(RegExp.input);//Hello,World!!!   
  6. re.exec("tempstr" );  
  7. alert(RegExp.input);//仍然是Hello,World!!!,因为tempstr不匹配   
  8. //lastMatch 最后匹配的字符   
  9. re = /[a-z]/g;  
  10. str = "hi" ;  
  11. re.test(str);  
  12. alert(RegExp.lastMatch);//h   
  13. re.test(str);  
  14. alert(RegExp["$&" ]); //i  ,$&是lastMatch的短名字,但由于它不是合法变量名,所以要。。   
  15. //lastParen 最后匹配的分组   
  16. re = /[a-z](\d+)/gi;  
  17. str = "Class1 Class2 Class3" ;  
  18. re.test(str);  
  19. alert(RegExp.lastParen);//1   
  20. re.test(str);  
  21. alert(RegExp["$+" ]); //2   
  22. //leftContext  返回被查找的字符串中从字符串开始位置到最后匹配之前的位置之间的字符   
  23. //rigthContext 返回被搜索的字符串中从最后一个匹配位置开始到字符串结尾之间的字符   
  24. re = /[A-Z]/g;  
  25. str = "123ABC456" ;  
  26. re.test(str);  
  27. alert(RegExp.leftContext);//123   
  28. alert(RegExp.rightContext);//BC456   
  29. re.test(str);  
  30. alert(RegExp["$`" ]); //123A   
  31. alert(RegExp["$'" ]); //C456   


multiline属性返回正则表达式是否使用多行模式,这个属性不针对某个正则表达式实例,而是针对所有正则表达式,并且这个属性可写.(IE与Opera不支持这个属性)
Js代码   收藏代码
  1. alert(RegExp.multiline);  
  2. //因为IE,Opera不支持这个属性,所以最好还是单独指定   
  3. var  re = /\w+/m;  
  4. alert(re.multiline);  
  5. alert(RegExp["$*" ]); //RegExp对象的静态属性不会因为给RegExp某个对象实例指定了m标志而改变   
  6. RegExp.multiline = true ; //这将打开所有正则表达式实例的多行匹配模式   
  7. alert(RegExp.multiline);  


使用元字符注意事项:元字符是正则表达式的一部分,当我们要匹配正则表达式本身时,必须对这些元字符转义.下面是正则表达式用到的所有元字符 
( [ { \ ^ $ | ) ? * + .
Js代码   收藏代码
  1. var  str =  "?" ;  
  2.     var  re = /?/;  
  3.     alert(re.test(str));//出错,因为?是元字符,必须转义   
  4.     re = /\?/;  
  5.     alert(re.test(str));//true   


使用RegExp构造函数与使用正则表达式字面量创建正则表达式注意点
Js代码   收藏代码
  1. var  str =  "\?" ;  
  2. alert(str);//只会输出?   
  3. var  re = /\?/; //将匹配?   
  4. alert(re.test(str));//true   
  5. re = new  RegExp( "\?" ); //出错,因为这相当于re = /\?/   
  6. re = new  RegExp( "\\?" ); //正确,将匹配?   
  7. alert(re.test(str));//true   


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

如何在正则表达式中使用特殊字符?
Js代码   收藏代码
  1. //ASCII方式用十六进制数来表示特殊字符   
  2. var  re = /^\x43\x4A$/; //将匹配CJ   
  3. alert(re.test("CJ" )); //true   
  4. //也可使用八进制方式   
  5. re = /^\103\112$/;//将匹配CJ   
  6. alert(re.test("CJ" )); //true   
  7. //还可以使用Unicode编码   
  8. re =/^\u0043\u004A$/;//使用 Unicode,必须使用u开头,接着是字符编码的四位16进制表现形式   
  9. alert(re.test("CJ" ));  


另处,还有一些其它的预定义特殊字符,如下表所示: 

字符    描述 
\n      换行符 
\r       回车符 
\t       制表符 
\f       换页符(Tab) 
\cX    与X对应的控制字符 
\b      不是退格符(BackSpace), 而是定位符规定匹配模式必须出现在目标字符串 的开头或结尾的两个边界之一,参考
\B      定位符则规定匹配对象必须位于目标字符串的开头和结尾两个边界之内
\v      垂直制表符 
\0      空字符("") 

字符类 ---〉简单类,反向类,范围类,组合类,预定义类
Js代码   收藏代码
  1. //简单类   
  2. var  re = /[abc123]/; //将匹配abc123这6个字符中一个   
  3. //负向类   
  4. re = /[^abc]/;//将匹配除abc之外的一个字符   
  5. //范围类   
  6. re = /[a-b]/;//将匹配小写a-b 26个字母   
  7. re = /[^0-9]/;//将匹配除0-9 10个字符之处的一个字符   
  8. //组合类   
  9. re = /[a-b0-9A-Z_]/;//将匹配字母,数字和下划线   


下面是正则表达式中的预定义类 


代码  等同于                  匹配 
.     IE下[^\n],其它[^\n\r]  匹配除换行符之外的任何一个字符 
\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+?"则是惰性的
Js代码   收藏代码
  1. var  str =  "abc" ;  
  2. var  re = /\w+/; //将匹配abc   
  3. re = /\w+?/;//将匹配a   

多行模式
Js代码   收藏代码
  1. var  re = /[a-z]$/;  
  2.     var  str =  "ab\ncdef" ;  
  3.     alert(str.replace(re,"#" )); //ab\ncde#   
  4.     re =/[a-z]$/m;  
  5.     alert(str.replace(re,"#" )); //a#\ncde#   


分组与非捕获性分组
Js代码   收藏代码
  1. re = /abc{2}/; //将匹配abcc   
  2. re = /(abc){2}/;//将匹配abcabc   
  3. //上面的分组都是捕获性分组   
  4. str = "abcabc ###" ;  
  5. arr = re.exec(str);  
  6. alert(arr[1]);//abc   
  7. //非捕获性分组 (?:)   
  8. re = /(?:abc){2}/;  
  9. arr = re.exec(str);  
  10. alert(arr[1]);//undefined   


候选(也就是所说的“或”)
Js代码   收藏代码
  1. re = /^a|bc$/; //将匹配开始位置的a或结束位置的bc   
  2. str ="add" ;  
  3. alert(re.test(str));//true   
  4. re = /^(a|bc)$/;//将匹配a或bc   
  5. str ="bc" ;  
  6. alert(re.test(str));//true   


当包含分组的正则表达式进行过test,match,search这些方法之后,每个分组都被放在一个特殊的地方以备将来使用,这些存储是分组中的特殊值,我们称之为反向引用
Js代码   收藏代码
  1. var  re = /(A?(B?(C?)))/;  
  2. /*上面的正则表达式将依次产生三个分组  
  3. (A?(B?(C?))) 最外面的  
  4. (B?(C?))  
  5. (C?)*/   
  6. str = "ABC" ;  
  7. re.test(str);//反向引用被存储在RegExp对象的静态属性$1—$9中   
  8. alert(RegExp.$1+"\n" +RegExp.$2+ "\n" +RegExp.$3);  
  9. //反向引用也可以在正则表达式中使用\1 ,\2...这类的形式使用   
  10. re = /\d+(\D)\d+\1\d+/;  
  11. str = "2008-1-1" ;  
  12. alert(re.test(str));//true   
  13. str = "2008-4_3" ;  
  14. alert(re.test(str));//false   


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


其它——〉正向前瞻,用来捕获出现在特定字符之前的字符,只有当字符后面跟着某个特定字符才去捕获它。与正向前瞻对应的有负向前瞻,它用匹配只有当字符后面不跟着某个特定字符时才去匹配它。在执行前瞻和负向前瞻之类的运算时,正则表达式引擎会留意字符串后面的部分,然而却不移动index
Js代码   收藏代码
  1. //正向前瞻   
  2. re = /([a-z]+(?=\d))/i;  
  3. //我们要匹配后面跟一个数字的单词,然后将单词返回,而不要返回数字   
  4. str = "abc every1 abc" ;  
  5. alert(re.test(str));//true   
  6. alert(RegExp.$1);//every   
  7. alert(re.lastIndex);
  8. //使用前瞻的好处是,前瞻的内容(?=\d)并不会当成一次匹配,下次匹配仍从它开始;对于exec正则表达式 //不加g,lastIndex永远返回0   
  9. //负向前瞻(?!)   
  10. re = /([a-z](?!\d))/;i  
  11. //将匹配后面不包含数字的字母,并且不会返回(?!\d)中的内容   
  12. str = "abc1 one" ;  
  13. alert(re.test(str));  
  14. alert(RegExp.$1);//one   


构建一个验证电子邮箱地址有效性的正则表达式。电子邮箱地址有效性要求(我们姑且这样定义):用户名只能包含字母数字以及下划线,最少一位,最多25位,用户名后面紧跟@,后面是域名,域名名称要求只能包含字母数字和减号(-),并且不能以减号开头或结尾,然后后面是域名后缀(可以有多个),域名后缀必须是点号连上2-4位英文字母
Js代码   收藏代码
  1. var  re = /^\w{1,15}(?:@(?!-))(?:(?:[a-z0-9-]*)(?:[a-z0-9](?!-))(?:\.(?!-)))+[a-z]{2,4}$/;
 
  • 大小: 208.9 KB
分享到:
评论
相关资源推荐
  • Web前端正则表达式大全 正则表达式,一个十分古老而又强大的文本处理工具,仅仅用一段非常简短的表达式语句,便能够快速实现一个非常复杂的业务逻辑。熟练地掌握正则表达式的话,能够使你的开发效率得到极大的提升。正则表达式经常被用于字段或任意字符串的校验,如下面这段校验基本日期格式的JavaScript代码:var reg = /^(\d{1,4})(-|\/)(\d{1,2})\2(\d{1,2})$/; var r = fi
  • 安全技术,web前端,最常用的正则表达式 安全技术,web前端,最常用的正则表达式
  • Web 前端开发之js正则表达式用法       前端web开发中,在数据走向后端之前,有必要做数据校验,就需要用到正则表达式, 但是js中使用正则表达式,需要注意书写在正则表达式的单独一行,正则表达式前后不能有 引号,单引号也不行,也不能有分号,负责整个正则表达式失去作用。       例如:我想在对input标签中的IP地址进行校验是否合规,需要用到正则表达式:  /^(\d{1,2}|1\d\d|2[0-4]\d|25[...
  • 正则表达式 详细 解释 正则表达式详解正则表达式详解正则表达式详解正则表达式详解
  • 正则表达式详解正则表达式详解 正则表达式详解正则表达式详解正则表达式详解正则表达式详解
  • javascript正则表达式详解 javascript正则表达式详解javascript正则表达式详解javascript正则表达式详解javascript正则表达式详解javascript正则表达式详解javascript正则表达式详解javascript正则表达式详解javascript正则表达式详解javascript正则表达式详解javascript正则表达式详解
  • 正则表达式语法详解正则表达式语法详解 正则表达式语法详解 正则表达式语法详解 正则表达式语法详解 正则表达式语法详解 正则表达式语法详解
  • Web基础之正则表达式 在jdk中提供了几个用来操作正则的类,这篇文章简单分析这两个类来学习一下正则表达式在java中的使用规则
  • 正则表达式使用详解(学习正则) 正则表达式使用详解(学习正则)正则表达式使用详解(学习正则)正则表达式使用详解(学习正则)正则表达式使用详解(学习正则)
  • WEB前端助手(FeHelper) WEB前端助手(FeHelper),有json格式化, 正则表达式,时间戳等功能
  • C#中使用正则表达式详解 C#中使用正则表达式详解C#中使用正则表达式详解
  • VB 正则表达式 使用详解 VB 正则表达式 使用详解 VB 正则表达式 使用详解
  • (史上最全)Web前端面试试题大全及答案汇总(之篇二JavaScript基础笔试面试题)
  • 正则表达式语法详解 正则表达式语法详解 正则表达式 如何写正则表达式
  • java正则表达式详解 正则表达式详解及例子,很全 正则表达式详解及例子,很全
  • Web前端之iframe详解
  • 正则表达式——全部符号解释(详解
  • c#正则表达式详解 正则表达式网上的文章很多,这里我参照网上的文章,并根据自己的理解总结出比较完整的C#正则表达式的基础知识: 引用文章——http://www.wangqi.com/n9250c53.aspx 一、正则表达式基础知识 以下基础知道是通用的,对于c#,java,js等语言     在正则表达式中拥有一套自己的语法规则,常见语法包括;字符匹配、重复匹配、字符定位、转义匹配和其
  • 前端面试题-正则表达式
  • PHP 中的正则表达式详解 简介正则表达式(Regular Expression),也简称为 RE、Reg、RegEx 或 RegExp。正则表达式的作用是用来查找或者替换符合某种模式(规则)的字符串。正则表达式是一个从左到右匹配目标字符串的模式(pattern)。大多数字符自身就代表一个匹配自身的模式。在 PHP 中,有两种处理正则表达式的扩展库。POSIX 扩展PCRE 扩展POSIX 扩展自 PHP 5.3.0 起, ...
Global site tag (gtag.js) - Google Analytics