以下内容转自: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/n1:"+re1[0]+"/r/n2:"+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/n1:"+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个”,是吻合的。
相关推荐
JavaScript 正则表达式迷你书 本书是 JavaScript 正则表达式的入门级教程,旨在帮助读者快速掌握正则表达式的基本概念和应用。下面是本书的知识点摘要: 第一章:正则表达式字符匹配攻略 * 两种模糊匹配:横向...
本书从字符匹配、位置匹配、括号的作用、回溯法原理、拆分、构建和编程等方面深入讲解了JavaScript正则表达式的相关知识,适合需要进行字符串匹配、提取、验证等操作的读者学习。 第1章介绍了正则表达式字符匹配的...
JavaScript 正则表达式详解 JavaScript 中的正则表达式是指使用特殊字符来描述字符串模式的表达式。正则表达式可以用来匹配、检索和操作字符串。 RegExp 对象 在 JavaScript 中,正则表达式可以被定义为一个 ...
JavaScript正则表达式是JavaScript语言中一种极为重要的文本处理工具,它允许通过简洁的语法定义文本的匹配模式。这些模式可用来对字符串进行检索、替换、提取等操作。了解和掌握JavaScript正则表达式,对于提高...
**JavaScript正则表达式迷你书(1.1版)** 正则表达式是JavaScript中一个强大的工具,用于处理文本字符串,进行模式匹配和查找、替换等操作。它们在编程逻辑中扮演着至关重要的角色,尤其是在处理字符串数据时,...
当与`<div>`或`<style>`标签的开始和结束相对应时,这些正则表达式将匹配整个标签及其内部内容。 需要注意的是,这种方法是不完美的,特别是当标签内含有其他标签时,容易出现匹配错误。比如,如果`<div>`标签中...
正则表达式(Regular Expression,简称regex)是用于在文本中匹配特定模式的强大工具,广泛应用于数据验证、搜索替换和文本处理等领域。正则表达式调试工具是开发人员用来测试和优化这些模式的重要辅助工具。本文将...
JavaScript正则表达式是编程语言JavaScript中的一个重要组成部分,它用于处理文本字符串,进行模式匹配、查找、替换等操作。在JavaScript中,正则表达式是一种强大的工具,可以帮助开发者实现复杂的数据验证、文本...
本资源“源码(精通正则表达式&实战正则表达式)”专注于JavaScript环境下的正则表达式学习,通过一系列视频教程和配套源码,帮助开发者提升对正则表达式的理解和应用能力。 首先,"精通正则表达式五部视频"可能涵盖...
6. **重复与贪婪与非贪婪**: - `*?`、`+?`、`??`、`{n,}?`、`{n,m}?`:这些是懒惰量词,只匹配尽可能少的字符,与贪婪量词 (`*`、`+`、`?`、`{n,}`、`{n,m}`) 相反。 7. **零宽断言**: - `(?=pattern)`:正向...
在编程领域,正则表达式(Regular Expression)是一种强大的文本处理工具,用于匹配、查找、替换、分割等操作。在本教程中,我们将深入探讨如何使用正则表达式来拆分字符串,这对于数据处理和文本分析尤其有用。下面...
11. **优化技巧**:正则表达式可能会带来性能问题,因此在编写复杂的模式时,应考虑使用非贪婪匹配(`*?`、`+?`、`??`),避免回溯,以及使用预编译模式提高效率。 12. **调试与测试**:使用在线工具(如Regex101、...
JavaScript中的正则表达式是一种强大的文本处理工具,用于匹配、查找、替换和验证字符串。它们在编程中扮演着至关重要的角色,特别是在数据验证、搜索和提取信息等方面。在这个"JavaScript常用正则表达式"的资源中,...
### JavaScript正则表达式语法详解 #### 一、引言 正则表达式是一种强大的文本处理工具,可以用来实现字符串的查找、替换等操作。在JavaScript中,正则表达式的应用非常广泛,从简单的字符串匹配到复杂的文本解析,...
在编程语言中,几乎所有现代语言都支持正则表达式的使用,例如 Java、Python、JavaScript 等。此外,在日常工作中使用的工具如 grep、sed 和 awk 等也支持正则表达式的操作。 #### 三、基本概念介绍 1. **元字符**...
正则表达式引擎的内部工作机制包括两种常见的搜索模式:贪婪匹配和惰性(非贪婪)匹配。默认情况下,大多数引擎采取贪婪匹配模式,尽可能多地匹配文本。相对地,惰性匹配则是在满足条件的前提下尽可能少地匹配。例如...
例如,JavaScript的正则表达式支持一些特有的功能,如预查`(?=...)`和否定预查`(?!=...)`,而Python的re模块则提供了更多的高级特性,如非贪婪量词和条件表达式。 学习和使用正则表达式: 掌握正则表达式需要时间和...