（从网上考过来的，收藏） javascript 正则表达式的贪婪与非贪婪

以下内容转自：http://www.cnitblog.com/yemoo/archive/2009/01/09/12675.html



以前看正则表达式，但没有注意到正则表达式的贪婪与非贪婪模式，今天在经典上看到了这么段代码：

<script>
try{
str="<p>abcdefg</p><p>abcdefghijkl</p>";

re1=str.match(/<p>[/W/w]+?<//p>/ig);
alert("非贪婪模式:/r/n/r/n１："+re1[0]+"/r/n２："+re1[1]);

re1=str.match(/<p>[/W/w]+<//p>/ig);
alert("贪婪模式:/r/n/r/n"+re1);

re1=str.match(/<p>(.+?)<//p>/i);
alert("非贪婪模式，且不要标记:/r/n/r/n１："+re1[1]);

re1=str.match(/<p>(.+)<//p>/i);
alert("贪婪模式，且不要标记:/r/n/r/n"+re1[1]);
}catch(e){alert(e.description)}
</script>




匹配次数中的贪婪与非贪婪

    在使用修饰匹配次数的特殊符号时，有几种表示方法可以使同一个表达式能够匹配不同的次数，比如："{m,n}", "{m,}", "?", "*", "+"，具体匹配的次数随被匹配的字符串而定。这种重复匹配不定次数的表达式在匹配过程中，总是尽可能多的匹配。比如，针对文本 "dxxxdxxxd"，举例如下：




表达式


匹配结果




(d)(/w+)


"/w+" 将匹配第一个 "d" 之后的所有字符 "xxxdxxxd"




(d)(/w+)(d)


"/w+" 将匹配第一个 "d" 和最后一个 "d" 之间的所有字符 "xxxdxxx"。虽然 "/w+" 也能够匹配上最后一个 "d"，但是为了使整个表达式匹配成功，"/w+" 可以 "让出" 它本来能够匹配的最后一个 "d"


    由此可见，"/w+" 在匹配的时候，总是尽可能多的匹配符合它规则的字符。虽然第二个举例中，它没有匹配最后一个 "d"，但那也是为了让整个表达式能够匹配成功。同理，带 "*" 和 "{m,n}" 的表达式都是尽可能地多匹配，带 "?" 的表达式在可匹配可不匹配的时候，也是尽可能的 "要匹配"。这 种匹配原则就叫作 "贪婪" 模式 。

    非贪婪模式：

    在修饰匹配次数的特殊符号后再加上一个 "?" 号，则可以使匹配次数不定的表达式尽可能少的匹配，使可匹配可不匹配的表达式，尽可能的 "不匹配"。这种匹配原则叫作 "非贪婪" 模式，也叫作 "勉强" 模式。如果少匹配就会导致整个表达式匹配失败的时候，与贪婪模式类似，非贪婪模式会最小限度的再匹配一些，以使整个表达式匹配成功。举例如下，针对文本 "dxxxdxxxd" 举例：




表达式


匹配结果




(d)(/w+?)


"/w+?" 将尽可能少的匹配第一个 "d" 之后的字符，结果是："/w+?" 只匹配了一个 "x"




(d)(/w+?)(d)


为了让整个表达式匹配成功，"/w+?" 不得不匹配 "xxx" 才可以让后边的 "d" 匹配，从而使整个表达式匹配成功。因此，结果是："/w+?" 匹配 "xxx"


    更多的情况，举例如下：

    举例1：表达式 "<td>(.*)</td>" 与字符串 "<td><p>aa</p></td> <td><p>bb</p></td>" 匹配时，匹配的结果是：成功；匹配到的内容是 "<td><p>aa</p></td> <td><p>bb</p></td>" 整个字符串， 表达式中的 "</td>" 将与字符串中最后一个 "</td>" 匹配。

    举例2：相比之下，表达式 "<td>(.*?)</td>" 匹配举例1中同样的字符串时，将只得到 "<td><p>aa</p></td>"， 再次匹配下一个时，可以得到第二个 "<td><p>bb</p></td>"。

========================================================================================================





正则表达式((?=\1\1\1)(\1))+" 啥意思???

表达式 "(\w)((?=\1\1\1)(\1))+" 在匹配字符串 "aaa ffffff 999999999" 时，将可以匹配6个"f"的前4个，可以匹配9个"9"的前7个。这个表达式可以读解成：重复4次以上的字母数字，则匹配其剩下最后2位之前的部分。当然，这个表达式可以不这样写，在此的目的是作为演示之用。
怎么得出的这个结果???求详细过程啊,一步步的....((?=\1\1\1)(\1))+ 不理解括号里面的字符?


-----------------------------------------------------------------------------------------------------------------------------------------------


这么刁钻的东西，在哪找来的？挺考人，伤神的。曾经在正则投入不少时间，但"(\w)((?=\1\1\1)(\1))+"  仍花了大半天才弄明白。复杂的东西，都应逐步拆解。请看下面分解，不感兴趣部分自行跳过：
一、
1. (\w) -- \w,一个字符，括号表示一个子匹配,第一个括号是"\1"，第二个括号是"\2"，……。
2. (\w)(\1) -- 一个字符，后面紧跟一个相同的字符。
（之前复杂的正则，转为基本的(\w)(\1)。化繁为简，先弄清楚简单的，再向复杂推去。）


01.import java.util.regex.Matcher;

02.import java.util.regex.Pattern;

03.public class Test {

04.        public static void main(String[] args) throws Exception

05.        {

06.                // Pattern pattern = Pattern.compile("(\\w)((?=\\1\\1\\1)(\\1))+");

07.                Pattern pattern = Pattern.compile("(\\w)(\\1)");

08.                Matcher matcher = pattern.matcher("aaa ffffff 999999999");

09.                // Matcher matcher = pattern.matcher("aaa 999999");

10.                while (matcher.find()) {

11.                        System.out.print(matcher.group()+" | ");

12.                }

13.   }

14.}
复制代码运行得：aa | ff | ff | ff | 99 | 99 | 99 | 99 | ，3个a,匹配了一次；6个f,匹配了三次；9个9,匹配了四次。
可见，(\w)(\1) -- 每次搜索两个字符，该字符与下一个相同即为true。
二、
1. (?=\\1) -- ?=，据“正则表达式系统教程"：

(?=pattern)  正向预查，在任何匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如，'Windows (?=95|98|NT|2000)' 能匹配 "Windows 2000" 中的 "Windows" ，但不能匹配 "Windows 3.1" 中的 "Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。

2. (\\w)(?=\\1\\1\\1) -- 一个字符，后面紧跟三个相同的字符。但后三个字符不获取，也不消耗字符：如匹配“ffffff”，第一次查找，匹配到前四个ffff；第二次查找，从第二个“f”开始（不是从第五个开始，如无“?=”：(\\w)(\\1\\1\\1)，则是从第五个开始），匹配了第二个“f”至第五个“f”；第三次查找，匹配了第三个“f”至第六个“f”；第四次查找，只剩下三个“f”，匹配不到。

01.Pattern pattern = Pattern.compile("(\\w)(?=\\1\\1\\1)");
复制代码（其它代码见上，只改正则）
运行得：f | f | f | 9 | 9 | 9 | 9 | 9 | 9 | ，四个字符连续相同才符合条件，但每次查找只消耗一个字符，即 index只+1，不是+4。

三、

01.Pattern pattern = Pattern.compile("(\\w)(?=\\1\\1\\1)(\\1)");
复制代码运行得：ff | ff | 99 | 99 | 99 |
(\\w)(?=\\1\\1\\1)(\\1) --- 相当于执行一次(\\w)(?=\\1\\1\\1)匹配，接着执行一次(\\w)(\\1) ，移到下一个索引，再继续前面的操作，如此循环。
　　(\\w)(?=\\1\\1\\1)，参考“二、”，接着执行 (\\w)(\\1)，(\\w)已完成，到(\\1) 了，它从第二个“f”开始，查找前面的字符相同否，同，匹配。第二次查找，从第三个“f”开始，也是只消耗两个 “f" 字符。第三次查找，只剩下两个“f”，(\\w)(?=\\1\\1\\1)匹配不到。9个9的查找类同，三次查找后，余 9-2*3=3 个“9”，”，(\\w)(?=\\1\\1\\1)需4个“9”才合，查找结束。假如10个“9”的话，第四次能匹配成功，出现四个“99”。

四、

01.Pattern pattern = Pattern.compile("(\\w)(?=\\1\\1\\1)(\\1)+");
复制代码运行得：ffffff | 999999999 |
1. (\\1)+ --- +代表一个或多个，(\\1)+ 表示第一个的子匹配一个或多个。
2. (\\w)(?=\\1\\1\\1)(\\1)+ --- 相当于先 (\\w)(?=\\1\\1\\1)，再 (\\w)(\\1)+ ，接着下一索引继续。
　　(\\w)(?=\\1\\1\\1)，参考上面，接着执行 (\\1)+，从第二个“f”开始，它会将余下的“f” 全部匹配掉，“ffffff”的查找就结束了（接下来的是第二轮查找，对 9个“9”）。

五、

01.Pattern pattern = Pattern.compile("(\\w)((?=\\1\\1\\1)(\\1))+");
复制代码运行得：ffff | 9999999 |
1. ((?=\\1\\1\\1)(\\1))+  --- 是整个“(?=\\1\\1\\1)(\\1)”的一个或多个。先(?=\\1\\1\\1)，查找三个与第一个子匹配相合的；再(\\1) ，查找一个与第一个子匹配相合的；然后因有“+”，匹配多次。

2. (\\w)((?=\\1\\1\\1)(\\1))+  --- 以“ffffff” 6个“f” 为例：①执行(\\w)：找到一字符“f”，符合， ②执行(?=\\1\\1\\1)：从第二个“f”开始，查找三个“f”，符合， ③执行(\\1)：因前面不消耗字符，从第二个“f”开始，查找一个“f”，符合，④整个“(?=\\1\\1\\1)(\\1)”是 + 的，要匹配多次，相当于内循环，“(?=\\1\\1\\1)(\\1)”不断匹配下去，现从第三个“f”开始，查找三个“f”，符合，⑤现又到(\\1)，从第三个“f”开始，查找一个“f”，符合，⑥…………，最后到剩下2个“f”时，(?=\\1\\1\\1) 不合，结束此轮查找。这样，(\\w)只执行一次，匹配最前面的“f”，“(?=\\1\\1\\1)(\\1)”不断匹配，执行三次，匹配了第二至第四个“f”，总共匹配了前面的四个“f”。

3. 至此，对照LZ所提“将可以匹配6个"f"的前4个，可以匹配9个"9"的前7个”，是吻合的。