正则表达式

最新推荐文章于 2022-03-25 18:09:23 发布

上善若水_情

最新推荐文章于 2022-03-25 18:09:23 发布

阅读量209

点赞数

分类专栏： JavaScript

JavaScript 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

什么是正则表达式

在编写处理字符串的程序或网页时，经常会有查找符合某些复杂规则的字符串的需要。正则表达式就是用于描述这些规则的工具。换句话说，正则表达式就是记录文本规则的代码。

创建一个正则表达式

第一种方法：var reg = /pattern/;
第二种方法：var reg = new RegExp('pattern');

正则表达式的exec方法简介

对象的exec 方法：
   reg.exec(str); 其中str为要执行正则表达式的目标字符串。
strobj.replace('pattern,'');
Strobj    表示原始数据
Pattern 表示正则表达式规则
例如：

<script type="text/javascript">
      var reg = /test/;
      var str = 'testString';
      var result = reg.exec(str);
      alert(result);
</script>

将会输出test，因为正则表达式reg会匹配str(‘testString’)中的’test’子字符串，并且将其返回。

使用下面的函数来做匹配正则的讲解：
function execReg(reg,str)
{
    var result = reg.exec(str);
    alert(result);
}
    函数接受一个正则表达式参数reg和一个目标字符串参数str，执行之后会alert出正则表达式与字符串的匹配结果。

正则表达式常见语法规则

c{n} 表示
C 代表字母。n表示个数的意思。
/c{1}/只能匹配一个c。
/c{2}/则会匹配两个连续的c。

例如：
reg = /c{1}/;
str='cainiao';
reg.exec(str);   返回结果c

reg = /c{2}/;
str='cainiao';
reg.exec(str);   返回结果null，表示没有匹配成功。

reg = /c{2}/;
str='ccVC果冻爽';
reg.exec(str);   返回结果cc。

c{m,n}

c{m,n}表示m个到n个c，且m小于等于n 。
如：c{3,4}的意思是，连续的3个c或者4个c
例：

reg = /c{3,4}/;
str='ccVC果冻爽';
reg.exec(str);    返回结果null，表示没有匹配成功。
reg = /c{3,4}/;
str='cccTest';
reg.exec(str);    结果返回ccc。
reg = /c{3,4}/;
str='ccccTest';
reg.exec(str);结果返回cccc，这表明正则会尽量多个，可3可4的时候它会选择多匹配一个。
reg = /c{3,4}/;
str='cccccTest';
reg.exec(str);   仍然只匹配4个c。

c{n,}
c{n,}表示最少n个c，最多则不限个数。如：c{1,}表示1个以上的c。例：
reg = /c{1,}/;
str='cainiao';
reg.exec(str);   结果返回c。
reg = /c{1,}/;
str='cccccTest';
reg.exec(str);   返回ccccc，再次说明了正则表达式会尽量多地匹配。(贪婪模式)
reg = /c{2,}/;
str='cainiao';
reg.exec(str);   结果返回null，c{2,}表示2个以上的c，而cainiao中只有1个c。

*,+,?

*表示0次或者多次，等同于{0,}，即
c* 和 c{0,} 是一个意思。
+表示一次或者多次，等同于{1,}，即
c+ 和 c{1,} 是一个意思。
?表示0次或者1次，等同于{0,1}，即
c? 和 c{0,1} 是一个意思。

贪心与非贪心

人都是贪婪的，正则也是如此。在
   reg = /c{3,4}/;
   str='ccccTest';
   中已经看到了，能匹配四个的时候，正则绝对不会去匹配三个。上面所介绍的所有的正则都是这样，只要在合法的情况下，它们会尽量多去匹配字符，这就叫做贪心模式。
如果希望正则尽量少地匹配字符，那么就可以在表示数字的符号后面加上一个?。
   组成如下的形式：
      {n,}?, *?, +?, ??, {m,n}?

例：
     reg = /c{1,}?/;
    str='ccccc';
   execReg(reg,str);
   返回的结果只有1个c，尽管有5个c可以匹配，但是由于正则表达式是非贪心模式，所以只会匹配一个。

/^开头,结尾$/

^表示只匹配字符串的开头。
$则只匹配字符串结尾的字符。
   例：

1、    reg = /^c/;
          str='维生素c';
reg.exec(str);   结果为null，因为字符串‘维生素c’的开头并不是c，所以匹配失败。
2、    reg = /c$/;
         str='维生素c';
reg.exec(str);   这次返回的结果是c，表明匹配成功。

点’.’

‘.’会匹配字符串中除了换行符\n之外的所有字符
例：
                 reg = /./;
                str='cainiao';
                execReg(reg,str);
结果显示，正则匹配到了字符c。

             reg = /.+/;
            str='blueidea——经典论坛好_。';
            execReg(reg,str);

    结果是：“blueidea——经典论坛好_。“也就是说所有的字符都被匹配掉了，包括一个空格，一个下滑线，和一个破折号。

          reg = /.+/;
         str='bbs.blueidea.com';
        execReg(reg,str);

        同样，直接返回整个字符串——bbs.blueidea.com，可见”.”也匹配”.”本身。

         reg = /^./;
         str='\ncainiao';
         execReg(reg,str);

   结果是null，终于失败了，正则要求字符串的第一个字符不是换行，但是恰恰字符是以\n开始的。

二选一，正则表达式中的或，“|“
b|c表示，匹配b或者c。
例：
       reg = /b|c/;
      str='blueidea';
      execReg(reg,str);

结果是b。

      reg = /b|c/;
     str='cainiao';
     execReg(reg,str);
    结果是c

    reg = /^b|c.+/;
   str='cainiao';
   execReg(reg,str);

   匹配掉整个cainiao。

     reg = /^b|c.+/;
    str='bbs.blueidea.com';
    execReg(reg,str);

    结果只有一个b，而不是整个字符串。因为上面正则表达式的意思是，匹配开头的b或者是c.+。

括号
reg = /^(b|c).+/;
str='bbs.blueidea.com';
execReg(reg,str);

结果是整个串bbs.blueidea.com，加上上面的括号后，意思是，如果字符串的开头是b或者c，那么匹配开头的b或者c以及其后的所有的非换行字符。

字符集合[abc]

[abc]表示a或者b或者c中的任意一个字符

reg = /^[abc]/;
    str='bbs.blueidea.com';
    execReg(reg,str);
   返回结果是b。
reg = /^[abc]/;
   str='test';
   execReg(reg,str);
这次的结果就是null了。

[a-z],[A-Z],[0-9]，分别表示？
小写字母，大写字母，数字

   reg = /^[a-zA-Z][a-zA-Z0-9_]+/;
   str='test'; execReg(reg,str);
   结果是整个test，正则的意思是：开头必须是英文字母，后面可以是英文字母或者数字以及下划线。

反字符集合[^abc]

^在正则表达式开始部分的时候表示开头的意思，例如/^c/表示开头是c；但是在字符集合中，它表示的是类似“非“的意思，例如[^abc]就表示不能是a，b或者c中的任何一个。
[^0-9]表示非数字，[^a-z]表示非小写字母，一次类推 …

reg = /[^abc]/;
str='blueidea';
execReg(reg,str);
返回的结果是l，因为它是第一个非abc的字符
（即第一个b没有匹配）

reg = /[^abc]/;
str='cainiao';
execReg(reg,str);
则返回i，前两个字符都是[abc]集合中的。

边界与非边界

\b表示的边界的意思，也就是说，只有字符串的开头和结尾才算数。例如/\bc/就表示字符串开始的c或者是结尾的c。
例：

reg = /\bc/;
str='cainiao';
execReg(reg,str);
返回结果c。匹配到了左边界的c字符。
reg = /\bc/;
str='维生素c';
execReg(reg,str);
仍然返回c，不过这次返回的是右侧边界的c。
reg = /\bc/;
str='bcb';
execReg(reg,str);
这次匹配失败，因为bcb字符串中的c被夹在中间，既不在左边界也不再右边界。

与\b对应\B表示非边界

reg = /\Bc/;
str='bcb';
execReg(reg,str);
这次会成功地匹配到bcb中的c，。
reg = /\Bc/;
str='cainiao';
execReg(reg,str);
则会返回null。因为\B告诉正则，只匹配非边界的c。

数字与非数字

\d表示数字的意思，相反，\D表示非数字。

reg = /\d/;
str='cainiao8';
execReg(reg,str);
返回的匹配结果为8，因为它是第一个数字字符。
reg = /\D/;
str='cainiao8';
execReg(reg,str);
返回c，第一个非数字字符

空白

\f匹配换页符，\n匹配换行符，\r匹配回车，\t匹配制表符，\v匹配垂直制表符。
\s匹配单个空格，等同于[\f\n\r\t\v]。

reg = /\s.+/;
str='This is a test String.';
execReg(reg,str);
返回“is a test String.”，正则的意思是匹配第一个空格以及其后的所有非换行字符。

\S表示非空格字符
reg = /\S+/;
str='This is a test String.';
execReg(reg,str);
匹配结果为This，当遇到第一个空格之后，正则就停止匹配了。

单词字符

\w表示单词字符，等同于字符集合[a-zA-Z0-9_]。
\W表示非单词字符，等效于[^a-zA-Z0-9_]
例：
reg = /\w+/;
     str='blueidea';
    execReg(reg,str);
返回完整的blueidea字符串，因为所有字符都是单词字符。
reg = /\w+/;
    str='.className';
    execReg(reg,str);
   结果显示匹配了字符串中的className，只有第一个“.”——唯一的非单词字符没有匹配。
reg = /\w+/;
    str='中文如何？';
    execReg(reg,str);
试图用单词字符去匹配中文自然行不通了，返回null。
reg = /\W+/;
    str='中文如何？';
    execReg(reg,str);
返回完整的字符串，因为，无论是中文和“？”都算作是非单词字符。

反向引用
形式如下：/(子正则表达式)\1/
例：
reg = /\w/;
str='blueidea';
execReg(reg,str);
返回b。

reg = /(\w)(\w)/;
str='blueidea';
execReg(reg,str);
返回bl,b,l
bl是整个正则匹配的内容，b是第一个括号里的子正则表达式匹配的内容，l是第二个括号匹配的内容。

reg = /(\w)\1/;
str='bbs.blueidea.com';
execReg(reg,str);
这个正则会匹配到bb。
reg = /(\w)(\w)\2\1/;
str='woow';
execReg(reg,str);
会匹配成功，因为第一个括号匹配到w，第二个括号匹配到o，而\2\1则表示ow，恰好匹配了字符串的最后两个字符。

不记录子正则表达式的匹配结果
使用形如(?:pattern)的正则就可以避免保存括号内的匹配结果。
例：
    reg = /^(?:b|c).+/;
    str='bbs.blueidea.com';
    execReg(reg,str);
可以看到返回的结果不再包括那个括号内的子正则表达式多匹配的内容。

同理，反向引用也不好使了：
    reg = /^(b|c)\1/;
    str='bbs.blueidea.com';
    execReg(reg,str);
   返回bb,b。bb是整个正则表达式匹配的内容，而b是第一个子正则表达式匹配的内容。

    reg = /^(?:b|c)\1/;
    str='bbs.blueidea.com';
    execReg(reg,str);
   返回null。由于根本就没有记录括号内匹配的内容，自然没有办法反向引用了。

正向预查

形式：(?=pattern)
   所谓正向预查，意思就是：要匹配的字符串，后面必须紧跟着pattern！
如：正则表达式/cainiao/会匹配cainiao。同样，也会匹配cainiao9中的cainiao。但是我们可能希望，cainiao只能匹配cainiao8中的cainiao 。这时候就可以像下面这样写：/cainiao(?=8)/

reg = /cainiao(?=8)/;
str='cainiao9';
execReg(reg,str);
返回null。
reg = /cainiao(?=8)/;
str='cainiao8';
execReg(reg,str);
匹配cainiao。
   注意：括号里的内容并不参与真正的匹配，只是检查一下后面的字符是否符合要求而已。

reg = /blue(?=idea)/;
   str='blueidea';
   execReg(reg,str);
   匹配到blue，而不是blueidea。
reg = /blue(?=idea)/;
   str='bluetooth';
   execReg(reg,str);
   返回null，因为blue后面不是idea。
reg = /blue(?=idea)/;
    str='bluetoothidea';
   execReg(reg,str);
   同样返回null。

?!
形式(?!pattern)和?=恰好相反，要求字符串的后面不能紧跟着某个pattern
例：

reg = /blue(?!idea)/;
   str='blueidea';
   execReg(reg,str);
返回null，因为正则要求，blue的后面不能是idea。
reg = /blue(?!idea)/;
   str='bluetooth';
   execReg(reg,str);
则成功返回blue

匹配元字符

什么是元字符呢？
   之前用过*,+,?之类的符号，它们在正则表达式中都有一定的特殊含义，类似这些有特殊功能的字符都叫做元字符。
例如：
   reg = /c*/; 表示有任意个c，但是如果我们真的想匹配’c*’这个字符串的时候怎么办呢？只要将*转义了就可以了。
   如下：
   reg = /c\*/;
   str='c*';
   execReg(reg,str);
   返回匹配的字符串：c*。
同理，要匹配其他元字符，只要在前面加上一个“\”就可以了。

正则表达式的修饰符

不区分大小写修饰符I
形式：/pattern/I
   var reg = /b/;
   var str = 'BBS';
   execReg(reg,str); 返回null，因为大小写不符合。
var reg = /b/i;
    var str = 'BBS';
   execReg(reg,str); 匹配到B，这个就是i修饰符的作用了。

行首行尾，修饰符m

形式：/pattern/m
    m修饰符的作用是修改^和$在正则表达式中的作用，让它们分别表示行首和行尾。
例：

var reg = /^b/;
   var str = 'test\nbbs';
   execReg(reg,str);
   匹配失败，因为字符串的开头没有b字符。但是加上m修饰符之后：
var reg = /^b/m;
   var str = 'test\nbbs';
   execReg(reg,str);
   匹配到b，因为加了m修饰符之后，^已经表示行首，由于bbs在字符串第二行的行首，所以可以成功地匹配。

split方法

str.split(reg,’seprator’);
   split返回分割后的数组，
   例如：
   var reg = /\W/;
   var str = 'bbs.blueidea.com';
   var arr = str.split(reg);
   document.write(arr);
   结果为：bbs,blueidea,com，可见数组被非单词字符分为了有三个元素的数组。

创建正则表达式

Var re=new RegExp();//RegExp 是一个对象,和Aarray一样，但这样没有任何效果,需要将正则表达式的内容作为字符串传递进去。你只是创建了一个空对象而已。
Var re=newRegExp("a");//最简单的正则表达式,将匹配字母a
Var re=newRegExp("a","i");//第二个参数,表示匹配时不分大小写
RegExp构造函数第一个参数为正则表达式的文本内容,而第一个参数则为可选项标志.标志可以组合使用。第二个参数简要说明：g （全文查找）、i （忽略大小写）、m（多行查找）
正则表达式还有另一种正则表达式字面量的声明方式：
var re=/a/i。编程中习惯使用这种方式。