关闭

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

标签: C#正则表达式
673人阅读 评论(0) 收藏 举报
分类:
小括号的作用


分类     代码/语法     说明


捕获    
      (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匹配的内容捕获到组里,而有些情况我们只是判断规则,或者后面并不需要对此处()中匹配的内容进行引用时,就没有必要把它捕获到组里了,一方面会造成资源的浪费,另一方面会降低效率,这时候就要用到非捕获组了。


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


        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";如果还有,则匹配失败

>                         #最外层的右括号


0
0
查看评论

JavaScript正则表达式(基础、分组、懒惰匹配、反向引用和零宽断言)

基础 常用字符总结 基本的匹配 基础 懒惰匹配 分组 反向引用 零宽断言 练习 基础常用字符总结:^ 匹配行的开始位置 $ 匹配行的结束位置 \b 匹配单词的开始或结束位置 . 匹配除换行符之外的任意字符 \w 匹配单词字符(包括字母、数字、下划线和汉字) \W 匹配非单词字符 \s ...
  • Transcendental
  • Transcendental
  • 2017-07-17 22:12
  • 483

正则表达式-零宽断言实践

处理JSON字符串KEY值中的特殊字符,VALUE中的字符不受影响。 处理字符串替换一般都是用String的replace系列方法。在这里用replaceAll(),这个方法可以使用正则表达式。简单的说零宽断言表示匹配字符的时候再添加一些定位条件,使匹配更精准。
  • RickyIT
  • RickyIT
  • 2016-12-21 11:36
  • 696

正则表达式之零宽断言详解

什么是零宽断言;正向先行断言;反向先行断言;正向后发断言;反向后发断言;
  • hsd2012
  • hsd2012
  • 2016-04-28 11:16
  • 4500

正则表达式零宽断言在php中的问题

最近在学习正则表达式,有一个这样的正则:"#(?<=<(\w+)>).*(?=<\/\1>)#“用来匹配像html标签里面的内容。类似<div>aaa</div>中的aaa,但是在php中测试的时候:$reg='#(?<=...
  • zshdd
  • zshdd
  • 2017-03-23 21:25
  • 537

C#正则表达式(3):注释,分组,向后引用,零宽断言,贪婪

注释   任何程序语言都会有注释.不然很多代码不容易看懂啊.像正则表达式这种表达式如果来个几千行,没一点注释,你想不看得吐血都难啊. 注释的格式是(?#comment)其中comment就表示注释的内容比如abc[\d(?#this means digit)]* 它就等同于abc[\...
  • weiwenhp
  • weiwenhp
  • 2012-06-14 21:03
  • 4607

老男孩带你了解perl正则表达式中的零宽断言

老男孩IT教育老男孩老师为大家整理了perl正则表达式中的零宽断言的方法,希望能帮到大家 1.1前言 本文只介绍perl语言正则表达式的零宽断言功能。 零宽断言实质:匹配文本里面的位置。 零宽断言叫zero-length assertions,也叫lookaround(这个更容易理解)。...
  • oldboylinux
  • oldboylinux
  • 2017-05-31 15:52
  • 1631

教你怎么理解正则表达式之零宽断言(环视)

思考题 今天有人问一个关于零宽断言的正则: var reg = /(?=a)b/; reg.exec("ab"); 大家思考下这个正则为什么匹配不了?我们先了解一下什么叫零宽断言,最后再来回答这个问题。 概念理解 零宽断言(有的资料叫它环视),分为零宽度正预测先行断言( 格式为...
  • binjly
  • binjly
  • 2013-09-29 13:23
  • 3000

Java正则表达式 预搜索(零宽断言)详解(精)

查看原文:http://ibloger.net/article/31.html零宽断言的意思是(匹配宽度为零,满足一定的条件/断言) 我也不知道这个词语是那个王八蛋发明的,简直是太拗口了。 零宽断言用于查找在某些内容(但并不包括这些内容)之前或之后的东西,也就是说它们像 \b ^ $ \< \...
  • xiaokui_wingfly
  • xiaokui_wingfly
  • 2016-07-21 17:22
  • 2820

对正则表达式零宽断言的个人理解(Java测试下)

零宽断言主要有4种形式:正预测零宽断言(?=),负预测零宽断言(?!),正回顾零宽断言(?(翻译可能不准确) 可以看出主要分为正向负向和预测回顾的各种组合 所谓正向,指的是匹配表达式,负向则指不匹配(他们最主要的区别就是=和!) 所谓预测指的是要匹配的后面部分,还没匹配到,但是预测可以匹配,回顾指已...
  • l707268743
  • l707268743
  • 2016-11-08 13:45
  • 1128

python正则表达式系列(5)——零宽断言

本文主要总结了python正则零宽断言(zero-length-assertion)的一些常用用法。
  • dnxbjyj
  • dnxbjyj
  • 2017-04-29 11:38
  • 732
    个人资料
    • 访问:63797次
    • 积分:879
    • 等级:
    • 排名:千里之外
    • 原创:18篇
    • 转载:40篇
    • 译文:0篇
    • 评论:2条