JavaSript中的正则表达式

标签：

  正则表达式是对字符串操作的逻辑公式，表达了对字符串的一种过滤逻辑。

  相对于.NET和Perl，JS对正则表达式的支持相当朴素，或者说JS的正则表达式是perl正则表达式的一个子集。

一、正则表达式引擎：

主流正则引擎分为3类：1、DFA(text-directed)　　2、NFA(rege-directed)　　3、POSIX NFA

JS采用的是NFA正则引擎，以正则为导向

DFA与NFA的却别：

1. DFA对于文本每个字符只扫描一次，比较快，NFA需要反复吃吐字符，速度慢

2. 只有NFA菜支持lazy和backreference等特性

3. 由于NFA支持lazy，NFA最左子式优先匹配成功，DFA则是最长左子式优先匹配成功

4. NFA采用greedy量词(对于*,+这样以贪婪方式进行)，NFA会优先匹配量词

5. NFA可能会选入递归调用的陷阱二表现的性能极差

二、元字符：

() [] {} . ? * + ^ $ \ |　　如果需要使用元字符的本身符号需要转义

三、特殊字符：

四、字符类：

  简单类：原则上正则的一个字符对应一个字符，我们可以用[]把它们括起来，让[]这个整体对应一个字符。如

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

  负向类：也是在那个括号里做文章，前面加个元字符进行取反，表示匹配不能为括号里面的字符。

1 alert(/[^abc]/.test("a"));//false
2 alert(/[^abc]/.test("b"));//false
3 alert(/[^abc]/.test("6"));//true
4 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

  预定义类：还是在那个中括号里面做文章，不过它好像已经走到尽头了。由于是中括号的马甲，因此它们还是对应一个字符。

五、量词：

  简单量词：

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

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

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

六、分组：

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

//分组+量词
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);//""

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

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

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 司徒正美

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

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

JavaSript中的正则表达式

标签：

原文地址：http://www.cnblogs.com/vitruvi/p/4289483.html