贪婪与不愿意与拥有量词
我发现了这个关于正则expression式的优秀教程 ，虽然我直观地理解了“贪婪”，“不情愿”和“占有”量词的含义，但我的理解似乎存在一个严重的漏洞。
具体来说，在下面的例子中：
Enter your regex: .*foo // greedy quantifier Enter input string to search: xfooxxxxxxfoo I found the text "xfooxxxxxxfoo" starting at index 0 and ending at index 13. Enter your regex: .*?foo // reluctant quantifier Enter input string to search: xfooxxxxxxfoo I found the text "xfoo" starting at index 0 and ending at index 4. I found the text "xxxxxxfoo" starting at index 4 and ending at index 13. Enter your regex: .*+foo // possessive quantifier Enter input string to search: xfooxxxxxxfoo No match found. 这个解释提到吃了整个inputstring，字母被消耗 ，匹配器退后，“foo”的最右边的事件已经被反刍 ，等等。
不幸的是，尽pipe有很好的比喻，我仍然不明白被谁吃了什么…你知道另一个教程（简洁地） 解释正则expression式引擎是如何工作的吗？
或者，如果有人能够在下面的段落中有所不同的解释，那将会非常感激：
第一个例子使用贪婪的量词。*find“任何东西”，零次或多次，后面跟着字母“f”“o”“o”。 由于量词是贪婪的，expression式的。*部分首先吃整个inputstring。 在这一点上，整体expression不能成功，因为最后三个字母（“f”“o”“o”）已经被消耗（ 由谁？ ）。 所以匹配器每次慢慢退出（ 从右到左 ）一个字母，直到“foo”的最右边的事件被反刍（ 这是什么意思？ ），此时匹配成功并且search结束。
然而，第二个例子是不愿意的，所以它首先消耗（ 由谁？ ）“无”。 因为“foo”没有出现在string的开头，所以它被迫吞下（ 谁吞下？）第一个字母（一个“x”），在0和4处触发第一个匹配。我们的testing工具继续这个过程直到inputstring耗尽。 在4日和13日发现另一场比赛。
第三个例子没有find匹配，因为量词是占有的。 在这种情况下，整个inputstring被。* +消耗，（ 怎么样？ ）在expression式的末尾没有留下任何东西来满足“foo”。 如果你想抓住所有的东西而没有退缩，那么使用占有量词来表示 （ 后面的意思是什么？ 在没有立即find匹配的情况下，它将胜过相当的贪婪量词。
我会给它一个镜头。
一个贪婪的量词首先尽可能匹配。 所以.*匹配整个string。 然后匹配器试图匹配下面的f ，但是没有剩下的字符。 所以它“回溯”，使贪婪的量词匹配一件事（把string末尾的“o”留下来）。 这仍然不匹配正则expression式中的f ，所以它“回溯”了一步，使得贪婪的量词再次匹配一个更less的东西（留下string末尾的“oo”不匹配）。 这仍然不匹配正则expression式中的f ，所以它回溯了一个步骤（在string末尾留下“foo”不匹配）。 现在，匹配器最终匹配正则expression式中的f ， o和o也匹配。 成功！
一个不情愿的或“非贪婪的”量词首先尽可能less地匹配。 所以.*不会匹配任何内容，而是让整个string不匹配。 然后匹配器试图匹配下面的f ，但是string的不匹配部分以“x”开始，所以不起作用。 所以匹配器回溯，使非贪婪量词匹配一件事（现在匹配“x”，留下“fooxxxxxxfoo”无可匹敌）。 然后它会尝试匹配成功的f和正则expression式匹配中的o和o 。 成功！
在你的例子中，然后按照相同的过程，用剩下的不匹配的string部分开始处理。
占有量词与贪婪量词一样，但不会回溯。 所以它开始与.*匹配整个string，没有什么不匹配的。 那么在正则expression式中就没有什么可以和f匹配的了。 由于所有格量词不回溯，所以匹配在那里失败。
我还没有听说过“反胃”或“退避”的确切术语; 那么将取代这些词组就是“回溯”，但是“反刍”似乎就像“回溯之前暂时被接受的内容再次抛弃”一样。
对于大多数正则expression式引擎来说，重要的是它们是回溯 ：他们将暂时接受一个潜在的，部分匹配，同时试图匹配正则expression式的全部内容。 如果正则expression式在第一次尝试时不能完全匹配，则正则expression式引擎将在其中一个匹配上回溯 。 它会尝试匹配* ， + ? ，交替或{n,m}重复不同，然后重试。 （是的，这个过程可能需要很长时间。）
第一个例子使用贪婪的量词。*find“任何东西”，零次或多次，后面跟着字母“f”“o”“o”。 由于量词是贪婪的，expression式的。*部分首先吃整个inputstring。 在这一点上，整体expression不能成功，因为最后三个字母（“f”“o”“o”）已经被消耗（ 由谁？ ）。
最后三个字母f ， o和o已经被规则的最初部分消耗掉了。 但是，正则expression式f的下一个元素在inputstring中没有任何内容。 引擎将被迫回溯到最初的匹配，并尝试匹配除了最后一个字符以外的所有字符。 （这可能是聪明的 ，回到最后三个，因为它有三个字面的术语，但我不知道这个级别的实现细节。）
所以匹配器每次慢慢退出（ 从右到左 ）一个字母，直到“foo”的最右边的事件被反刍（ 这是什么意思？ ）
这意味着foo在匹配时暂时包含了。 由于该尝试失败，正则expression式引擎尝试在.*接受less一个字符。 如果在这个例子中.* 之前有一个成功的匹配，那么引擎可能会尝试缩短匹配（从右到左，正如你所指出的，因为它是一个贪婪的限定词），如果它无法匹配整个input，那么在我假设的例子中，可能会被迫重新评估它在匹配之前的匹配。
指向匹配成功，search结束。
然而，第二个例子是不情愿的，所以它首先消耗（ 由谁？ ）“无”。 因为“富”
最初的什么都没有被消耗掉.?* ，这会消耗尽可能最less的任何东西，使正则expression式的其余部分能够匹配。
没有出现在string的开头，它被迫吞下（ 谁吞下？）
在第一个字符后面，第一个字符也是消耗的，在最初的失败之后回溯到匹配整个正则expression式和尽可能短的匹配。 （在这种情况下，正则expression式引擎将从左到右扩展匹配.*?因为.*?是不情愿的。）
第一个字母（“x”），它在0和4处触发第一个匹配。我们的testing工具继续这个过程，直到inputstring被耗尽。 在4日和13日发现另一场比赛。
第三个例子没有find匹配，因为量词是占有的。 在这种情况下，整个inputstring被消耗。* +，（ 如何？ ）
A .*+将尽可能消耗，并且当整个正则expression式无法find匹配时， 将不会回溯到find新的匹配项。 由于所有格forms不执行回溯，所以您可能不会看到.*+许多用法，而是用字符类或类似的限制： account: [[:digit:]]*+ phone: [[:digit:]]*+ 。
这可以大大加快正则匹配，因为你告诉正则expression式引擎，如果input不匹配，它不应该回溯潜在的匹配。 （如果你必须手工编写所有匹配的代码，这将类似于从不使用putc(3)来“推回”一个input字符，这与第一次尝试写入的朴素代码非常相似。除了正则expression式引擎比推回的单个字符更好，他们可以倒回所有的零，然后再试一次。
但是，除了潜在的加速，还可以让你编写正确匹配你所需要的正则expression式。 我遇到了一个简单的例子:)但用占有者和贪婪的量词写一个正则expression式可以给你不同的匹配，而其中一个可能更合适。
在expression式结尾处留下任何东西来满足“foo”。 如果你想抓住所有的东西而没有退缩，那么使用占有量词来表示 （ 后面的意思是什么？ 它会跑赢大盘
在这种情况下，“后退”意味着“回溯” – 抛弃一个暂时的部分匹配来尝试另一个部分匹配，这个匹配可能成功也可能不成功。
在没有立即find匹配的情况下等价的贪婪量词。
这只是我的练习输出，
http://swtch.com/~rsc/regexp/regexp1.html
我不确定这是在互联网上的最好的解释，但它的写得很好，适当详细，我不断回来。 你可能想看看。
如果你想要一个更高级的（不太详细的解释），对于简单的正则expression式，比如你正在看的那个，正则expression式引擎通过回溯工作。 本质上，它select（“吃”）string的一部分，并尝试匹配该部分的正则expression式。 如果它匹配，很好。 如果不是，引擎会改变它对string部分的select，并尝试将正则expression式匹配到该部分，依此类推，直到尝试所有可能的select。
这个过程是recursion使用的：在试图将一个string与一个给定的正则expression式匹配时，引擎将正则expression式分割成几部分，并将algorithm分别应用到每个部分。
贪婪，不情愿和占有量词的区别在引擎做出select要匹配的string的哪一部分的时候，以及如果第一次不工作时如何修改这个select。 规则如下：
-
一个贪婪的量词告诉引擎从整个string开始（或者至less是所有尚未与正则expression式的前面部分匹配的string），并检查它是否与正则expression式匹配。 如果是的话，太好了; 引擎可以继续其余的正则expression式。 如果不是的话，它会再次尝试，但是要修改一个字符（最后一个）离开要检查的string部分。 如果这样做不起作用，则会删除另一个字符等。因此，一个贪婪的量词从最长到最短的顺序检查可能的匹配。
-
一个不情愿的量词告诉发动机从尽可能短的一段弦开始。 如果匹配，引擎可以继续; 如果不是，则会在要检查的string部分添加一个字符，然后尝试该字符，直到find匹配项或整个string已用完。 所以一个不情愿的量词从最短到最长的顺序检查可能的匹配。
-
所有格量词在第一次尝试时就像是一个贪婪量词：它通过检查整个string来告诉引擎开始。 不同之处在于，如果不起作用，那么所有格量词就会报告比赛失败。 引擎不会改变正在查看的string部分，也不会再做任何尝试。
这就是为什么在你的例子中所有格量词匹配失败： .*+被整个string匹配，然后引擎继续寻找额外的字符foo后，但当然没有find他们，因为你已经在string的末尾。 如果它是一个贪婪的量词，它会回溯，并尝试使匹配到倒数第二个字符，然后到倒数第三个字符，然后到倒数第四个字符，这是成功的，因为只有那么在.*已经“吃掉”了string的前面部分之后还有剩下的。
以下是我使用单元格和索引位置（请参阅此处的图表来区分单元格和索引）。
贪婪 – 尽可能匹配贪婪的量词和整个正则expression式。 如果没有匹配的话，回溯贪婪的量词。
inputstring： xfooxxxxxxfoo
正则expression式： 。* foo
上面的正则expression式有两个部分：
（我和
（ⅱ）“富”
下面的每个步骤将分析这两个部分。 对于“通过”或“失败”的匹配的附加注释在花括号中进行解释。
步骤1：
（i）。* = xfooxxxxxxfoo – PASS（'。*'是一个贪婪的量词，将使用整个inputstring）
（ii）foo =在索引13之后没有字符匹配 – 失败
比赛失败。
第2步：
（i）。* = xfooxxxxxxfo – PASS（对贪婪量词'*'的回溯）
（ii）foo = o – 失败
比赛失败。
第3步：
（i）。* = xfooxxxxxxf – PASS（贪婪量词的回溯。*'）
（ii）foo = oo – 失败
比赛失败。
步骤4：
（i）。* = xfooxxxxxx – PASS（贪婪量词的回溯。*'）
（ii）foo = foo – PASS
报告MATCH
结果：1场比赛（es）
我发现文本“xfooxxxxxxfoo”从索引0开始到索引13结束。
不情愿 – 尽可能less地匹配不情愿的量词并匹配整个正则expression式。 如果不匹配，则将字符添加到不情愿的量词。
inputstring： xfooxxxxxxfoo
正则expression式： 。*？foo
上面的正则expression式有两个部分：
（一世） '。*？' 和
（ii）'foo'
步骤1：
。*？ =''（空格） – PASS（尽可能less地与不情愿的量词匹配。“*？'。具有”'的索引0是匹配的。）
foo = xfo – FAIL（Cell 0,1,2 – 即0到3之间的索引）
比赛失败。
第2步：
。*？ = x – PASS（将字符添加到不情愿的量词'*'中。具有'x'的单元0是匹配的。）
foo = foo – PASS
报告MATCH
第3步：
。*？ =''（空白） – PASS（尽可能less地与不情愿的量词匹配“*？'。具有”'的索引4是匹配。
foo = xxx – FAIL（单元格4,5,6 – 即4到7之间的索引）
比赛失败。
步骤4：
。*？ = x – PASS（将字符添加到不情愿的量词'*？'。单元格4.）
foo = xxx – FAIL（单元格5,6,7 – 即5和8之间的索引）
比赛失败。
第5步：
。*？ = xx – PASS（将字符添加到不情愿的量词'。*？'。单元格4到5）
foo = xxx – FAIL（单元格6,7,8 – 即6和9之间的索引）
比赛失败。
第六步：
。*？ = xxx – PASS（将字符添加到不情愿的量词'。*？'。单元格4到6）
foo = xxx – FAIL（Cell 7,8,9 – 即7到10之间的索引）
比赛失败。
第七步：
。*？ = xxxx – PASS（将字符添加到不情愿的量词'。*？'。单元格4到7）
foo = xxf – FAIL（单元格8,9,10 – 即8和11之间的索引）
比赛失败。
第八步：
。*？ = xxxxx – PASS（将字符添加到不情愿的量词'。*？'。单元格4到8）
foo = xfo – FAIL（单元格9,10,11 – 即9和12之间的索引）
比赛失败。
第9步：
。*？ = xxxxxx – PASS（将字符添加到不情愿的量词'。*？'。单元格4到9）
foo = foo – PASS（单元格10,11,12 – 即10和13之间的索引）
报告MATCH
第10步：
。*？ =''（空白） – PASS（尽可能less地与不情愿的量词匹配“*？'。索引13是空白的。）
foo =没有匹配的字符 – 失败（索引13之后没有任何匹配）
比赛失败。
结果：2场比赛（es）
我发现文本“xfoo”从索引0开始到索引4结束。
我发现文本“xxxxxxfoo”从索引4开始到索引13结束。
所有格 – 尽可能匹配所有格量词并匹配整个正则expression式。 不要回溯。
inputstring： xfooxxxxxxfoo
正则expression式： 。* + foo
上面的正则expression式有两个部分：'。* +'和'foo'。
步骤1：
* + = xfooxxxxxxfoo – PASS（尽可能匹配所有格量词“*”）
foo =没有匹配的字符 – 失败（索引13后没有匹配）
比赛失败。
注意：不允许回溯。
结果： 0比赛（es）
贪婪：“匹配最长的字符序列”
不情愿：“匹配尽可能短的字符序列”
所有者：这是有点奇怪，因为它不（贪婪和不情愿的对比）尝试find整个正则expression式匹配。
顺便说一句：没有正则expression式模式匹配器实现将永远使用回溯。 所有现实模式匹配器都非常快 – 几乎与正则expression式的复杂性无关！
贪婪量化涉及在迭代过程中使用string中所有未经validation的字符进行模式匹配。 未经validation的字符在活动序列中开始。 每当匹配没有发生时，最后的字符被隔离 ，再次执行检查。
当仅有主动序列满足正则expression式模式的主要条件时，将试图validation对照隔离的剩余条件。 如果此validation成功，则隔离区中的匹配字符将得到validation，而残留的不匹配字符将保持未validation状态，并将在下一次迭代中重新开始此过程时使用。
字符stream是从活动序列到隔离区的。 由此产生的行为是尽可能多地将原始序列包含在匹配中。
不情愿的量化与贪婪的资格大致相同，除了字符的stream动是相反的 – 也就是说，他们从隔离区开始stream入活动序列 。 由此产生的行为是尽可能less的原始序列包含在匹配中。
拥有量化不具有隔离，并包含固定活动序列中的所有内容 。
