JavaScript 【引用类型】RegExp类型

以下为学习《JavaScript 高级程序设计》》(第 3 版) 所做笔记。

目录：

　　1、创建正则表达式

　　2、RegExp 实例属性

　　3、RegExp 实例方法

　　4、RegExp 构造函数属性　

创建正则表达式

1. 以字面量形式创建正则表达式

var expression = / pattern / flags;

pattern 部分是正则表达式。flags部分是标志，用以标明正则表达式的行为，正则表达式的匹配模式支持3个标志（g、i 跟 m）。

<script>
    //g
    //表示全局模式
    //模式将被应用于字符串，而非发现第一个匹配项就停止。
    var pattern1 = /at/g;   //匹配字符串中所有"at"的实例
    //i
    //表示不区分大小写
    //在确定匹配模式时忽略模式和字符串的大小写
    var pattern2 = /[bc]at/i;   //匹配第一个"bat"或"cat",不区分大小写
    var pattern3 = /.at/gi;     //匹配字符串中所有以"at"结尾的3个字符的组合，不区分大小写
    //m
    //表示多行模式
    //在到达一行文本末尾时还会继续查找下一行中是否存在与模式匹配的项
</script>

在模式 pattern 中如果想要匹配元字符，需要对元字符进行转义。正则表达式中元字符有：( [ { ^ $ | ） ？ * + . }

<script>
    var pattern1 = /[bc]at/i;     //匹配第一个"bat"或"cat",不区分大小写
    var pattern2 = /[bc]at/i;   //匹配第一个"[bc]at",不区分大小写
</script>

2. 使用 RegExp 构造函数创建正则表达式

RegExp 构造函数接收的第一个参数为模式 pattern, 第二个参数为标志 flags。

<script>
    var pattern = new RegExp( "[bc]at", "i" );
</script>

在模式 pattern 中如果想要匹配元字符，需要对元字符进行双重转义。例如字面量形式的模式  /w\hello\123/  等同于 RegExp 构造函数的模式参数 " \w\\hello\\123 "。

3.使用字面量形式创建正则表达式与使用 RegExp 构造函数创建正则表达式的区别

 使用正则表达式字面量必须像直接调用 RegExp 构造函数一样，每次都创建 RegExp 实例。在循环体中，使用字面量形式创建正则表达式实际上只会创建一个实例，不会每次循环都创建一个新实例，比如说第二次循环调用就是从上一次匹配的末尾开始的，不会从头开始匹配。

RegExp 实例属性

RegExp 的每个实例都有以下属性：global、ignoreCase、lastIndex、multiline、source

<script>
    var pattern = /[bc]at/i;
    var pattern2 = new RegExp( "\[bc\]at", "i" );
    //global
    //布尔值
    //表示是否设置了 g 标志
    console.log( pattern.global );      //输出：false
    console.log( pattern2.global );     //输出：false
    //ignoreCase
    //布尔值
    //表示是否设置了 i 标志
    console.log( pattern.ignoreCase );   //输出：true
    console.log( pattern2.ignoreCase );  //输出：true
    //lastIndex
    //整数
    //表示开始搜索下一个匹配项的字符位置，从0算起
    console.log( pattern.lastIndex );    //输出：0
    console.log( pattern2.lastIndex );   //输出：0
    //multiline 
    //布尔值
    //表示是否设置了 m 标志
    console.log( pattern.multiline );    //输出：false
    console.log( pattern2.multiline );   //输出：false
    //source
    //正则表达式的字符串表示
    //按照字面量形式而非传入够早函数的字符串模式返回
    console.log( pattern.source );      //输出：[bc]at
    console.log( pattern2.source );     //输出：[bc]at
</script>

RegExp 实例方法

   exec()  

<script>
    var text = "mom and dad and baby";
    var pattern = /mom( and dad( and baby)?)?/gi;
    //lastIndex
    //lastIndex 属性用于规定下次匹配的起始位置
    console.log( pattern.lastIndex );   //输出：0
    //exec()
    //接收1个参数:要应用正则表达式的字符串
    //有匹配项，则返回一个包含第一个匹配项的数组
    //无匹配项，则返回 null
    var matches = pattern.exec(text);
    //index
    //index是使用exec()方法后返回的数组的属性
    //表示匹配项在数组中的位置
    console.log( matches.index );   //输出：0
    //input
    //input是使用exec()方法后返回的数组的属性
    //表示应用正则表达式的字符串
    console.log( matches.input );   //输出：mom and dad and baby
    //数组第一项：与整个模式匹配的字符串
    console.log( matches[0] );      //输出：mom and dad and baby
    //数组其它项：与模式中的捕获组匹配的字符串
    console.log( matches[1] );      //输出： and dad and baby
    console.log( matches[2] );      //输出： and baby 

    var text = "cat, bat, sat, fat";
    //模式不是全局模式，每次调用 exec()返回的都是第一个匹配项，lastIndex始终不变
    var pattern = /.at/;
    var matches = pattern.exec( text );
    console.log( matches.index );       //输出：0
    console.log( matches[0] );          //输出：cat
    console.log( pattern.lastIndex );   //输出：0
    mathces = pattern.exec( text );
    console.log( matches.index );       //输出：0
    console.log( mathces[0] );          //输出：cat
    console.log( pattern.lastIndex );   //输出：0
    //模式是全局模式，每次调用exec()都会返回字符串的下一个匹配项，lastIndex在每次调用exec()后都会变化
    var pattern = /.at/g;
    var matches = pattern.exec( text );
    console.log( matches.index );       //输出：0
    console.log( matches[0] );          //输出：cat
    console.log( pattern.lastIndex );   //输出：3
    mathces = pattern.exec( text );
    console.log( matches.index );       //输出：0
    console.log( mathces[0] );          //输出：bat
    console.log( pattern.lastIndex );   //输出：8
</script>

  test()  

<script charset="utf-8">
    var text = "000-00-0000";
    var pattern = /d{3}-d{2}-d{4}/;
    //test()
    //接受1个字符串参数。在模式与该参数匹配的情况下返回 true
    //经常用于验证用户输入
    if( pattern.test( text ) ){
        console.log( "匹配" );          //输出：匹配
    }

    //RegExp实例继承的 toLocaleString() 和 toString() 方法都会返回正则表达式的字面量，与创建正则表达式的方式无关。
    var pattern = new RegExp( "\[bc\]at", "gi" );
    console.log( pattern.toString() );          //输出：/[bc]at/gi
    console.log( pattern.toLocaleString() );    //输出：/[bc]at/gi
</script>

RegExp 构造函数属性

<script>
    var text = "Today is a happy day.";
    var pattern = /(.)app/g;
    var pattern2 = /(..)a(.)p(.)/g;

    if( pattern.test( text ) ){
        //input : 最近一次要匹配的字符串
        //$_ 等同于 input
        console.log( RegExp.input );        //输出:Today is a happy day.
        console.log( RegExp["$_"] );        //输出:Today is a happy day.
        //lastMarch : 最近一次匹配项
        //$& 等同于 lastMarch
        console.log( RegExp.lastMatch );    //输出：happ
        console.log( RegExp["$&"] );        //输出：happ
        //lastParen ：最近一次捕获组
        //$+ 等同于 lastParen
        console.log( RegExp.lastParen );    //输出：h
        console.log( RegExp["$+"] );        //输出：h
        //leftContext : input字符串中 lastMarch 之前的文本
        //$` 等同于 leftContext
        console.log( RegExp.leftContext );  //输出：Today is a 
        console.log( RegExp["$`"] );        //输出：Today is a 
        //rightContext : input字符串 lastMarch 之后的文本
        //$' 等同于 rightContext
        console.log( RegExp.rightContext ); //输出：y day.
        console.log( RegExp["$'"] );        //输出：y day.
        //multiline : 布尔值，表示是否所有表达式都是用多行模式
        //$* 等同于 multiline
        console.log( RegExp.multiline );
        console.log( RegExp["$*"] );        
    }
    
    //RegExp.$1、RegExp.$2......RegExp.$9 分别用于存储第一、第二。。。。。。第九个匹配的捕获组
    if( pattern2.test(text) ){
        console.log( RegExp.$1 );   //输出： h
        console.log( RegExp.$2 );   //输出：p
        console.log( RegExp.$3 );   //输出：y
        console.log( RegExp.$4 );   //输出：( 空字符串 )
    }
</script>