C# 正则表达式贪婪模式案例

案例一、

如 "acbacb"  正则  "a.*?b" 只会取到第一个"acb" 原本可以全部取到但加了限定符后,只会匹配尽可能少的字符 ,而"acbacb"最少字符的结果就是"acb" 。

案例二、

/// <summary>
        /// 去掉<script>标签
        /// </summary>
        static void Test2()
        {
            //要匹配的字符串
            string text = @"hello
                            <script>
                            alert(‘1‘);
                            </script>
                            regex
                            <script>
                            alert(‘2‘);
                            </script>
                            world";
            //正则表达式
            string pattern = @"<script>[\s\S]*?</script>";
            //string result = Regex.Replace(text, pattern, "").Replace("\r\n","").Replace(" ","");
            string result = Regex.Replace(text, pattern, "").Replace(" ", "");
            Console.WriteLine(result);
        }

        /// <summary>
        /// 获取<script>标签内容
        /// </summary>
        static void Test3()
        {
            //要匹配的字符串
            string text = @"hello
                            <script>
                            alert(‘1‘);
                            </script>
                            regex
                            <script>
                            alert(‘2‘);
                            </script>
                            world";
            //正则表达式
            string pattern = @"<script>[\s\S]*?</script>";
            Regex r = new Regex(pattern, RegexOptions.IgnoreCase);
            //string result = Regex.Replace(text, pattern, "").Replace("\r\n","").Replace(" ","");
            MatchCollection matchCollection = r.Matches(text);
            foreach (Match m in matchCollection)
            {
                //显示匹配开始处的索引值和匹配到的值
                System.Console.WriteLine("Match=[" + m + "]");
                CaptureCollection cc = m.Captures;
                foreach (Capture c in cc)
                {
                    Console.WriteLine("/tCapture=[" + c + "]");
                }
                for (int i = 0; i < m.Groups.Count; i++)
                {
                    Group group = m.Groups[i];
                    System.Console.WriteLine("/t/tGroups[{0}]=[{1}]", i, group);
                    for (int j = 0; j < group.Captures.Count; j++)
                    {
                        Capture capture = group.Captures[j];
                        Console.WriteLine("/t/t/tCaptures[{0}]=[{1}]", j, capture);
                    }
                }
            }
        }
时间: 2024-10-06 20:37:04

C# 正则表达式贪婪模式案例的相关文章

python 正则表达式 贪婪模式的简介和匹配时的几种模式

看到一篇文章,关于python正则的,http://www.cnblogs.com/huxi/archive/2010/07/04/1771073.html 贪婪模式与非贪婪模式: 正则表达式通常用于在文本中查找匹配的字符串.Python里数量词默认是贪婪的(在少数语言里也可能是默认非贪婪),总是尝试匹配尽可能多的字符:非贪婪的则相反,总是尝试匹配尽可能少的字符.例如:正则表达式"ab*"如果用于查找"abbbc",将找到"abbb".而如果使用

正则表达式 贪婪模式和非贪婪模式

1.贪婪模式:(.*)  (匹配尽可能多的字符) 2.非贪婪模式:(.*?) From:http://www.cnblogs.com/xuejianxiyang/p/5485284.html

正则表达式 贪婪模式 懒惰模式

当正则表达式中包含能接受重复的限定符时,通常的行为是(在使整个表达式能得到匹配的前提下)匹配尽可能多的字符.以这个表达式为例:a.*b,它将会匹配最长的以a开始,以b结束的字符串.如果用它来搜索aabab的话,它会匹配整个字符串aabab.这被称为贪婪匹配. 有时,我们更需要懒惰匹配,也就是匹配尽可能少的字符.前面给出的限定符都可以被转化为懒惰匹配模式,只要在它后面加上一个问号?.这样.*?就意味着匹配任意数量的重复,但是在能使整个匹配成功的前提下使用最少的重复.现在看看懒惰版的例子吧: a.*

正则表达式中的贪婪模式与非贪婪模式详解

1 概述 贪婪与非贪婪模式影响的是被量词修饰的子表达式的匹配行为,贪婪模式在整个表达式匹配成功的前提下,尽可能多的匹配,而非贪婪模式在整个表达式匹配成功的前提下,尽可能少的匹配.非贪婪模式只被部分NFA引擎所支持. 属于贪婪模式的量词,也叫做匹配优先量词,包括: “{m,n}”.“{m,}”.“?”.“*”和“+”. 在一些使用NFA引擎的语言中,在匹配优先量词后加上“?”,即变成属于非贪婪模式的量词,也叫做忽略优先量词,包括: “{m,n}?”.“{m,}?”.“??”.“*?”和“+?”.

正则表达式默认是贪婪模式

regex的---------------------正则表达式默认是贪婪模式,优先级|不高 没有^高因为.+要尽可能多的匹配.所以会认为1111.1 1. 111.111111.都是.+匹配的结果,但是由于正则表达式中最后还有一个 : . ,所以如果要是将.+匹配了所有的字符,则最后的 . (句号)无法找到匹配,正则表达式会尽可能的找到匹配,所以会将 .(句号)尝试给正则表达式中的最后一个字符(句号)来匹配,然后把前面的所有字符都用.+:来匹配.---------------------?功能

正则表达式贪婪与非贪婪模式

之前做程序的时候看到过正则表达式的贪婪与非贪婪模式,今天用的时候就想不起来了,现在这里总结一下,以备自己以后用到注意. 1.什么是正则表达式的贪婪与非贪婪匹配 如:String str="abcaxc"; Patter p="ab*c"; 贪婪匹配:正则表达式一般趋向于最大长度匹配,也就是所谓的贪婪匹配.如上面使用模式p匹配字符串str,结果就是匹配到:abcaxc(ab*c). 非贪婪匹配:就是匹配到结果就好,就少的匹配字符.如上面使用模式p匹配字符串str,结果

正则表达式之 贪婪与非贪婪模式

1 概述 贪婪与非贪婪模式影响的是被量词修饰的子表达式的匹配行为,贪婪模式在整个表达式匹配成功的前提下,尽可能多的匹配,而非贪婪模式在整个表达式匹配成功的前提下,尽可能少的匹配.非贪婪模式只被部分NFA引擎所支持. 属于贪婪模式的量词,也叫做匹配优先量词,包括: “{m,n}”.“{m,}”.“?”.“*”和“+”. 在一些使用NFA引擎的语言中,在匹配优先量词后加上“?”,即变成属于非贪婪模式的量词,也叫做忽略优先量词,包括: “{m,n}?”.“{m,}?”.“??”.“*?”和“+?”.

【转】正则表达式贪婪与非贪婪模式

转自:http://www.cnblogs.com/xudong-bupt/p/3586889.html 正则表达式贪婪与非贪婪模式 之前做程序的时候看到过正则表达式的贪婪与非贪婪模式,今天用的时候就想不起来了,现在这里总结一下,以备自己以后用到注意. 1.什么是正则表达式的贪婪与非贪婪匹配 如:String str="abcaxc"; Patter p="ab*c"; 贪婪匹配:正则表达式一般趋向于最大长度匹配,也就是所谓的贪婪匹配.如上面使用模式p匹配字符串st

python正则表达式贪婪与非贪婪模式

之前做程序的时候看到过正则表达式的贪婪与非贪婪模式,今天用的时候就想不起来了,现在这里总结一下,以备自己以后用到注意. 1.什么是正则表达式的贪婪与非贪婪匹配 如:String str="abcaxc"; Patter p="ab.*c"; 贪婪匹配:正则表达式一般趋向于最大长度匹配,也就是所谓的贪婪匹配.如上面使用模式p匹配字符串str,结果就是匹配到:abcaxc(ab.*c). 非贪婪匹配:就是匹配到结果就好,最少的匹配字符.如上面使用模式p匹配字符串str,