正则表达式

 正则表达式

正则表达式可以做什么？

     1.测试字符串的某个模式。例如，可以对一个输入字符串进行测试，看在该字符串是否存在一个电话号码模式或一个信用卡号码模式，这称为数据有效性验证 。

     2.替换文本。可以在文档中使用一个正则表达式来标识特定文字，然后可以全部将其删除，或者替换为别的文字。

     3.根据模式匹配从字符串中提取一个子字符串。可以用来在文本或输入字段中查找特定文字 

     4 正则表达式看上去并不像某种语言或者某个技术那么重要，仅靠它们你无法写出一个应用程序来。然而，它们却总是在你的开发过程中如影随形，

     不管是进行表单验证，还是高亮显示搜索结果，或者是进行URL地址映射，都是非常有用的。

  总共可以分为以下几大模块：

   1.匹配单个字符

   2.匹配多个字符

   3.匹配边界

   4.匹配子模式

   5.后向引用

   6.文本替换

   7.预查和非获取匹配

  正则表示在多种开发语言（c#，javascript等）中都有应用，我主要用javascript作为例子学习和总结。

  通常情况下， 如果一个文本中出现了多个匹配， 正则表达式返回第一个匹配， 如果将 global设置为 true， 则会返回全部匹配；

  匹配模式是大小写敏感的，如果设置了 ignore case 为 true 则忽略大小写。

 

 在js中使用正则表达是，主要通过两种方法 

一：通过RegExp对象，他有三个方法 test（） exec（） compile（）

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

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

   3.compile() 方法用于改变 RegExp。

   具体实例：

<script type="text/javascript">
   //RegExp 直接量语法 就是两个斜杠 /表达式/
   //var reg=new RegExp('I') 等价于 /I/
   //test  的用法
   function showTest(){
        var text='I love china';
        var patt=new RegExp('I');
        var isTrue=patt.test(text);  //只要有一个I存在就返回true ,否则false
   }
   //exec 的用法
   function showExec(){
        var text='I love china';
        var patt=new RegExp('I');
        var result=patt.exec(text);  //返回 I
        
        
   }
   //全局 大小写 设置
   function showGI(){
       var text='I love china I love american I love world';
        var re='';
        var patt=new RegExp('I','g');
        do{
         re=patt.exec(text);
         alert(re)
        }while(re!=null)
        //如果加上i 就不区分大小了
        var patt=new RegExp('I','gi');
   }
   //compile 的用法
   function showCompile(){
        var text='I love china'
        var patt=new RegExp('I');
        var isTrue=patt.test(text);  //true
        patt.compile('x');
        var isTrue=patt.test(text);  //false
    
   }

二：字符串的match 和replace 方法

   function showMatch(){
      var str='I love you!';
      var reg1=str.match('you');  //you
      var reg2=str.match('you!'); //you!
   }
   function showMatch2(){
      var str='I love you you you you....';
      var reg=/you/g;
      var reg1=str.match(reg); //它会将所有的you都以数组的形式存储
      //这个是与exec 最大的区别
   }

function showReplace(){
      var str='I love you you you you....';
      var reg=/you/;
      var reg1=str.replace(reg,'me'); 
      //结果：I love me you you you...."
      //如果要替换所有的 you 
      //那么就要加上：g
      //var reg=/you/g;
    
   }

  1.匹配单个字符

   function reg(){
    //1.匹配固定单个字符 i
    //2.匹配任意单个字符 .  
    //3.匹配“.”元字符 \.
    //4.匹配字符组   [en]
    //5 在字符组中使用字符区间  [a-z]
    //6 反义字符组 [^en]
    //7 匹配元字符,要使用“\”来进行转义
    //8 匹配空字符 
    /*

     \r  回车
     \n  换行
     \t  Tab 键
 
     \d  所有单个数字，与 [0-9] 相同
     \D  所有非数字， 与 [^0-9] 相同
     \w  所有单个大小写字母、数字、下划线，与 [ a-zA-Z0-9_ ] 相同
     \W  所有单个非大小写字母、非数字、非下划线，与 [^ a-zA-Z0-9_ ] 相同
     \s  所有单个空字符，与 [\f\n\r\t\v] 相同
     \S  所有单个非空字符，与 [^\f\n\r\t\v] 相同
  */

   }

  2.匹配多个字符

     正则表达式中，可以在 单个字符(比如“j”)、字符组(比如“[abcde]”)、特定字符类型，(比如“\d”)、单个任意字符(即“.”) 后面加“+” ，来表示匹配一个或多个(换言之，至少一个)字符组成的字符串。

function reg2(){
     /*
        1.匹配一个或多个         i+  一个或者多个i
        2.匹配零个或多个字符      i*  0个或者多个i
        3.匹配零个或一个字符串    i?  0个或者一个字符
        4.匹配指定数目字符        i{3} 匹配三个i
        5.匹配区间以内数目的字符   i{1,3} 最少一个i 最多3个i
     */   
       
   }

 贪婪匹配和惰性匹配

贪婪匹配(greedy)：它会匹配尽可能多的字符。

惰性匹配(lazy)：     它会匹配尽可能少的字符，它从第一个字符开始找起，一旦符合条件，立刻保存到匹配集合中，然后继续进行查找。所以说它是懒惰的。

   

    举例说明：

function reg3(){
       var txt='I LOVE <strong>ME</strong> AND <strong>YOU</strong> !';
       //现在我们要匹配 <strong></strong>  之间的内容；
       var greedy=/<strong>.*<\/strong>/g  
       var lazy= /<strong>.*?<\/strong>/g
       
       var re=txt.match(greedy);
       var re1=txt.match(lazy);
      
   }

结果：

 

注意：

一个是“{n}”，对于这种形式的匹配，由于它精确地要求匹配 n 个字符，所以无所谓贪婪还是惰性，尽管“{n}?”也是正确的匹配写法，

但它的匹配结果总是与“{n}”相同。

还有一个就是“??”

3.匹配边界

 则表达式中，可以在 字符 前加“\b”，来匹配其 后面 的字符位于字符串首位的字符

   function reg4(){
     //a 开头的单词，换句话说a不能在中间，或者结尾处
     var txt='good nice awesome gain';
     var reg=/\ba/g;
     var result=txt.match(reg);
       
   }
   function reg5(){     
     //匹配单词 old
     var txt ='the old man wear a gold watch' 
     var reg=/\bold/g;
     var result=txt.match(reg);
     //正则表达式中，可以在 字符 后加“\b”，来匹配其 前面 的字符位于字符串末位的字符
   }

边界及其相对性

    通常情况下，以 空格、段落首行、段落末尾、逗号、句号 等符号作为边界，值得注意的是，分隔符“-”也可以作为边界

 function reg7(){
       var txt='aaaa,bbbb';   
       var txt1='aaa-,-bbb';
       var reg=/\b,\b/g
       var re=txt.match(reg);  //,
       var re1=txt1.match(reg); //null
   }

 有了“\b”，自然有“\B”，它用来匹配不在边界的字符,匹配非单词边界

匹配文本首

在正则表达式中，可以在 匹配模式的第一个字符前添加 “^”，以匹配 满足模式且位于全部文本之首的字符串

在正则表达式中，可以在 匹配模式的最后一个字符后添加 “$”，以匹配 满足模式且位于全部文本之末的字符串。

4.匹配子模式

1.在正则表达式中，可以使用“(”和“)”将模式中的子字符串括起来，以形成一个子模式,将子模式视为一个整体时，那么它就相当于一个单个字符。
2.在正则表达式中，可以使用“|”将一个表达式拆分成两部分“reg1|reg2”，它的意思是：匹配所有符合表达式 reg1 的文本 或者 符合表达式 reg2 的文本。

3.用子模式的一个作用：系统会在幕后将所有的子模式保存起来，以供后向引用使用(包含查找时的后向引用 和 替换时的后向引用)

    function reg8(){
      //我们想要匹配 “1900”到“2099”的所有年份
      txt='1890 1991 2008 2990'    ;
      var reg=/(19|20)\d{2}/g //较为综合的一个应用
    }

5.后向引用

1.正则表达式中，使用“\数字”来进行后向引用，数字表示这里引用的是前面的第几个子模式。

 function reg8(){
    var txt='let us go go!';
    var reg=/(go) \1/g;
    var result=txt.match(reg); 
  }
  
  //匹配重复单词
  function reg9(){
      var reg=/(\w+) \1/g;
  }
  //匹配有效的 HTML 
  function reg10(){
      var reg=/<h([1-6])>.*?<\/h\1>/g;
        
  }

.Net 中的后向引用

     在 .Net 中使用正则表达式进行查找时，给子模式命名的语法是：?<name>，后向引用的语法是：\k<name>。

6.文本替换

正则表达式的三部曲应该是：1、查找；2、引用匹配了的文本(后向引用)；3、有选择地替换文本。

需要注意的是：大部分语言的正则表达式实现，在查找中，使用后向引用来代表一个子模式，其语法是“\数字”；而在替换中，其语法是“$数字”。

 function reg11(){
    var txt='<h1>This is a valid header</h1>';
    var reg=/<h1>(.*?)<\/h1>/g;
    var repalce='<h1 style="background:#ff0">$1</h1>'
    var result=txt.replace(reg,repalce); 
    //结果：
    //"<h1 style="background:#ff0">This is a valid header</h1>" 
    
  }
  //替换电话号码
  //格式都改为：029-8401132
  function reg12(){
     var txt='(020)82514769 (021)83281314 (029)88401132';  
     var reg=/\((\d{3})\)(\d{8})/g;
     var replaceReg='$1-$2';
     var result=txt.replace(reg,replaceReg);
     //结果：
     //020-82514769 021-83281314 029-88401132
  }

.Net 中的文本替换

    在 .Net 中使用正则表达式进行替换时，给子模式命名的语法是：?<name>，后向引用的语法是：${name}

7.预查和非获取匹配

        1.用子模式的一个作用：系统会在幕后将所有的子模式保存起来，以供后向引用使用(包含查找时的后向引用 和 替换时的后向引用)

        2.而很多时候，我们添加一个子模式，并不是为了在后向引用中获取它，我们或许是出于匹配需要，或许简单的只是为了使表达式更清晰，
         正则表达式中，可以在子模式内部前面加“?:”来表示这个子模式是一个 非获取匹配，非获取匹配不会被保存，不能在后向引用中获取。

        3. 正则表达式中，可以在子模式内部前面加“?:”来表示这个子模式是一个 非获取匹配，非 获取匹配不会被保存，不能在后向引用中获取。

function reg13(){
       var txt='window 98 window2000xp window 2008'
       var reg=/window (?:[\w.]+\b)/g;
       var replaceReg='Win$1';
       var result=txt.replace(reg,replaceReg);
       //结果：
       //Win$1 window2000xp Win$1
       //“$1”被当作一个普通字符进行了处理
   }

正向预查

它的语法是在 子模式内部 前面加“?=”，表示的意思是：首先，要匹配的文本必须满足此子模式它的语法是在 子模式内部 前面加“?=”，表示的意思是：
首先要满足整个表达式，然后提出满足子模式的部分。剩下的才是我们想要的

   function reg14(){
      // 满足真模式滴,然后踢出满足子模式滴部分
       var txt='windows 98 windows 2000xp windows 2008 windows3000'
       var reg=/windows (?=[\w.]+\b)/g;
       var result=txt.replace(reg,'MC');
       
       //结果：MC98 MC2000xp MC2008 windows3000
       
   }

反向预查 

    反向预查 的语法是在子模式内部前面加“?<=”，表示的意思是：首先，要匹配的文本必须满足此子模式  后面  的表达式其次，此子模式不参与匹配

 

　　 由于js中不支持反向预查，此处就不举例了！

        

正向、反向预查组合

 

负正向预查、负反向预查

一个html编码代码

function HTMLEncode(input) {
            var convert = document.createElement("DIV");
            convert.innerText = input;
            var output = convert.innerHTML;
            convert = null;
            return output;
        }

  总结：本小节，只是对正则表达式的基本语法做一些讲解，具体的实例总结，亲看第二篇；

   参考文献：

  张子阳的：http://www.tracefact.net/Misc/Regular-Expression-Tutorial.aspx（他讲得非常详细了）