正则表达式(二) - 零宽断言与懒惰匹配以及平衡组

小括号的作用

分类 　　　　代码/语法 　　　　说明

捕获　　　　
　　　　　　(exp) 　　　　　　 匹配exp,并捕获文本到自动命名的组里
　　　　　　(?<name>exp) 　 匹配exp,并捕获文本到名称为name的组里，也可以写成(?'name'exp)
　　　　　　(?:exp) 　　　　   匹配exp,不捕获匹配的文本，也不给此分组分配组号
零宽断言
　　　　　　(?=exp) 　　　　 匹配exp前面的位置
　　　　　　(?<=exp) 　　　  匹配exp后面的位置
　　　　　　(?!exp) 　　　　  匹配后面跟的不是exp的位置
　　　　　　(?<!exp) 　　　　匹配前面不是exp的位置
注释
　　　　　　(?#comment) 这种类型的分组不对正则表达式的处理产生任何影响，用于提供注释让人阅读

要特别注意的是，零宽断言是不占用位置的，也就是说，匹配结果里是不会返回它的。

 (?:exp)　既不捕获匹配的文本，也不给此分组分配组号，这个东西到底有什么用呢？

 (?:exp) 非捕获组，匹配exp的内容，但不捕获到组里

至于作用，一般来说是为了节省资源，提高效率
比如说验证输入是否为整数，可以这样写
^([1-9][0-9]*|0)$
这时候我们需要用到()来限制“|”表示“或”关系的范围，但我们只是要判断规则，没必要把exp匹配的内容保存到组里，这时就可以用非捕获组了
^(?:[1-9][0-9]*|0)$

　　有的时候我们不得不用()，而()默认情况下会将其中exp匹配的内容捕获到组里，而有些情况我们只是判断规则，或者后面并不需要对此处()中匹配的内容进行引用时，就没有必要把它捕获到组里了，一方面会造成资源的浪费，另一方面会降低效率，这时候就要用到非捕获组了。

至于这些东西，说是说不明白的，看符号也没用，最好就是上例子。

//正则表达式牛逼，名词好牛B，其实好简单
        static void Main(string[] args)
        {
            //(exp) 匹配exp,并捕获文本到自动命名的组里
            Regex reg = new Regex(@"A(\w+)A");
            Console.WriteLine(reg.Match("dsA123A"));    //输出 A123A
            Console.WriteLine(reg.Match("dsA123A").Groups[1]);      //输出123

            //(?<name>exp)    匹配exp,并捕获文本到名称为name的组里，也可以写成(?'name'exp)
            Regex reg2 = new Regex(@"A(?<num>\w+)A");
            Console.WriteLine(reg2.Match("dsA123A").Groups["num"]); //输出123

            Regex reg3 = new Regex(@"A(?:\w+A)");
            Console.WriteLine(reg3.Match("dsA123A"));

            Console.WriteLine("==============================");

            //(?=exp)    匹配exp前面的位置  零宽正预测先行断言
            Regex reg4 = new Regex(@"sing(?=ing)");     //表达式的意思是，我认为在sing的后面会有ing，如果sing后面紧跟着ing，那么这个sing才匹配成功，注意断言词不会被匹配
            Console.WriteLine(reg4.Match("ksingkksingingkkk"));     //输出    sing
            Console.WriteLine(reg4.Match("singddddsingingd").Index);   //输出 8   输出8就意味住前面那个sing被没有被匹配

            //(?<=exp) 匹配exp后面的位置  零宽度正回顾后发断言
            Regex reg5 = new Regex(@"(?<=wo)man");
            Console.WriteLine(reg5.Match("Hi man Hi woman"));   //输出 man
            Console.WriteLine(reg5.Match("Hi man Hi woman").Index);     //输出 12    掰着手指头算算到底匹配的是哪一个

            //(?!exp)    匹配后面跟的不是exp的位置 零宽度负预测先行断言
            Regex reg6 = new Regex(@"sing(?!ing)");
            Console.WriteLine(reg6.Match("singing-singabc"));   //输出 sing
            Console.WriteLine(reg6.Match("singing-singabc").Index); //输出 8  还得掰着手指头算算匹配的是哪一个

            //(?<!exp)    匹配前面不是exp的位置 零宽度负回顾后发断言
            Regex reg7 = new Regex(@"(?<!wo)man");
            Console.WriteLine(reg7.Match("Hi woman Hi man"));   //输出 man
            Console.WriteLine(reg7.Match("Hi woman Hi man").Index); //输出 12  算算匹配的是哪一个

            //(?#comment)    不对正则表达式的处理产生任何影响，用于提供注释让人阅读
            Regex reg8 = new Regex("ABC(?#这只是一段注释而已)DEF");
            Console.WriteLine(reg8.Match("ABCDEFG"));   //输出 ABCDEF
        }

懒惰匹配

代码/语法 　　　　　　说明
*? 　　　　　　　　　重复任意次，但尽可能少重复
+? 　　　　　　　　　重复1次或更多次，但尽可能少重复
?? 　　　　　　　　　 重复0次或1次，但尽可能少重复
{n,m}? 　　　　　　  重复n到m次，但尽可能少重复
{n,}? 　　　　　　　  重复n次以上，但尽可能少重复

如果你细心的留意到，会发现，其实懒惰匹配符只是在原有限定符后面加了个？以表示尽可能少地匹配的意思。

class Program
    {
        //正则表达式牛逼，名词好牛B，其实好简单
        static void Main(string[] args)
        {
            //懒惰匹配
            Regex reg1 = new Regex(@"A(\w)*B");
            Console.WriteLine(reg1.Match("A12B34B56B"));    //输出 A12B34B56B //留意到默认是尽可能多地匹配

            Regex reg2 = new Regex(@"A(\w)*?B"); //\w重复任意次，但尽可能少          
            Console.WriteLine(reg2.Match("A12B34B56B"));   //输出 A12B

            Regex reg3 = new Regex(@"A(\w)+?");  //\w重复1次或更多次，但尽可能少
            Console.WriteLine(reg3.Match("AB12B34B56B"));        //输出AB 注意此处测试字符串

            Regex reg4 = new Regex(@"A(\w)??B");  //\w重复0次或1次，但尽可能少
            Console.WriteLine(reg4.Match("A12B34B56B"));    //输出 空白，匹配失败，因为至少也要重复\w两次
            Console.WriteLine(reg4.Match("A1B2B34B56B"));   //输出 A1B

            Regex reg5 = new Regex(@"A(\w){4,10}?B");       //\w至少重复4次，最多重复10次
            Console.WriteLine(reg5.Match("A1B2B3B4B5B"));   //输出 A1B2B3B    到了第4个的时候，恰好第4个字符是3只有匹配3后面的那个B了

            Regex reg6 = new Regex(@"A(\w){4,}?");  //\w至少重复4次，最多无上限
            Console.WriteLine(reg5.Match("A1B2B3B4B5B"));   //输出 A1B2B3B    到了第4个的时候，恰好第4个字符是3只有匹配3后面的那个B了

            Console.ReadKey();
        }
    }

 平衡组

正则表达式平衡组用于匹配左右两边开始，结束符号相等数量的内容
　　例如，对于字符串"xx <aa <bbb> <bbb> aa> yy>" 左右两边的< > 是不等的，如果简单的<.+>匹配到的是最外层的开始括号<与结束括号 
>之间的内容，但是开始和封闭的括号数量不一致。如果你希望匹配到的是左右括号正常结束的字符串，那么就需要用到平衡组了。

平衡组语法：
　　(?'group') 把捕获的内容命名为group,并压入堆栈(Stack)
　　(?'-group') 从堆栈上弹出最后压入堆栈的名为group的捕获内容，如果堆栈本来为空，则本分组的匹配失败
　　(?(group)yes|no) 如果堆栈上存在以名为group的捕获内容的话，继续匹配yes部分的表达式，否则继续匹配no部分
　　(?!) 零宽负向先行断言，由于没有后缀表达式，试图匹配总是失败

        static void Main(string[] args)
        {
            //平衡组 我们现在要匹配最外层的括号的内容
            string strTag = "xx <aa <bbb> <bbb> aa> yy>";   //要匹配的目标是 <aa <bbb> <bbb> aa>  ，注意括号数不等
            Regex reg = new Regex("<.+>");
            Console.WriteLine(reg.Match(strTag));   //输出 <aa <bbb> <bbb> aa> yy>    看到与希望匹配的目标不一致，主要是因为 < 与 > 的数量不相等

            Regex reg3 = new Regex("<[^<>]*(((?'Open'<)[^<>]*)+((?'-Open'>)[^<>]+))*(?(Open)(?!))>");
            Console.WriteLine(reg3.Match(strTag));  //<aa <bbb> <bbb> aa>   目标正确


            //平衡组最常用的例子，匹配HTML，以下是匹配嵌套DIV里面的内容
            Regex reg2 = new Regex(@"<div[^>]*>[^<>]*(((?'Open'<div[^>]*>)[^<>]*)+((?'-Open'</div>)[^<>]*)+)*(?(Open)(?!))</div>");
            string str = "<a href='http://www.baidu.com'></a><div id='div1'><div id='div2'>你在他乡还好吗？</div></div><p></p>";
            Console.WriteLine(reg2.Match(str));  //输出 <div id='div1'><div id='div2'>你在他乡还好吗？</div></div>
            Console.ReadKey();
        }

语法解释：
<                         #最外层的左括号
    [^<>]*                #最外层的左括号后面的不是括号的内容
    (
        (
            (?'Open'<)    #碰到了左括号，在黑板上写一个"Open"
            [^<>]*       #匹配左括号后面的不是括号的内容
        )+
        (
            (?'-Open'>)   #碰到了右括号，擦掉一个"Open"
            [^<>]*        #匹配右括号后面不是括号的内容
        )+
    )*
    (?(Open)(?!))         #在遇到最外层的右括号前面，判断黑板上还有没有没擦掉的"Open"；如果还有，则匹配失败

>                         #最外层的右括号