在正则表达式的上下文中，“懒惰”和“贪婪”是什么意思？

Question

这两个术语是什么意思？

Answer 1

贪婪会尽可能多地消耗。 从http://www.regular-expressions.info/repeat.html我们看到了尝试将 HTML 标记与<.+>匹配的示例。 假设您有以下内容：

<em>Hello World</em>

您可能认为<.+> （ .表示任何非换行符， +表示一个或多个）只会匹配<em>和</em> ，而实际上它会非常贪婪，并且从第一个开始<到最后> 。 这意味着它将匹配<em>Hello World</em>而不是你想要的。

让它变得懒惰（ <.+?> ）将防止这种情况。 通过添加? 在+ ，我们告诉它重复尽可能少的次数，所以遇到的第一个>就是我们想要停止匹配的地方。

我鼓励您下载RegExr ，这是一个很棒的工具，可以帮助您探索正则表达式 - 我一直在使用它。

Answer 2

'Greedy'表示匹配最长可能的字符串。

'Lazy'意味着匹配最短的字符串。

例如，贪婪的h.+l匹配'hell' 'hello'中的'hell' 'hello'而懒惰的h.+?l匹配'hel' 。

Answer 3

贪婪量词	惰性量词	描述
*	*?	星量词：0或更多
+	+?	加量词：1个或更多
?	??	可选量词：0 或 1
{n}	{n}?	量词：正好 n
{n,}	{n,}?	量词：n个或更多
{n,m}	{n,m}?	量词：n和m之间

添加一个？ 到一个量词，使其不贪婪，即懒惰。

例子：
测试字符串： stackoverflow
贪婪的reg表达式： s.*o输出： stackoverflow
惰性正则表达式： s.*?o输出： stacko verflow

Answer 4

贪婪意味着您的表达式将匹配尽可能大的组，懒惰意味着它将匹配尽可能小的组。 对于这个字符串：

abcdefghijklmc

和这个表达：

a.*c

贪婪匹配将匹配整个字符串，而惰性匹配将仅匹配第一个abc 。

Answer 5

据我所知，默认情况下，大多数正则表达式引擎都是贪婪的。 在量词末尾添加问号将启用延迟匹配。

正如@Andre S 在评论中提到的那样。

• 贪心：继续搜索，直到条件不满足为止。
• 懒惰：一旦满足条件就停止搜索。

请参阅下面的示例，了解什么是贪婪和什么是懒惰。

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Test {
    public static void main(String args[]){
        String money = "100000000999";
        String greedyRegex = "100(0*)";
        Pattern pattern = Pattern.compile(greedyRegex);
        Matcher matcher = pattern.matcher(money);
        while(matcher.find()){
            System.out.println("I'm greeedy and I want " + matcher.group() + " dollars. This is the most I can get.");
        }

        String lazyRegex = "100(0*?)";
        pattern = Pattern.compile(lazyRegex);
        matcher = pattern.matcher(money);
        while(matcher.find()){
            System.out.println("I'm too lazy to get so much money, only " + matcher.group() + " dollars is enough for me");
        }
    }
}

---

结果是：

 I'm greeedy and I want 100000000 dollars. This is the most I can get. I'm too lazy to get so much money, only 100 dollars is enough for me

Answer 6

取自www.regular-expressions.info

贪婪：贪婪量词首先尝试尽可能多地重复标记，然后随着引擎回溯以找到整体匹配逐渐放弃匹配。

懒惰：懒惰量词首先根据需要多次重复标记，然后随着引擎通过正则表达式回溯以找到整体匹配逐渐扩展匹配。

Answer 7

从正则表达式

正则表达式中的标准量词是贪婪的，这意味着它们尽可能多地匹配，只在必要时返回以匹配正则表达式的其余部分。

通过使用惰性量词，表达式首先尝试最小匹配。

Answer 8

贪心匹配。 正则表达式的默认行为是贪婪的。 这意味着它会尝试尽可能多地提取，直到它符合模式，即使较小的部分在语法上就足够了。

例子：

import re
text = "<body>Regex Greedy Matching Example </body>"
re.findall('<.*>', text)
#> ['<body>Regex Greedy Matching Example </body>']

它没有匹配到第一次出现 '>'，而是提取了整个字符串。 这是正则表达式的默认贪婪或“全部”行为。

另一方面，惰性匹配“需要尽可能少”。 这可以通过添加? 在模式的末尾。

例子：

re.findall('<.*?>', text)
#> ['<body>', '</body>']

如果您只想检索第一个匹配项，请改用搜索方法。

re.search('<.*?>', text).group()
#> '<body>'

来源： Python 正则表达式示例

Answer 9

贪婪意味着它会消耗你的模式，直到没有它们为止，而且它不能再看下去了。

Lazy 会在遇到您请求的第一个模式时立即停止。

我经常遇到的一个常见例子是\\s*-\\s*? 正则表达式([0-9]{2}\\s*-\\s*?[0-9]{7})

第一个\\s*被归类为贪婪，因为*并且在遇到数字后会查找尽可能多的空格，然后查找破折号字符“-”。 第二个\\s*?在哪里\\s*? 因为*?的存在而懒惰*? 这意味着它将看起来第一个空白字符并在那里停止。

Answer 10

最好通过例子来说明。 细绳。 192.168.1.1和一个贪婪的正则表达式\\b.+\\b你可能认为这会给你第一个八位字节，但实际上是匹配整个字符串。 为什么？ 因为 .+ 是贪婪的，贪婪匹配会匹配192.168.1.1中的每个字符，直到它到达字符串的末尾。 这是重要的一点！ 现在它开始一次回溯一个字符，直到找到第三个标记 ( \\b ) 的匹配项。

如果字符串 4GB 文本文件和 192.168.1.1 位于开头，您可以很容易地看到这种回溯将如何导致问题。

要使正则表达式非贪婪（懒惰），请在贪婪搜索后打上问号，例如

*?
??
+?

现在发生的是标记 2 ( +? ) 找到匹配项，正则表达式沿字符移动，然后尝试下一个标记 ( \\b ) 而不是标记 2 ( +? )。 所以它小心翼翼地爬行。

Answer 11

贪婪量词就像 IRS/ATO

如果它在那里，他们会拿走它。

IRS 与此正则表达式匹配： .*

$50,000

这将匹配一切！

参见此处的示例： Greedy-example

非贪婪量词 - 他们尽可能少

如果我要求退税，国税局突然变得不贪婪，他们使用这个量词：

(.{2,5}?)([0-9]*)针对此输入： $50,000

第一组是不需要的，只匹配$5 ——所以我得到了$5退款。 他们不贪心。 他们尽可能少拿。

请参阅此处：非贪婪示例。

何苦？

如果您尝试匹配表达式的某些部分，这将变得很重要。 有时您不想匹配所有内容。

希望这个比喻能帮助你记住！

Answer 12

如果有人到达这里寻找解析时更快的方法：

关于正则表达式性能的一个常见误解是，懒惰的量词（也称为非贪婪，不情愿，最小或不贪婪）比其贪婪等效词更快。 通常这不是真的，但是有一个重要的限定词：在实践中，懒惰的限定词通常会更快。

摘自公然的Badassery

Answer 13

为了进一步澄清懒惰，这里有一个例子，乍一看可能并不直观，但解释了 Suganthan Madhavan Pillai 回答的“逐渐扩展匹配”的想法。

input -> some.email@domain.com@
regex -> ^.*?@$

此输入的正则表达式将匹配。 乍一看，有人可能会说 LAZY match(".*?@") 将首先停止@，之后它将检查输入字符串是否结束("$")。 按照这个逻辑，有人会得出不匹配的结论，因为输入字符串没有在第一个 @ 之后结束。

但是正如您所看到的，情况并非如此，即使我们使用非贪婪（惰性模式）搜索，正则表达式也会向前 go 搜索，直到它达到第二个 @ 并且有一个 MINIMAL 匹配。

Answer 14

尝试理解以下行为：

    var input = "0014.2";

Regex r1 = new Regex("\\d+.{0,1}\\d+");
Regex r2 = new Regex("\\d*.{0,1}\\d*");

Console.WriteLine(r1.Match(input).Value); // "0014.2"
Console.WriteLine(r2.Match(input).Value); // "0014.2"

input = " 0014.2";

Console.WriteLine(r1.Match(input).Value); // "0014.2"
Console.WriteLine(r2.Match(input).Value); // " 0014"

input = "  0014.2";

Console.WriteLine(r1.Match(input).Value); // "0014.2"
Console.WriteLine(r2.Match(input).Value); // ""