从不会到精通js正则表达式转 精通正则表达式 豆瓣

发布时间：2024年11月06日 17:42:21分享人:逗够滚来源:互联网19

正则表达式可以:
•测试字符串的某个模式。例如，可以对一个输入字符串进行测试，看在该字符串是否存在一个电话号码模式或一个信用卡号码模式。这称为数据有效性验证
•替换文本。可以在文档中使用一个正则表达式来标识特定文字，然后可以全部将其删除，或者替换为别的文字
•根据模式匹配从字符串中提取一个子字符串。可以用来在文本或输入字段中查找特定文字

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

创建正则表达式

JavaScript Code复制内容到剪贴板
  1. varre=newRegExp();//RegExp是一个对象,和Aarray一样
  2. //但这样没有任何效果,需要将正则表达式的内容作为字符串传递进去
  3. re=newRegExp("a");//最简单的正则表达式,将匹配字母a
  4. re=newRegExp("a","i");//第二个参数,表示匹配时不分大小写


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

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

JavaScript Code复制内容到剪贴板
  1. varre=newRegExp("a","gi");//匹配所有的a或A

正则表达式还有另一种正则表达式字面量的声明方式

JavaScript Code复制内容到剪贴板
  1. varre=/a/gi;


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


正则表达式对象的方法

•test,返回一个 Boolean 值，它指出在被查找的字符串中是否存在模式。如果存在则返回 true，否则就返回false。
•exec,用正则表达式模式在字符串中运行查找，并返回包<scripttype="text/javascript"src="http://www.iteye.com/javascripts/tinymce/themes/advanced/langs/zh.js"></script><scripttype="text/javascript"src="http://www.iteye.com/javascripts/tinymce/plugins/javaeye/langs/zh.js"></script>含该查找结果的一个数组。
•compile,把正则表达式编译为内部格式，从而执行得更快。
正则表达式对象的属性

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

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


测试正则表达式是如何工作的!

JavaScript Code复制内容到剪贴板
  1. //test方法,测试字符串,符合模式时返回true,否则返回false
  2. varre=/he/;//最简单的正则表达式,将匹配he这个单词
  3. varstr="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!Helovesher!";
  12. alert(re.test(str));//true,只要包含he(HE)就符合,如果要只是he或HE,不能有其它字符,则可使用^和$
  13. re=/^he/i;//脱字符(^)代表字符开始位置
  14. alert(re.test(str));//false,因为he不在str最开始
  15. str="Heisagoodboy!";
  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="userName";//用户名包含空格
  24. alert(re.test(str));//true
  25. str="userName";//用户名包含制表符
  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


当然,仅仅知道了字符串是否匹配模式还不够,我们还需要知道哪些字符匹配了模式

JavaScript Code复制内容到剪贴板
  1. varosVersion="Ubuntu8";//其中的8表示系统主版本号
  2. varre=/^[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. vararr=re.exec(osVersion);
  11. alert(arr[0]);//8



更复杂的用法,使用子匹配

JavaScript Code复制内容到剪贴板
  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="Ubuntu8.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对象的一些和正则表达式有关的方法

JavaScript Code复制内容到剪贴板
  1. //replace方法,用于替换字符串
  2. varstr="somemoney";
  3. alert(str.replace("some","much"));//muchmoney
  4. //replace的第一个参数可以为正则表达式
  5. varre=/s/;//空白字符
  6. alert(str.replace(re,"%"));//some%money
  7. //在不知道字符串中有多少空白字符时,正则表达式极为方便
  8. str="somesometsometf";
  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. varstr="a-bd-c";
  16. vararr=str.split("-");//返回["a","bd","c"]
  17. //如果str是用户输入的,他可能输入a-bd-c也可能输入abdc或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="Myageis18.Goldenage!";//年龄不是一定的,我们用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方法也用于将字符串与正则表达式进行匹配并返回结果数组

JavaScript Code复制内容到剪贴板
  1. varstr="MynameisCJ.Helloeveryone!";
  2. varre=/[A-Z]/;//匹配所有大写字母
  3. vararr=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="onetwothreefour";
  11. alert(str.match(re));//one,two,three,four


RegExp对象实例的一些属性

JavaScript Code复制内容到剪贴板
  1. varre=/[a-z]/i;
  2. alert(re.source);//将[a-z]字符串输出
  3. //请注意,直接alert(re)会将正则表达式连同前向斜线与标志输出,这是re.toString方法定义的


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

JavaScript Code复制内容到剪贴板
  1. varre=/[A-Z]/;
  2. //exec方法执行后,修改了re的lastIndex属性,
  3. varstr="Hello,World!!!";
  4. vararr=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(开始位置)

JavaScript Code复制内容到剪贴板
  1. varre=/[A-Z]/;
  2. varstr="Hello,World!!!";
  3. re.lastIndex=120;
  4. vararr=re.exec(str);
  5. alert(re.lastIndex);//0



RegExp对象的静态属性

JavaScript Code复制内容到剪贴板
  1. //input最后用于匹配的字符串（传递给test,exec方法的字符串）
  2. varre=/[A-Z]/;
  3. varstr="Hello,World!!!";
  4. vararr=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="Class1Class2Class3";
  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不支持这个属性)

JavaScript Code复制内容到剪贴板
  1. alert(RegExp.multiline);
  2. //因为IE，Opera不支持这个属性，所以最好还是单独指定
  3. varre=/w+/m;
  4. alert(re.multiline);
  5. alert(RegExp["$*"]);//RegExp对象的静态属性不会因为给RegExp某个对象实例指定了m标志而改变
  6. RegExp.multiline=true;//这将打开所有正则表达式实例的多行匹配模式
  7. alert(RegExp.multiline);



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

JavaScript Code复制内容到剪贴板
  1. varstr="?";
  2. varre=/?/;
  3. alert(re.test(str));//出错，因为？是元字符，必须转义
  4. re=/?/;
  5. alert(re.test(str));//true

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

JavaScript Code复制内容到剪贴板
  1. varstr="?";
  2. alert(str);//只会输出?
  3. varre=/?/;//将匹配?
  4. alert(re.test(str));//true
  5. re=newRegExp("?");//出错,因为这相当于re=/?/
  6. re=newRegExp("\?");//正确，将匹配？
  7. alert(re.test(str));//true


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

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

JavaScript Code复制内容到剪贴板
  1. //ASCII方式用十六进制数来表示特殊字符
  2. varre=/^x43x4A$/;//将匹配CJ
  3. alert(re.test("CJ"));//true
  4. //也可使用八进制方式
  5. re=/^103112$/;//将匹配CJ
  6. alert(re.test("CJ"));//true
  7. //还可以使用Unicode编码
  8. re=/^u0043u004A$/;//使用Unicode，必须使用u开头，接着是字符编码的四位16进制表现形式
  9. alert(re.test("CJ"));


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

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

字符类 ---〉简单类，反向类，范围类，组合类，预定义类

JavaScript Code复制内容到剪贴板
  1. //简单类
  2. varre=/[abc123]/;//将匹配abc123这6个字符中一个
  3. //负向类
  4. re=/[^abc]/;//将匹配除abc之外的一个字符
  5. //范围类
  6. re=/[a-b]/;//将匹配小写a-b26个字母
  7. re=/[^0-9]/;//将匹配除0-910个字符之处的一个字符
  8. //组合类
  9. re=/[a-b0-9A-Z_]/;//将匹配字母，数字和下划线



从不会到精通js正则表达式（转） 精通正则表达式 豆瓣
下面是正则表达式中的预定义类


代码等同于匹配
.IE下[^n]，其它[^nr]匹配除换行符之外的任何一个字符
d[0-9]匹配数字
D[^0-9]匹配非数字字符
s [nrtfx0B]匹配一个空白字符
S [^nrtfx0B]匹配一个非空白字符
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+?"则是惰性的

JavaScript Code复制内容到剪贴板
  1. varstr="abc";
  2. varre=/w+/;//将匹配abc
  3. re=/w+?/;//将匹配a


多行模式

JavaScript Code复制内容到剪贴板
  1. varre=/[a-z]$/;
  2. varstr="abncdef";
  3. alert(str.replace(re,"#"));//abncde#
  4. re=/[a-z]$/m;
  5. alert(str.replace(re,"#"));//a#ncde#



分组与非捕获性分组

JavaScript Code复制内容到剪贴板
  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


候选（也就是所说的“或”）

JavaScript Code复制内容到剪贴板
  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这些方法之后，每个分组都被放在一个特殊的地方以备将来使用，这些存储是分组中的特殊值，我们称之为反向引用

JavaScript Code复制内容到剪贴板
  1. varre=/(A?(B?(C?)))/;
  3. str="ABC";
  4. re.test(str);//反向引用被存储在RegExp对象的静态属性$1—$9中
  5. alert(RegExp.$1+"n"+RegExp.$2+"n"+RegExp.$3);
  6. //反向引用也可以在正则表达式中使用1,2...这类的形式使用
  7. re=/d+(D)d+1d+/;
  8. str="2008-1-1";
  9. alert(re.test(str));//true
  10. str="2008-4_3";
  11. alert(re.test(str));//false


使用反向引用可以要求字符串中某几个位置上的字符必须相同.另外，在replace这类方法中可用特殊字符序列来表示反向引用

JavaScript Code复制内容到剪贴板
  1. re=/(d)s(d)/;
  2. str="12345678";
  3. alert(str.replace(re,"$2$1"));//在这个里面$1表示第一个分组1234,$2则表示5678


其它——〉正向前瞻,用来捕获出现在特定字符之前的字符,只有当字符后面跟着某个特定字符才去捕获它。与正向前瞻对应的有负向前瞻，它用匹配只有当字符后面不跟着某个特定字符时才去匹配它。在执行前瞻和负向前瞻之类的运算时，正则表达式引擎会留意字符串后面的部分，然而却不移动index

JavaScript Code复制内容到剪贴板
  1. //正向前瞻
  2. re=/([a-z]+(?=d))/i;
  3. //我们要匹配后面跟一个数字的单词，然后将单词返回，而不要返回数字
  4. str="abcevery1abc";
  5. alert(re.test(str));//true
  6. alert(RegExp.$1);//every
  7. alert(re.lastIndex);//使用前瞻的好处是,前瞻的内容(?=d)并不会当成一次匹配，下次匹配仍从它开始
  8. //负向前瞻(?!)
  9. re=/([a-z](?!d))/;i
  10. //将匹配后面不包含数字的字母,并且不会返回(?!d)中的内容
  11. str="abc1one";
  12. alert(re.test(str));
  13. alert(RegExp.$1);//one

构建一个验证电子邮箱地址有效性的正则表达式。电子邮箱地址有效性要求(我们姑且这样定义)：用户名只能包含字母数字以及下划线，最少一位，最多25位，用户名后面紧跟@，后面是域名，域名名称要求只能包含字母数字和减号（-），并且不能以减号开头或结尾，然后后面是域名后缀（可以有多个），域名后缀必须是点号连上2-4位英文字母

JavaScript Code复制内容到剪贴板
  1. varre=/^w{1,15}(?:@(?!-))(?:(?:[a-z0-9-]*)(?:[a-z0-9](?!-))(?:.(?!-)))+[a-z]{2,4}$/;

  3. 附录

  4. 元字符

    描述

    将下一个字符标记为一个特殊字符、或一个原义字符、或一个向后引用、或一个八进制转义符。例如，“n”匹配字符“n”。“\n”匹配一个换行符。序列“\”匹配“”而“(”则匹配“(”。

    ^

    匹配输入字符串的开始位置。如果设置了RegExp对象的Multiline属性，^也匹配“n”或“r”之后的位置。

    $

    匹配输入字符串的结束位置。如果设置了RegExp对象的Multiline属性，$也匹配“n”或“r”之前的位置。

    *

    匹配前面的子表达式零次或多次。例如，zo*能匹配“z”以及“zoo”。*等价于{0,}。

    +

    匹配前面的子表达式一次或多次。例如，“zo+”能匹配“zo”以及“zoo”，但不能匹配“z”。+等价于{1,}。

    ?

    匹配前面的子表达式零次或一次。例如，“do(es)?”可以匹配“does”或“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?”。请注意在逗号和两个数之间不能有空格。

    ?

    当该字符紧跟在任何一个其他限制符（*,+,?，{n}，{n,}，{n,m}）后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串“oooo”，“o+?”将匹配单个“o”，而“o?”将匹配所有“o”。

    .点

    匹配除“n”之外的任何单个字符。要匹配包括“n”在内的任何字符，请使用像“(.|n)”的模式。

    (pattern)

    匹配pattern并获取这一匹配。所获取的匹配可以从产生的Matches集合得到，在VBScript中使用SubMatches集合，在JScript中则使用$0…$9属性。要匹配圆括号字符，请使用“(”或“)”。

    (?:pattern)

    匹配pattern但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。这在使用或字符“(|)”来组合一个模式的各个部分是很有用。例如“industr(?:y|ies)”就是一个比“industry|industries”更简略的表达式。

    (?=pattern)

    正向肯定预查，在任何匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如，“Windows(?=95|98|NT|2000)”能匹配“Windows2000”中的“Windows”，但不能匹配“Windows3.1”中的“Windows”。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。

    (?!pattern)

    正向否定预查，在任何不匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如“Windows(?!95|98|NT|2000)”能匹配“Windows3.1”中的“Windows”，但不能匹配“Windows2000”中的“Windows”。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。

    (?<=pattern)

    反向肯定预查，与正向肯定预查类似，只是方向相反。例如，“(?<=95|98|NT|2000)Windows”能匹配“2000Windows”中的“Windows”，但不能匹配“3.1Windows”中的“Windows”。

    (?<!pattern)

    反向否定预查，与正向否定预查类似，只是方向相反。例如“(?<!95|98|NT|2000)Windows”能匹配“3.1Windows”中的“Windows”，但不能匹配“2000Windows”中的“Windows”。

    x|y

    匹配x或y。例如，“z|food”能匹配“z”或“food”。“(z|f)ood”则匹配“zood”或“food”。

    [xyz]

    字符集合。匹配所包含的任意一个字符。例如，“[abc]”可以匹配“plain”中的“a”。

    [^xyz]

    负值字符集合。匹配未包含的任意字符。例如，“[^abc]”可以匹配“plain”中的“plin”。

    [a-z]

    字符范围。匹配指定范围内的任意字符。例如，“[a-z]”可以匹配“a”到“z”范围内的任意小写字母字符。

    [^a-z]

    负值字符范围。匹配任何不在指定范围内的任意字符。例如，“[^a-z]”可以匹配任何不在“a”到“z”范围内的任意字符。

    b

    匹配一个单词边界，也就是指单词和空格间的位置。例如，“erb”可以匹配“never”中的“er”，但不能匹配“verb”中的“er”。

    B

    匹配非单词边界。“erB”能匹配“verb”中的“er”，但不能匹配“never”中的“er”。

    cx

    匹配由x指明的控制字符。例如，cM匹配一个Control-M或回车符。x的值必须为A-Z或a-z之一。否则，将c视为一个原义的“c”字符。

    d

    匹配一个数字字符。等价于[0-9]。

    D

    匹配一个非数字字符。等价于[^0-9]。

    f

    匹配一个换页符。等价于x0c和cL。

    n

    匹配一个换行符。等价于x0a和cJ。

    r

    匹配一个回车符。等价于x0d和cM。

    s

    匹配任何空白字符，包括空格、制表符、换页符等等。等价于[fnrtv]。

    S

    匹配任何非空白字符。等价于[^ fnrtv]。

    t

    匹配一个制表符。等价于x09和cI。

    v

    匹配一个垂直制表符。等价于x0b和cK。

    w

    匹配包括下划线的任何单词字符。等价于“[A-Za-z0-9_]”。

    W

    匹配任何非单词字符。等价于“[^A-Za-z0-9_]”。

    xn

    匹配n，其中n为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如，“x41”匹配“A”。“x041”则等价于“x04&1”。正则表达式中可以使用ASCII编码。

    num

    匹配num，其中num是一个正整数。对所获取的匹配的引用。例如，“(.)1”匹配两个连续的相同字符。

    n

    标识一个八进制转义值或一个向后引用。如果n之前至少n个获取的子表达式，则n为向后引用。否则，如果n为八进制数字（0-7），则n为一个八进制转义值。

    nm

    标识一个八进制转义值或一个向后引用。如果nm之前至少有nm个获得子表达式，则nm为向后引用。如果nm之前至少有n个获取，则n为一个后跟文字m的向后引用。如果前面的条件都不满足，若n和m均为八进制数字（0-7），则nm将匹配八进制转义值nm。

    nml

    如果n为八进制数字（0-3），且m和l均为八进制数字（0-7），则匹配八进制转义值nml。

    un

    匹配n，其中n是一个用四个十六进制数字表示的Unicode字符。例如，u00A9匹配版权符号（©）。

    [a-z] 表示匹配 26 个小写字母中的任意一个
    [A-Z] 表示匹配 26 个大写字母中的任意一个
    | 竖线（准确点：管道符）表示“或”的意思
    ([a-z]|[A-Z])即 26 个大小写字符中任意一个
    w 为正则中的转义字符，表示匹配字母、数字、下划线
    _ 字符，没有任何意义就是匹配下划线（多余的，因为 w 已经包含了下划线）
    {5,19} 表示前面的字符（即：[w_]）必须至少出现 5 次最多出现 19 次。
    ^ ...(略)... $ 此处的 ^ 和 $ 为匹配限定符，表示必须匹配全部文本（即：从头配到尾）。
    /...(略).../ 在 JavaScript 正则表达式用 / 号标注（仅 JS 支持），相当于字符串要用引号一样。 

    PS: ^ 符号表示必须从文本开始处匹配，$ 表示必须匹配到文本结束为止。如果不加这个符号，可能只会匹配部分文本，而非全部文本。
    例子如下：
    文本：“baaab”
    正则1：a+ （表示匹配一个或多个 a 字符）
    正则2：^a+$ （同上，但多了限定符）
    用正则1匹配测试成功，因为中间的 aaa 符合要求
    用正则2匹配测试失败，因为有 ^ $ 限制，必须文本开始处一直匹配到结束。


    这个正则表达式写的很罗嗦，我修改后的：/^[a-zA-z]w{5,19}$/
    注1：([a-z]|[A-Z]) 原作者意思匹配大小写字母，没必要用到捕获组（即：括号），完全可以这样写：[a-zA-Z]
    注2：[w_] 原作者意思匹配字母、数字、下划线，其实 w 就是：字母、数字、下划线，没必要再单独指定下划线了，因为就一个 w 所以 [] 括号也不需要了。

  
精通正则表达式 

爱华网本文地址 » http://www.413yy.cn/a/25101010/38504.html

更多阅读

JS中正则表达式 js正则表达式数字

JS中正则表达式有几种不同的使用方法,一些用法是通过字符串对象来使用,另外一些通过正则表达式对象使用。一、RegExp（正则表达式）的属性和方法1、属性RegExp的实例有几个只读的属性：global表示是否为全局匹配，igoreCase表示是否忽略大小

JS正则表达式大全 js常用正则表达式大全

转载声明:版权规文章原创作者所有转载时间:2007年08月20日转载作者:pablo3518JS正则表达式大全正则表达式中的特殊字符字符 含意做为转意，即通常在""后面的字符不按原来意义解释，如/b/匹配字符"b"，当b前面加了反斜杆后//，转意为匹配一个

国际象棋从入门到精通 国际象棋入门快易精

国际象棋从入门到精通林敏君早在几年前，我写过一篇《不可不看的优秀国际象棋书》，今天重温旧帖，觉得有些内容应该重写了，一些不适合自学的及重复的内容应该删去，本着精简实用的原则重新推荐合适的教材。近年我国的国际象棋事业发展迅

声明:《从不会到精通js正则表达式转 精通正则表达式 豆瓣》为网友逗够滚分享！如侵犯到您的合法权益请联系我们删除