JS 正则表达式基础

规范用""，迫不得已才用''

• 正则表达式Regular Expression，简称regex或者regexp
• 是一种来描述文本模式的特殊语法。
• 一个正则表达式是由普通字符（例如字符'a'到'z'，'0'到'9'）以及特殊字符（称为元字符，如："\","*","?"等）组成。
简单的说一个正则表达式就是你需要匹配的字符串。
例如，正则表达式"A*B"匹配字符串"ACCCCB"但不匹配"ACCCCC".
JavaScript中正则表达式是由两个"/"所包围，由英文，数字和特殊字符组成

 

• 1 匹配模式

i（ignore case） ,g（global search）,m（multiline search）三个匹配模式

var reg01 = /abc/;
var reg02 = /a{1,2}b/g;
var reg03 = /a{1,2}b/ig;
  1,'i'为'ignore case',即忽略大小写
  2,'g'为'global search',即全局搜索
  3,'m'为'multiline search',即多行搜索

  <script>
 // i
 alert(/abc/.test('Abc')); //false  不忽略大小写
 alert(/abc/i.test('Abc'));//true   忽略大小写
 // g
 alert(/abc/.test('Abcabc'));//true 默认是全局搜索？
 alert(/abc/g.test('Abcabc')); // true 全局搜索
 // m
  alert('aa\rabc');
  alert(/^abc$/m.test('aa\nabc')); // true
  alert(/^abc$/.test('aa\nabc')); //false;
  alert(/abc/.test('aa\nabc')); //ture;
</script>

      不要将全局 RegExp 对象与 正则表达式 对象混淆。尽管听起来像是一回事，但它们是截然不同的。全局 RegExp 对象的属性包含不断更新的关于每个匹配出现的信息，而正则表达式对象只包含出现正则表达式匹配的信息。

  RegExp 例子：
 

function matchDemo(){
   var s;
   var re = new RegExp("d(b+)(d)","ig");
   var str = "cdbBdbsbdbdz";
   var arr = re.exec(str);
   s = "$1 contains: " + RegExp.$1 + "\n";
   s += "$2 contains: " + RegExp.$2 + "\n";
   s += "$3 contains: " + RegExp.$3;
   return(s);
}

 

• 2 特殊字符

.    除\n之外的所有字符

 

\     转义字符，例如'\n'匹配一个换行符, '\\'匹配'\', '\)'匹配')'  alert('a\nb');  alert('a\rb');

^     匹配文本的开头  如果正则表达式的'多行搜索'属性被设置即'm'属性 ^ 也匹配每个换行符'\n'或者回车符'\r'之的  

          位置。
         例如：
               alert(/^b$/m.test('a\nb')); // true
               alert(/^b$/.test('a\nb'));  // false
         注意：如果正则表达式不起头不加上 /^，则在字符串中找到与正则匹配的就返回true，不需要从头开始匹配，相当

                  于全文搜索匹配，不必要从头匹配

$     匹配文本的末尾  如果正则表达式的'多行搜索'属性被设置即'm'属性 ^ 也匹配每个换行符'\n'或者回车符'\r'之前的位

         置。
          例如：
                  alert(/^bc$/m.test('bc\n')); // true
                  alert(/^bc$/.test('bc\n'));  // false

*     0次或多次 
          将前一个字符或子表达式匹配0次或多次，等同于{0,}
         例如：
               alert(/zo*/.test('z')); // true
               alert(/zo*/.test('zoooooooooo')); //true 
               alert(/zo{0,}/.test('sdzjo')); //true
   
+    1次或多次
         将前一个字符或子表达式匹配1次或多次,等同于{1,}

?     0次或1次
        将前一个字符或子表达式匹配0次或1次
        例如：
               alert(/^oy?$/.test('o'));   //true
               alert(/^oy?$/.test('oy'));  //true
               alert(/^oy?$/.test('oyy'));//false

               alert(/oyp/.test('o\roypoyp')); // true
               alert(/^oyp$/.test('o\roypoyp'));//false

{n}     n次
                将前一个字符或子表达式匹配n次
                例如： 
                        alert(/o{2}/.test('poy'));  //  false 
                        alert(/o{2}/.test('pooy')); //  true


{n,}   至少n次
                将前一个字符或子表达式匹配至少n次

{n,m}  至少n次，至多m次
                      将前一个字符或子表达式匹配至少n次，之多m次
                       alert(/o{1,3}/.test('py'));   //false
                       alert(/o{1,3}/.test('pooy')); //true
                       alert(/o{1,3}/.test('pooooooy')); // true

                    注意：匹配前三个'o' 我觉得这样的话如果碰到一个o就返回，主要在^$这中间起作用

?     这里的？与上面的？不同，这里有条件限制
        条件 这个 ？ 跟在数量限定字符后 （*,+,?,{n},{n,},{n,m}）表示前面的匹配为'非贪婪'模式
        所谓非贪婪模式表示匹配尽可能少的字符。
       例如
          alert(/o+?/.test('poooo')); //true 仅仅匹配第一个o 可能这个速度上要快很多,匹配就返回
          alert(/o+/.test('poooo')); //true  匹配所有的o

(pattern)   匹配'pattern'的模式，并返回匹配的结果
                                结果可以用match和$1..获取，如果要匹配(的话，要用\(和\) 转义
                                alert(/(\d)/.test(1111)); //true

                                alert('12345'.match(/(\d)/)); // 1,1
                               //针对match函数如果没有设置全局标志 (g)，数组的0元素包含整个匹配，而第 1 到 n 元素包

                                含 了匹配中曾出现过的任一//个子匹配。这//相当于没有设置全局标志的 exec 方法。如果设置了

                                全局标志，元素0到n中包含所有匹配。
                                 alert('12345'.match(/(\d)/g));// 1,2,3,4,5

                                  /(\d\d)/g.test('12345'); 
                                  alert(RegExp.$1); // 12
                                  /(\d+)/.test('12345');
                                 alert(RegExp.$1);//12345

                                  var a = new RegExp('(\\d)/g'); 
                                  a.exec('12345');
                                 alert(RegExp.$1);  // 12345




(?:pattern)   （非捕获匹配） 经常与或"|"一起连用
                                    /(\d\d)/g.test('12345');
                                    alert(RegExp.$1); // 12 
                                     /(?:\d\d)/g.test('12345');
                                    alert(RegExp.$1); // 空字符串（注意这里！！！）
                                    它不返回结果速度很快



(?=pattern)    定位于'pattern'模式的匹配之前 （非捕获匹配），此匹配模式不占用字符，也就是
                                      是说当发生一个匹配后，对下一个匹配的搜索将直接从前一个匹配后开始
                                       alert(/Windows(?=95|2000)/.test("Windows3.1")); //false
                                       alert(/Windows(?=95|2000)/.test("Windows2000")); //true
                                       alert(RegExp.$1); // 空字符串  注意这里

                                       alert(/Windows(95|2000)/.test("Windows2000")); //true
                                       alert(RegExp.$0) //undefined $1 从1开始
                                        alert(RegExp.$1); // 2000  注意这里



(?!pattern)   与(?=pattern) 差不多，只不过取的反值
                                    alert(/Windows(?!95|2000)/.test("Windows3.1")); //true
                                     alert(/Windows(?!95|2000)/.test("Windows2000")); //false
                                     alert(RegExp.$1); // 空字符串  注意这里



x|y     匹配x或y
              z|food 可以匹配 z或者food
             (z|f)ood 可以匹配zood或者food
             alert((/(z|f)ood/).test('z')); // false

[xyz]    一个字符集合，匹配该集合中的任意一个字符

                      alert(/[xyz]/.test("axyzdf")); //true
                       alert(RegExp.$1);// 空字符串

                      alert(/([xyz])/g.test("axyzdf"));// 注意打了括号
                      alert(RegExp.$1); //x 说明只有定义类似(patter)的时候才在RegExp保存值
      
[^xyz]      一个字符集合，匹配不输入该集合范围中的任意一个字符
                            alert(/[^123]/.test('123')); //false
                            alert(/([^123])/.test('1235')); //false
                            alert(RegExp.$1); // 5 注意 正则打了括号才输出5的，如果没有括号则输出空字符串



[a-z]           一个字符 范围 集合，匹配属于该集合范围中的任意一个字符。


[^a-z]       一个字符 范围 集合，匹配不属于该集合范围中的任意一个字符

\b                   匹配一个单词的结尾 单词最后一个字母与空格之间的位置
                            alert(/yp\b/.test('oyp oo')); //true; 有个空格
                            alert(/yp\b/.test('oypoo')); //false
    

\B                   匹配一个非单词的结尾（匹配一个非结尾（单词的结尾））
                          alert(/yp\B/.test('oyp oo')); //false;
                           alert(/yp\B/.test('oypoo')); //true;

\cx                 匹配一个由'x'确定的控制字符


\d                    匹配一个数字，等同于[0-9]

\D                   匹配非一个数字，等同于[^0-9]

\f                     匹配一个填表符 等同于"\x0c" 和 "\cL"

                          alert('oy\x0c'); 
                          alert(/\cL/.test("oy\x0c"));  //true

\n                    匹配一个换行符，等同于"\x0a"和"\cJ"
                     例子：
                           alert("oy\np"); // oy 
                                                  // p
                           alert("oy\x0ap");// op
                                                     // p
                           alert("oy\cJp"); //oy\cJp
                           alert(/\cJ/.test("oy\np")); // true \cJ匹配换行符 注意
   
\r     匹配一个回车符，等同于"\x0d"和"\cM"

\s    匹配一个空白符，包括空格，制表符合填表符，等同于[\f\n\r\t\v];

\S    匹配一个非空白字符，等同于[^\f\n\r\t\v]
 
\t    匹配一个制表符，等同于"\x09"和'\cI'

\v    匹配一个垂直制表符，等同于"\0b"和"\cK"

\w    匹配一个英文字符，数字和下划线，等同于[A-Za-z0-9_]

\W    匹配一个非英文字符，数字和下划线，等同于[^A-Za-z0-9_]

\xn   匹配一个‘n’代表的字符
             n是该字符的十六进制ASCII编码，必须是两位数
            例如
           alert("\x41");    //  A
           alert(/\x41/.test("A")); //true
           alert("\x411")  // A1
           alert(/\x411/.test("A2")); //false
           alert(/\x411/.test("A1")); //true

\num      num是一个正整数，匹配一个前面匹配返回的的结果
                       alert(/(.)\1/.test("1")); // false 
                       alert(/(.)\1/.test("11")); // true
                       alert(RegExp.$1); // 1

                    注意(.) 匹配任意一个字符
                              alert(/(.)/.test('123123123123')) // true;
                              alert(RegExp.$1); // 1

    
\n        标示一个八进制或者对前面匹配的引用（注意不是匹配返回的结果） ？？
\nm   标示一个八进制或者对前面匹配的引用  ？？
\nml  标示一个八进制字符串


\un    匹配一个n代表的字符，n是该字符的十六进制Unicode编码，必须是4位的
              例如
                   alert(\u00A9);

• 3创建正则对象的方法

              方法1： var reg1 = /\w+/;// 普通创建
              方法2： var reg2 = new RegExp("\\w+"); // 用RegExp方法创建 
              两种方法创建同样拥有 exec(),test(),compile()方法，以及相应的属性，具体见文档

• 4 正则对象的属性和方法

         4.1 属性
                正则表达式对象的属性有4个:"global","ignoreCase","multiline","source"
                var regObj = /^This is a regular String\.\w+/gi;
                alert(regObj.global);  // true; 
                alert(regObj.ignoreCase); // true; 
                alert(regObj.multiline); //false
                alert(regObj.source); //^This is a regular String\.\w+
         4.2 方法
               正则表达式的方法有三个:"compile","exec","test"
               4.2.1 compile方法将正则表达式编译成内置的格式，可以提高执行速度 
               compile(stringPattern,[strFlags]); 


  

  <script> 
var str,regObj,t01,t02,startTime; 
str = "JLKJLJSDFJLSDJFLSDasdfasdfasdfsdflqwjeoqJJlasjJjkjkasdjJlasjdfljlweljLALAJljasljdlsjfdlajsLAJljsdnflsdjfsdf"; 
//未编译 
regObj = /asdfsdflqwjeoqJJlasjJjkjkasdjJlasjdfljlweljLALAJljasljdlsjfdlajsLAJljsdnfls/g; 
startTime = new Date(); 
for(var i = 0 ; i < 500000; i ++) { 
    str.match(regObj); 
} 
t01 = new Date() - startTime; 

//编译后 
regObj1 = regObj.compile("asdfsdflqwjeoqJJlasjJjkjkasdjJlasjdfljlweljLALAJljasljdlsjfdlajsLAJljsdnfls","g") 
var startTime2 = new Date(); 
for(var i = 0 ; i < 500000; i ++) { 
    str.match(regObj1); 
} 
t02 = new Date() - startTime2; 

alert("未编译时间="+t01+"\n"+"编译后="+t02); 
</script> 

可以看出是提高了效率但是非常不明显。 
    4.2.2 exec方法 
     var str = "The quick brown fox jumps over a lazy dog."; 
     var re = /\w+/g; 
     var arr; 
     while ((arr = re.exec(str))!=null) { 
          document.write("自位置"+arr.index+"至"+arr.lastIndex+" "+arr+"<br>"); 
     } 
     输出 
自位置0至3 The 
自位置4至9 quick 
自位置10至15 brown 
自位置16至19 fox 
自位置20至25 jumps 
自位置26至30 over 
自位置31至32 a 
自位置33至37 lazy 
自位置38至41 dog 
    详细信息见文档

  
      

 

• 5 正则与字符串的操作

       5.1 字符串的搜索与匹配
          search() 方法 返回搜索位置的索引
          match() 方法  返回搜索内容
          var str = "sdfsdfasdfvderwfvdber";
          alert(str.search(/fvd/g)); //9
          alert(str.match(/fvd/g));  // fvd,fvd

      5.2 字符串替换         

         alert("pyo love cj".replace(/pyo/,"oyp"));

         &It  --  < 
         &gt  --  >

 

 

 

 

 

3  正则表达式：
   3.1 中文的正则表达式  /^[\u0391-\uFFE5]+$/
       var reg = /^[\u0391-\uFFE5]+$/;
       alert(/^[\u0391-\uFFE5]+$/.test("我是oy"));
       alert(/^[\u0391-\uFFE5]+$/.test("我是欧阳"));
   3.2 年龄的正则表达式 /^1[0-9]{0,2}$/
       alert(/^1[0-9]{0,2}$/.test(199));//true