JS 正则（RegExp）

摘要：返回值是被找到的值。序列匹配，而则匹配。还有关于如何选择一个这里的，转换成文本后，只表示一个就是说这段待执行文本内含一个构建正则思考一下创建正则的几种方式并且多认识一个正则方法匹配前面的子表达式一次或多次。和均为非负整数，其中。

通过 new 关键词来定义 RegExp 对象。

test() 方法检索字符串中的指定值。返回值是 true 或 false。

        var r = new RegExp("e");
        var str = "hello world!";
        alert(r.test(str))            // true

exec() 方法检索字符串中的指定值。返回值是被找到的值。如果没有发现匹配，则返回 null。

        var r = new RegExp("e");
        var str = "hello world!";
        alert(r.exec(str));            // "e"

这些是JS RegExp提供的一些方法，简单介绍下；

        var reg = /is/;

这就是一个简单的字面量正则赋值

例如， "n" 匹配字符 "n"。" " 匹配换行符。序列 "" 匹配 ""，而 "(" 则匹配 "("。

还有关于如何选择一个？

        var str1 = "aaaAAA";            // 这里的，转换成文本后，只表示一个,就是说这段待执行文本内含一个
        console.log(str1);                // "aaaAAA"
        var r = new RegExp(//);         // 构建正则
        console.log(str1.replace(r,"R")); // "aaaRAAA"

        var s = "ffffdffffdffffdd";
        
        var r = /d/;                // "Sffffdffffdffffd"
        var r1 = new RegExp("d");    // "Sffffdffffdffffd"
        var r2 = new RegExp(/d/);    // "Sffffdffffdffffd"
        var r3 = new RegExp("d");    // "Sffffdffffdffffd"
        
        var R = /d+/;                // "S"
        var R1 = new RegExp("d+")    // "S"
        var R2 = new RegExp(/d+/);    // "S"
        var R3 = new RegExp("d+"); // "S"
        //    console.log(s.replace(rX,"S"))

        var reg = /is/;
        var str = "He is a boy. This is a dog. Where is she?";
        console.log(
            str.replace(reg,"IS")
        );
        // "He IS a boy. This is a dog. Where is she?" 
        // 使用replace方法，将按照正则规则选择到的字符串（... is ...）替换为"IS",但是我们发现只有第一句被替换

只有第一句被替换？引出我们的：

在一段字符串中，可能存在若干符合正则的选择，不执行全局g，只会选择第一个，执行全局g，所有符合的都会被选择到。
另一种说法：global可选标志，带这个标志表示替换将针对行中每个匹配的串进行，否则则只替换行中第一个匹配串

   reg = /is/g;
   console.log(str.replace(reg,"IS"));     // "He IS a boy. This IS a dog. Where IS she?"

例如，zo* 能匹配 "z" 以及 "zoo"。* 等价于{0,}。

PS：.*连在一起就意味着任意数量的不包含换行的字符

        var str = "ffffdffffd
dfdf";
        console.log(str);        // "ffffdffffd 
                                 // dfdf"        这里文本排列错误，但是知道里面存在一个换行符就对了
        var reg = /.*/;                    
        console.log(str.replace(reg,"X"));      // "X
                                                // dfdf"    选择了换行符前面的任意字符（这里重复任意次）

这里要提到一个中括号：

        var str = "a1b2c3d4";
        
        var reg = /d/;                            // 选择一个数字字符（而已）哪怕有更多选择只选择第一个遇到的
        console.log(str.replace(reg,"X"));        // "aXb2c3d4"
        reg = /d/g;                            // 在全局中，选择数字字符，并返回多个（如果存在）符合规则的字串
        console.log(str.replace(reg,"X"));        // "aXbXcXdX"
        reg = /[a-z]d/g                        // 一个a-z任意字符和一个数字字符，并返回多个（如果存在）符合规则的字串
        console.log(str.replace(reg,"X"));        // "XXXX"
        reg = /[a-z]d/                            // 一个a-z任意字符和一个数字字符
        console.log(str.replace(reg,"X"));        // "Xb2c3d4"
        // D 匹配一个非数字字符，与d相反
        str = "123ABC"
        reg = /D/;
        console.log(str.replace(reg,"0"));        // "1230BC"
        reg = /D/g;                            // 一个非数字字符，并返回多个（如果存在）符合规则的字串
        console.log(str.replace(reg,"0"));        // "123000"
        reg = /D{3}/;                            // 三个连续的非数字字符
        console.log(str.replace(reg,"456"));    // "123456"
        
        // 区分大小写
        str = "A1B2C3d4"
        reg = /[A-Z]/g;                            // 选择A-Z大写字母任意一个，并返回多个（如果存在）符合规则的字串
        console.log(str.replace(reg,"O"))        // "O1O2O3d4"
        reg = /[A-Z]d/;                        // 选择A-Z大写字母任意一个和一个数字
        console.log(str.replace(reg,"O"))        // "OB2C3d4"
        reg = /[A-Z]d/g;                        // 选择A-Z大写字母任意一个和一个数字，并返回多个（如果存在）符合规则的字串
        console.log(str.replace(reg,"O"))        // "OOOd4"

和大括号：

还有之前的：

以上5种在正则中被成为限定符，很好理解，限制匹配次数嘛

        var str = "A1234B123C123456";
        
        var reg = /d{4}/;                        // {4}之前的d重复匹配4次
        console.log(str.replace(reg,"&"));        // "A&B123C123456"
        reg = /d{6}/                            // 重复6次
        console.log(str.replace(reg,"&"));        // "A1234B123C&"
        reg = /[A-Z]d{6}/                        // 一个A-Z任意字母，和一个连续6个任意数字
        console.log(str.replace(reg,"&"))        // "A1234B123&"
        
        str = "000&1111&222222&55555555&";
        reg = /d{4,}/;                            // 一个数字，至少匹配4次
        console.log(str.replace(reg,"——"));        // "000&——&222222&55555555&"
        reg = /d{4,}/g;                        // （一个数字，至少匹配4次），并返回多个符合规则的匹配串
        console.log(str.replace(reg,"——"));        // "000&——&——&——&"
        reg = /d{4,6}/g;                        // (一个数字，至少4次，至多6次)
        console.log(str.replace(reg,"——"));        // "000&——&——&——55&"

        reg = /d?/g;                            // 等价于：{0,1}
        console.log(str.replace(reg,"？"));        //　"？？？？&？？？？？&？？？？？？？&？？？？？？？？？&？"

        reg = /d+/;                            // 等价于：{1,}
        console.log(str.replace(reg,"+"));        // "+&1111&222222&55555555&"
        reg = /d+/g;                            
        console.log(str.replace(reg,"+"));        // "+&+&+&+&"
        
        reg = /d*/g;
        console.log(str.replace(reg,"+"));        // "++&++&++&++&+"            

正则表达式30分钟入门教程

正则表达式语言

正则表达式

正则表达式全部符号解释