JavaSript-正则表达式

RegExp（正则表达式）：匹配特殊的字符或者有特效搭配原则的字符的最佳选择。

JavaScript RegExp对象

俩种创建RegExp对象的方法。

1：直接量语法：

        var reg=/abc/;
        var str='abcsdcs';

reg表示我们制定了这样的规则，检查字符串是否连续出现abc。

后面可以加上三个属性i g m（下面说）

2：创建RegExp对象 

new RegExp(pattern,attributes);

参数 pattern 是一个字符串，指定了正则表达式的模式或其他正则表达式。

参数 attributes 是一个可选的字符串，包含属性 "g"、"i" 和 "m"，分别用于指定全局匹配、区分大小写的匹配和多行匹配。ECMAScript 标准化之前，不支持 m 属性。如果 pattern 是正则表达式，而不是字符串，则必须省略该参数。

        var reg=/abc/;
        var str='abcsdcs';
        var reg1=new RegExp("abc");

reg和reg1一样。

还可以利用已有的表达式写：

        var reg=/abc/;
        var str='abcsdcs';
        var reg1=new RegExp(reg);
        var reg2=RegExp(reg);

reg和reg1是互相不干扰，reg和reg2公用一个地址，就是一个而已。

应该很清楚了吧。

修饰符（i,g,m)

修饰符	描述
i	执行对大小写不敏感的匹配。
g	执行全局匹配（查找所有匹配而非在找到第一个匹配后停止）。
m	执行多行匹配。

i:不区分大小写

        var reg=/abc/i;
        var str='Abcsdcs';

index表示在那里匹配成功了。

如果把i去掉，那么匹配为null,没有嘛，大小写是不同的。

g:全局匹配

        var reg=/aba/g;
        var str='abababa';

我如果仔细看str的时候，发现其实里面不只有俩个。

我们注意这里匹配时，如果匹配成功了，那么就不会回头了，继续匹配，那么就只有首尾的俩个了。

m:多行匹配

        var reg=/^a/g;
        var str='abc\na';

reg表示的是a必须是开头，这种情况。

其实我们知道str字符串是俩行的，但是只匹配了一个，因为没有开启多行匹配功能。

        var reg=/^a/gm;
        var str='abc\na';

这样就可以了。

方括号：方括号用于查找某个范围内的字符。

比如[abc]那么匹配的时候这个地方是a||b||c都可以。

        var reg=/[ab]c/g;
        var str='acbc';

ac和bc都可以。

[^ab]表示这里不能是ab，其他字符均可。

        var reg=/[^ab]c/g;
        var str='acec';

ec就满足条件了。

[0-9]：查找任何从 0 至 9 的数字。

[a-z] ：查找任何从小写 a 到小写 z 的字符。

[A-Z]：查找任何从大写 A 到大写 Z 的字符。

[A-z]：查找任何从大写 A 到小写 z 的字符。

        var reg=/[0-9][A-z]/g;
        var str='a5b6A#';

(red|blue|green)：查找任何指定的选项。

        var reg=/(wust|cyl)/g;
        var str='777wustcyl777';

这个很简单，但是括号的用法不止如此，后面有更神奇的用法。

元字符（Metacharacter）是拥有特殊含义的字符：

\w 查找单词字符。\W 查找非单词字符。

\w===[0-9A-z_]  \W就是取补集

        var reg=/\w/g;
        var str='7wustcyl7_@';

@不在里面，在\W里面

\d     查找数字。\D 查找非数字字符。

\d=[0-9]  \W取补集

\s 查找空白字符。\S 查找非空白字符。

空白字符可以是：
空格符 (space character)
制表符 (tab character)
回车符 (carriage return character)
换行符 (new line character)
垂直换行符 (vertical tab character)

换页符 (form feed character)

\s=[\t\n\f\t\v ]  \S取补集

\b 匹配单词边界。\B 匹配非单词边界。

什么是单词边界了？

var str='abc cde sdf';那个这个字符串有6个单词边界，就是每个单词首尾的，但是是空。

       var reg=/\b/g;
        var str='abc def srt';

既然是空，那么有什么作用了。

        var reg=/\bd/g;
        var str='adc def srt';

只有一个d.

        var reg=/\bd/g;
        var str='adcdef srt';

不存在这样的d.

'.'查找单个字符，除了换行和行结束符。

.===[\r\n]的补集

表示整个字符集合，也就是所有的都可以匹配。

写法很多 比如[\s\S]这样就可以了。

量词

n+ 匹配任何包含至少一个 n 的字符串。{1，}

n* 匹配任何包含零个或多个 n 的字符串。{0，}

        var reg=/\w+/g;
        var str='cyl';

如果我们不加+，那么肯定是，+重复的是\w。

这里\w+可以看出\w\w\w.

        var reg=/\w*/g;
        var str='cyl';

因为出现0次就是空嘛，当光标移到l后面是，还有一个逻辑的距离空。

        var reg=/\d*/g;
        var str='cyl';

结果是什么？

c前面 c到y y到l  l后面

那么刚刚为什么c的前面没有匹配空出来了？

这里需要知道它匹配的”贪婪原则“，能匹配多的字符就匹配多的。

没有字符可以匹配了，才匹配空的。

n?匹配任何包含零个或一个 n 的字符串。{0,1}

        var reg=/\w?/g;
        var str='cyl';

应该很简单了。

n{X} 匹配包含 X 个 n 的序列的字符串。{x}

n{X,Y}匹配包含 X 至 Y 个 n 的序列的字符串。{x,y}  满足贪婪原则，匹配多的优先

n{X,} 匹配包含至少 X 个 n 的序列的字符串。{x, } 满足贪婪原则，匹配多的优先

        var reg=/\w{5}/g;
        var reg1=/\w{3,5}/g;
        var  reg2=/\w{3,}/g;
        var str='aaaaaaaaaaaaa';

13个a的不同匹配，一看就明白了。

n$ 匹配任何结尾为 n 的字符串。

^n 匹配任何开头为 n 的字符串。

        var reg=/^abc/g;
        var str='abcabc';

只有第一个满足要求，你可以理解成以a开头后面接上bc

        var reg=/abc$/g;
        var str='abcabc';

同理也只有一个。

那么，这样了？

        var reg=/^abc$/g;
        var str='abcabc';

匹配不出来，道理也很简单。^abc匹配的是前面的那个abc  abc&匹配的是后面那个abc。abc不一样，所以当然匹配不出来了咯！！！

也就是说var reg=/^abc$/g  只能匹配var str='abc';

?=n 匹配任何其后紧接指定字符串 n 的字符串。

?!n 匹配任何其后没有紧接指定字符串 n 的字符串。

         var reg=/a(?=b)/;
         var str='abaaaa';

后面的可以看出修饰前面的，结果不包含。

RegExp 对象属性

global RegExp 对象是否具有标志 g。

ignoreCase RegExp 对象是否具有标志 i。

lastIndex 一个整数，标示开始下一次匹配的字符位置。

multiline RegExp 对象是否具有标志 m。

source 正则表达式的源文本。

重点看lastIndex

等一会讲。

RegExp 对象方法

test 检索字符串中指定的值。返回 true 或 false。（作用不大）

exec 检索字符串中指定的值。返回找到的值，并确定其位置。

重点exec

        var reg=/ab/g;
        var str='abab';

index是找到的位置，执行第一遍我们在0，再执行一遍，到2了，接着继续匹配了？没有了就是空。然后继续匹配，我们发现它回去了，循环了。好像有一个东西循环的动？这个东西就是lastIndex.

        var reg=/ab/g;
        var str='abab';
        console.log(reg.lastIndex);
        console.log(reg.exec(str));
        console.log(reg.lastIndex);
        console.log(reg.exec(str));
        console.log(reg.lastIndex);
        console.log(reg.exec(str));
        console.log(reg.lastIndex);
        console.log(reg.exec(str));

一目了然。

而且lastIndex还可以改变。。。。

（）的高级应用。

问题：假设我们需要匹配形如xxyy的字符串，怎么写正则表达式。

         var reg=/(\w)\1(\w)\2/g;
         var str='aabbacac1122';

我们来解释一下，为什么能这么写。

（）里面的式子称为子表达式，而且会把里面的东西保留下来。更厉害的是我可以通过\num将第num个自表达式反向引用出来。

形如xxxx的怎么写了？ var reg=/(\w)\1\1\1/g;  ok了。

支持正则表达式的 String 对象的方法

注意这里是String上面的方法。

search 检索与正则表达式相匹配的值。

         var reg=/(\w)\1(\w)\2/g;
         var str='aabbacac';

返回的是匹配成功的位置，如果没有那么为-1，加g不加g，没区别。

         var reg=/(\w)\1(\w)\2/g;
         var str='abbacac';

match 找到一个或多个正则表达式的匹配。

这个也是我们一直用的，就不用说了。

split 把字符串分割为字符串数组。

         var reg=/(\w)\1/g;
         var str='abbacac';

在bb处分开了，注意还是要把子表达式返回的。

         var reg=/\d/g;
         var str='abb0acac';

没有子表达式。

replace 替换与正则表达式匹配的子串。 重点

先看一个代码：

         var str='aaa';
         console.log('a','b');

答案是撒？

         var str='aaa';
         console.log(str.replace('a','b'));

它没有访问全局的能力。只能变一个。

等价于下面这个写法。

         var reg=/a/;
         var str='aaa';
         console.log(str.replace(reg,'b'));

我们只有给reg加上g才能把所有的a变成b

         var reg=/a/g;
         var str='aaa';
         console.log(str.replace(reg,'b'));

问题描述：我们需要把形如xxyy变成yyxx.

怎么搞？

         var reg=/(\w)\1(\w)\2/g;
         var str='aabbcyl1122';
         console.log(str.replace(reg,'$2$2$1$1'));

这样搞撒。这里有个知识点我们可以用$num来引用第num个子表达式。

         var reg=/(\w)\1(\w)\2/g;
         var str='aabbcyl1122';
         console.log(str.replace(reg,function($,$1,$2){
             return $2+$2+$1+$1;
         }));

还可一这样写，第二个参数是一个函数，返回值是字符串就行。

函数的第一个参数是正则表达式的匹配内容，第二个是第一个子表达式，第三个是第二个子表达式，以此类推。

一道好题目：

将字符串'10000000'变成'10.000.000'

         var reg=/(?=(\B)(\d{3})+$)/g;
         var str='10000000';