JavaScript 正则表达式

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

JavaScript通过RegExp类型来支持正则表达式,语法格式如下:

    var reg = / pattern / falgs;

其中的模式(pattern)部分可以是任何简单或复杂的正则表达式,可以包含字符类/限定符/分组/向前查找以及反向引用.每个正则表达式都可带有一个或多个标志(flags),用以标明正则表达式的行为.

    正则表达式的匹配模式支持下列3个标志:

    1)g:表示全局(global)模式,即模式将被应用于所有字符串,而非在发现第一个匹配项时立即停止;

    2)i:表示不区分大小写(case-insensitive)模式,即在确定匹配项时忽略模式与字符串的大小写;

    3)m:表示多行模式(multiline),即在到达一行文本末尾时还会继续查找下一行中是否存在于模式匹配的项;

因此,一个正则表达式就是一个模式与上述3个标志的组合体.

创建正则表达式:

Js代码  

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

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

    1)g:全文查找

    2)i:忽略大小写

    3)m:多行查找

Js代码  

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

等价于:

Js代码  

1. var re = /a/gi;  

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

正则表达式对象的方法:
    •test():返回一个 Boolean 值，它指出在被查找的字符串中是否存在模式。如果存在则返回 true，否则就返回 false。 
   •exec():该方法是专门为捕获组而设计的,接受一个要应用模式的字符串，并返回包含第一个匹配项信息的数组,在没有匹配项时返回null;返回的数组包含两个额外的属性:index和input,index表示匹配项在字符串中的位置,input表示应用正则表达式的字符串。 
   •compile():把正则表达式编译为内部格式，从而执行得更快。 

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

String对象一些和正则表达式相关的方法: 
    •match():找到一个或多个正则表达式的匹配,找不到则返回null。 
    •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"));  

元字符

    ( [ { \ ^ $ | ) ? * + . ] }

预定义的特殊字符

字符	正则	描述
\t	/\t/	制表符
\n	/\n/	制表符
\r	/\r/	回车符
\f	/\f/	换页符
\a	/\a/	alert字符
\e	/\e/	escape字符
\cX	/\cX/	与X相对应的控制字符
\b	/\b/	与回退字符
\v	/\v/	垂直制表符
\0	/\0/	空字符

字符类

alert(/ruby/.test( "ruby" )); //true alert(/[abc]/.test( "a" )); //true alert(/[abc]/.test( "b" )); //true alert(/[abc]/.test( "c" )); //true alert( "a bat ,a Cat,a fAt bat ,a faT cat" .match(/[bcf]at/gi)); //bat,Cat,fAt,bat,faT,cat

alert(/[^abc]/.test( "a" )); //false

alert(/[^abc]/.test( "b" )); //false

alert(/[^abc]/.test( "6" )); //true

alert(/[^abc]/.test( "gg" )); //true

alert(/[a-f]/.test( "b" )); //true alert(/[a-f]/.test( "k" )); //false alert(/[a-z]/.test( "h" )); //true alert(/[A-Z]/.test( "gg" )); //false alert(/[^H-Y]/.test( "G" )); //true alert(/[0-9]/.test( "8" )); //true alert(/[^7-9]/.test( "6" )); //true

alert(/[a-m1-5\n]/.test( "a" )) //true alert(/[a-m1-5\n]/.test( "3" )) //true var  a = "\n\          " alert(/[a-m1-5\n]/.test(a)) //true alert(/[a-m1-5\n]/.test( "r" )) //false

字符	等同于	描述
.	[^\n\r]	除了换行和回车之外的任意字符
\d	[0-9]	数字字符
\D	[^0-9]	非数字字符
\s	[ \t\n\x0B\f\r]	空白字符
\S	[^ \t\n\x0B\f\r]	非空白字符
\w	[a-zA-Z_0-9]	单词字符(所有的字母)
\W	[^a-zA-Z_0-9]	非单词字符

alert(/\d/.test( "3" )) //true

alert(/\d/.test( "w" )) //false

alert(/\D/.test( "w" )) //true

alert(/\w/.test( "w" )) //true

alert(/\w/.test( "司" )) //false

alert(/\W/.test( "徒" )) //true

alert(/\s/.test( " " )) //true

alert(/\S/.test( " " )) //false

alert(/\S/.test( "正" )) //true

alert(/./.test( "美" )) //true

alert(/./.test( "  " )) //true

var  a = "\n\

       "

alert(/./.test(a)) //true

量词

简单量词

代码	类型	描述
?	软性量词	出现零次或一次
*	软性量词	出现零次或多次(任意次)
+	软性量词	出现一次或多次（至道一次）
{n}	硬性量词	对应零次或者n次
{n,m}	软性量词	至少出现n次但不超过m次
{n,}	软性量词	至少出现n次(+的升级版)

alert(/..../.test( "司徒正美" )) //true

alert(/司徒正美/.test( "司徒正美" )) //true

alert(/[\u4e00-\u9fa5]{4}/.test( "司徒正美" )) //true

alert(/[\u4e00-\u9fa5]{4}/.test( "司徒正美55" )) //true

alert(/^[\u4e00-\u9fa5]+$/.test( "正则表达式" )) //true

alert(/^[\u4e00-\u9fa5]+$/.test( "正则表达式&*@@" )) //false

alert(/\d{6}/.test( "123456" )) //true

alert(/[ruby]{2}/.test( "rr" )) //true

alert(/[ruby]{2}/.test( "ru" )) //true

alert(/[ruby]{2}/.test( "ry" )) //true

/[\u4e00-\u9fa5]/用于匹配单个汉字。

贪婪量词，惰性量词与支配性量词

贪婪量词，上面提到的所有简单量词。就像成语中说的巴蛇吞象那样，一口吞下整个字符串，发现吞不下（匹配不了），再从后面一点点吐出来（去掉最后一个字符，再看这时这个整个字符串是否匹配，不断这样重复直到长度为零）

隋性量词，在简单量词后加问号。由于太懒了，先吃了前面第一个字符，如果不饱再捏起多添加一个（发现不匹配，就读下第二个，与最初的组成一个有两个字符串的字符串再尝试匹配，如果再不匹配，再吃一个组成拥有三个字符的字符串……）。其工作方式与贪婪量词相反。

支配性量词，在简单量词后加加号。上面两种都有个不断尝试的过程，而支配性量词却只尝试一次，不合口味就算了。就像一个出身高贵居支配地位的公主。但你也可以说它是最懒量词。由于javascript不支持，所以它连出场的机会也没有了。

var  re1 = /.*bbb/g; //贪婪

var  re2 = /.*?bbb/g; //惰性

//  var re3 = /.*+bbb/g;//支配性,javascript不支持，IE与所有最新的标准浏览器都报错

alert(re1.test( "abbbaabbbaaabbbb1234" )+ "" ); //true

alert(re1.exec( "abbbaabbbaaabbbb1234" )+ "" ); //null

alert( "abbbaabbbaaabbbb1234" .match(re1)+ "" ); //abbbaabbbaaabbbb

 

alert(re2.test( "abbbaabbbaaabbbb1234" )+ "" ); //true

alert(re2.exec( "abbbaabbbaaabbbb1234" )+ "" ); //aabbb

alert( "abbbaabbbaaabbbb1234" .match(re2)+ "" ); //abbb,aabbb,aaabbb

分组

到目前为止，我们只能一个字符到匹配，虽然量词的出现，能帮助我们处理一排密紧密相连的同类型字符。但这是不够的，下面该轮到小括号出场了，中括号表示范围内选择，大括号表示重复次数。小括号允许我们重复多个字符。

//分组+量词 alert(/(dog){2}/.test( "dogdog" )) //true //分组+范围 alert( "baddad" .match(/([bd]ad?)*/)) //baddad,dad //分组+分组 alert( "mon and dad" .match(/(mon( and dad)?)/)) //mon and dad,mon and dad, and dad

反向引用

反向引用标识由正则表达式中的匹配组捕获的子字符串。每个反向引用都由一个编号或名称来标识，并通过“\编号”表示法进行引用。

var  color = "#990000" ; / #(\d+)/.test(color); alert(RegExp.$1); //990000 alert(/(dog)\1/.test( "dogdog" )) //true var  num = "1234 5678" ; var  newNum = num.replace(/(\d{4}) (\d{4})/, "$2 $1" ); alert(newNum)

候选

继续在分组上做文章。在分组中插入管道符（“|”），把它划分为两个或多个候多项。

var  reg = /(red|black|yellow)!!/; alert(reg.test( "red!!" )) //true alert(reg.test( "black!!" )) //true alert(reg.test( "yellow!!" )) //true

非捕获性分组

并不是所有分组都能创建反向引用，有一种特别的分组称之为非捕获性分组，它是不会创建反向引用。反之，就是捕获性分组。要创建一个非捕获性分组，只要在分组的左括号的后面紧跟一个问号与冒号就行了。

var  color = "#990000" ; / #(?:\d+)/.test(color); alert(RegExp.$1); //""

题目，移除所有标签，只留下innerText!

var  html = "<p><a href='http://www.cnblogs.com/rubylouvre/'>Ruby Louvre</a>by <em>司徒正美</em></p>" ; var  text = html.replace(/<(?:.|\s)*?>/g, "" ); alert(text)

注意：javascript不存在命名分组

前瞻

前瞻与后瞻其实都属于零宽断言，但javascript不支持后瞻。

零宽断言
正则	名称	描述
(?=exp)	正向前瞻	匹配exp前面的位置
(?!exp)	负向前瞻	匹配后面不是exp的位置
(?<=exp)	正向后瞻	匹配exp后面的位置不支持
(?<!exp)	负向后瞻	匹配前面不是exp的位置不支持

正向前瞻用来检查接下来的出现的是不是某个特定的字符集。而负向前瞻则是检查接下来的不应该出现的特定字符串集。零宽断言是不会被捕获的。

var  str1 = "bedroom" ; var  str2 = "bedding" ; var  reBed = /(bed(?=room)) ///在我们捕获bed这个字符串时，抢先去看接下来的字符串是不是room alert(reBed.test(str1)); //true alert(RegExp.$1) //bed alert(RegExp.$2 === "" ) //true alert(reBed.test(str2)) //false

var  str1 = "bedroom" ; var  str2 = "bedding" ; var  reBed = /(bed(?!room))/  //要来它后面不能是room alert(reBed.test(str1)) //false alert(reBed.test(str2)) //true

题目，移除hr以外的所有标签，只留下innerText!

var  html = "<p><a href='http://www.cnblogs.com/rubylouvre/'>Ruby Louvre</a></p><hr/><p>by <em>司徒正美</em></p>" ; var  text = html.replace(/<(?!hr)(?:.|\s)*?>/ig, "" ) alert(text) //Ruby Louvre<hr/>by 司徒正美

边界

边界
正则	名称	描述
^	开头	注意不能紧跟于左中括号的后面
$	结尾
\b	单词边界	指[a-zA-Z_0-9]之外的字符
\B	非单词边界

题目，设计一个字符串原型方法，实现首字母大写！

var  a = "ruby" ;   String.prototype.capitalize =  function  () {       return  this .replace(/^\w/, function  (s) {           return  s.toUpperCase();       });   } alert(a.capitalize()) //Ruby

单词边界举例。要匹配的东西的前端或未端不能为英文字母阿拉伯字数字或下横线。

var  str = "12w-eefd&efrew" ; alert(str.match(/\b\w+\b/g)) //12w,eefd,efrew

实例属性	描述
global	是当前表达式模式首次匹配内容的开始位置，从0开始计数。其初始值为-1，每次成功匹配时，index属性都会随之改变。
ignoreCase	返回创建RegExp对象实例时指定的ignoreCase标志（i）的状态。如果创建RegExp对象实例时设置了i标志，该属性返回True，否则返回False，默认值为False。
lastIndex	是当前表达式模式首次匹配内容中最后一个字符的下一个位置，从0开始计数，常被作为继续搜索时的起始位置，初始值为-1， 表示从起始位置开始搜索，每次成功匹配时，lastIndex属性值都会随之改变。(只有使用exec()或test()方法才会填入，否则为0)
multiLine	返回创建RegExp对象实例时指定的multiLine标志（m）的状态。如果创建RegExp对象实例时设置了m标志，该属性返回True，否则返回False，默认值为False。
source	返回创建RegExp对象实例时指定的表达式文本字符串。

var  str = "JS's Louvre" ; var  reg = /\w/g; alert(reg.exec(str)); //J alert(reg.lastIndex); //1 alert(reg.exec(str)); //S alert(reg.lastIndex); //2 alert(reg.exec(str)); //s alert(reg.lastIndex); //4 alert(reg.exec(str)); //L alert(reg.lastIndex); //6

匹配中文字符的正则表达式：

[ \ u4e00 -\ u9fa5 ]

匹配双字节字符(包括汉字在内)：

[ ^\ x00 -\ xff ]

应用：计算字符串的长度（一个双字节字符长度计2，ASCII字符计1）

String . prototype . len = function (){   return   this . replace ([ ^\ x00 -\ xff ] / g,"aa").length; }

匹配空行的正则表达式：

\ n [ \ s | ] *\ r

匹配HTML标记的正则表达式：

/ <(.*)>.*< \/ \1>|<(.*)  \/ > /

匹配首尾空格的正则表达式：

( ^\ s * ) | ( \ s *$ )

应用：j avascript中没有像v bscript那样的trim函数，我们就可以利用这个表达式来实现，如下：

String . prototype . trim  =  function () {
     return   this . replace ( / (^\s*)|(\s*$) /g ,  "" ) ;
}

利用正则表达式分解和转换IP地址
下面是利用正则表达式匹配IP地址，并将IP地址转换成对应数值的Javascript程序：

function   IP2V ( ip ) {
     re = / (\d+)\.(\d+)\.(\d+)\.(\d+) /g    //匹配IP地址的正则表达式
     if ( re . test ( ip )) {
         return  RegExp .$ 1 * Math . pow ( 255 , 3 ) )+ RegExp .$ 2 * Math . pow ( 255 , 2 ) )+ RegExp .$ 3 * 255 + RegExp .$ 4 * 1
     } else {
         throw   new   Error ( " Not a valid IP address! " )
     }
}

不过上面的程序如果不用正则表达式，而直接用split函数来分解可能更简单，程序如下：

var   ip = " 10.100.20.168 "
ip = ip . split ( " . " )
alert ( " IP值是： " + ( ip [ 0 ] * 255 * 255 * 255 + ip [ 1 ] * 255 * 255 + ip [ 2 ] * 255 + ip [ 3 ] * 1 ))

匹配Email地址的正则表达式：

\ w + ([ -+. ] \ w + ) *@\ w + ([ -. ] \ w + ) *\.\ w + ([ -. ] \ w + ) *

匹配网址URL的正则表达式：

http : //([\w-]+\.)+[\w-]+(/[\w- ./?%&=]*)?

利用正则表达式去除字串中重复的字符的算法程序：[*注：此程序不正确]

var   s = " abacabefgeeii "
var   s1 = s . replace ( / (.).*\1 /g , " $1 " )
var   re = new   RegExp ( " [ " + s1 + " ] " , " g " )
var   s2 = s . replace ( re , "" )
alert ( s1 + s2 )    //结果为：abcefgi

*注
如果var s = “abacabefggeeii”
结果就不对了，结果为：abeicfgg
正则表达式的能力有限,这是我能想到的最简单的实现方法。思路是使用后向引用取出包括重复的字符，再以重复的字符建立第二个表达式，取到不重复的字符，两者串连。这个方法对于字符顺序有要求的字符串可能不适用。

得用正则表达式从URL地址中提取文件名的javascript程序，如下结果为page1

s = " http://blog.penner.cn/page1.htm "
s = s . replace ( / (.* \/ ){ 0, }([^\.]+).* /i g , " $2 " )
alert ( s )

利用正则表达式限制网页表单里的文本框输入内容：

用正则表达式限制只能输入中文：

onkeyup = " value=value.replace(/[^\u4E00-\u9FA5]/g,'') " onbeforepaste = " clipboardData.setData('text',clipboardData.getData('text').replace(/[^\u4E00-\u9FA5]/g,'')) "

用正则表达式限制只能输入全角字符：

onkeyup = " value=value.replace(/[^\uFF00-\uFFFF]/g,'') " onbeforepaste = " clipboardData.setData('text',clipboardData.getData('text').replace(/[^\uFF00-\uFFFF]/g,'')) "

用正则表达式限制只能输入数字：

onkeyup = " value=value.replace(/[^\d]/g,'') " onbeforepaste = " clipboardData.setData('text',clipboardData.getData('text').replace(/[^\d]/g,'')) "

用正则表达式限制只能输入数字和英文：

onkeyup = " value=value.replace(/[\W]/g,'') " onbeforepaste = " clipboardData.setData('text',clipboardData.getData('text').replace(/[^\d]/g,'')) "

匹配非负整数（正整数 + 0）

^\ d +$

匹配正整数

^ [ 0 - 9 ] * [ 1 - 9 ][ 0 - 9 ] *$

匹配非正整数（负整数 + 0）

^ (( -\ d + ) | ( 0 + )) $

匹配负整数

^- [ 0 - 9 ] * [ 1 - 9 ][ 0 - 9 ] *$

匹配整数

^-?\ d +$

匹配非负浮点数（正浮点数 + 0）

^\ d + ( \.\ d + ) ?$

匹配正浮点数

^ (([ 0 - 9 ] +\. [ 0 - 9 ] * [ 1 - 9 ][ 0 - 9 ] * ) | ([ 0 - 9 ] * [ 1 - 9 ][ 0 - 9 ] *\. [ 0 - 9 ] + ) | ([ 0 - 9 ] * [ 1 - 9 ][ 0 - 9 ] * )) $

匹配非正浮点数（负浮点数 + 0）

^ (( -\ d + ( \.\ d + ) ? ) | ( 0 + ( \ .0 + ) ? )) $

匹配负浮点数

^ ( - (([ 0 - 9 ] +\. [ 0 - 9 ] * [ 1 - 9 ][ 0 - 9 ] * ) | ([ 0 - 9 ] * [ 1 - 9 ][ 0 - 9 ] *\. [ 0 - 9 ] + ) | ([ 0 - 9 ] * [ 1 - 9 ][ 0 - 9 ] * ))) $

匹配浮点数

^ ( -?\ d + )( \.\ d + ) ?$

匹配由26个英文字母组成的字符串

^ [ A - Za - z ] +$

匹配由26个英文字母的大写组成的字符串

^ [ A - Z ] +$

匹配由26个英文字母的小写组成的字符串

^ [ a - z ] +$

匹配由数字和26个英文字母组成的字符串

^ [ A - Za - z0 - 9 ] +$

匹配由数字、26个英文字母或者下划线组成的字符串

^\ w +$

匹配email地址

^ [ \ w - ] + ( \. [ \ w - ] + ) *@ [ \ w - ] + ( \. [ \ w - ] + ) +$

匹配url

^ [ a - zA - z ] +: //匹配(\w+(-\w+)*)(\.(\w+(-\w+)*))*(\?\S*)?$

匹配html tag

<\ s * ( \ S + )( \ s [ ^> ] * ) ?> ( .*? ) <\ s *\ / \1\s*>