在正則表達式中，'懶'和'貪'是什麼意思？

394

貪婪會盡可能消耗。從http://www.regular-expressions.info/repeat.html我們看到了試圖將HTML標籤與<.+>匹配的示例。假設你有以下幾點：

<em>Hello World</em>

你可能會認爲<.+>（.手段任何非換行符和+意味着一個或多個）將只匹配<em>和</em>，在現實中，它會非常貪心，並從第一個<到最後的>。這意味着它將匹配<em>Hello World</em>而不是你想要的。

讓它變懶（<.+?>）會阻止這種情況發生。通過在+之後加上?，我們告訴它重複儘可能少的次數，所以它遇到的第一個>是我們想要停止匹配的地方。

我建議您下載，這個工具可以幫助您探索正則表達式 - 我一直都在使用它。

來源

2010-02-20 06:22:32 Sampson

+1

所以如果你使用貪婪你將有3（1元素+2標籤）匹配或只是1匹配（1元素）？ – ajsie 2010-02-20 06:27:12

+8

它只會匹配1次，從第一個** <**開始，到最後一個**> **結束。 – Sampson 2010-02-20 06:28:15

+2

但讓它懶惰會匹配兩次，給我們打開和關閉標記，忽略之間的文本（因爲它不適合表達式）。 – Sampson 2010-02-20 06:29:13

41

貪婪意味着你的表情將盡可能地匹配一個羣體，懶惰意味着它會匹配儘可能最小的羣體。對於這個字符串：

abcdefghijklmc

這個表述：

a.*c

貪婪的比賽將整個字符串匹配，和一個懶惰的比賽將只匹配第一個abc。

來源

2010-02-20 06:19:18

+0

+1 http://www.regular-expressions.info/repeat.html – Sampson 2010-02-20 06:19:46

182

「Greedy」表示匹配時間最長的字符串。

'懶'表示匹配最短的字符串。

例如，貪婪h.+l比賽'hell'在'hello'但懶惰h.+?l匹配'hel'。

來源

2010-02-20 06:19:41 slebetman

+44

輝煌，只要條件l滿足，懶惰就會停止，但貪婪意味着只有當條件l不再滿足時纔會停止。 – 2014-02-23 21:27:00

+0

對於所有閱讀帖子的人來說：貪婪或懶惰的量詞本身並不匹配最長/最短的子字符串。您將不得不使用[**脾氣貪婪令牌**]（http://www.rexegg.com/regex-quantifiers.html#tempered_greed），或使用非正則表達式方法。 – 2016-10-15 21:29:59

+0

@AndrewS不要被示例中的double ll混淆。這是相當懶惰將匹配儘可能短的子字符串，而貪婪將匹配最長的可能。貪婪的'h。+ l'與'helolo''中的'helol'匹配，但懶惰的'h。+？l'匹配''hel''。 – 2017-03-21 16:38:58

4

從Regular expression

標準量詞正規表達式是貪婪的，這意味着他們比賽一樣多，因爲他們可以，只是回饋必要匹配其餘的正則表達式。

通過使用惰性量詞，表達式首先嚐試最小匹配。

來源

2010-02-20 06:21:22

7

取自www.regular-expressions.info

貪婪：貪婪量詞首先嚐試重複令牌多次成爲可能，並逐漸發動機回溯找到整體匹配放棄比賽。

懶惰：懶惰量詞第一重複令牌幾次要求，並作爲推理機通過正則表達式找到一個總體匹配逐漸擴大了比賽。

來源

2014-10-19 08:34:34

40

+-------------------+-----------------+------------------------------+ 
| Greedy quantifier | Lazy quantifier |  Description   | 
+-------------------+-----------------+------------------------------+ 
| *     | *?    | Star Quantifier: 0 or more | 
| +     | +?    | Plus Quantifier: 1 or more | 
| ?     | ??    | Optional Quantifier: 0 or 1 | 
| {n}    | {n}?   | Quantifier: exactly n  | 
| {n,}    | {n,}?   | Quantifier: n or more  | 
| {n,m}    | {n,m}?   | Quantifier: between n and m | 
+-------------------+-----------------+------------------------------+

添加？到量詞使其不明朗，即懶惰。

實施例：
測試字符串：計算器
貪婪reg表達式：s.*o輸出：stackoverflo瓦特
懶惰reg表達式：s.*?o輸出：stacko verflow

來源

2016-01-15 07:26:36 Premraj

+1

是不是？相當於？。同樣，不是{n}？等同於{n} – 2016-09-02 08:07:04

+1

@BreakingBenjamin：否？不等於？，當它有選擇返回0或1次出現時，它會選擇0（懶惰）選擇。要查看它們之間的區別，請將're.match（'（f）？（。*）'，'food'）。groups（）'與're.match（'（f）??（。*）'，''食品「）。組（）'。在後者中，即使可能，'（f）'也不會匹配前導'f'。因此'f'會被第二個'。'捕獲組匹配。我相信你可以用'{n}'構造一個例子嗎？'太。無可否認，這兩者很少被使用。 – smci 2017-11-16 00:42:24

-2

試着去了解以下行爲：

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); // ""

來源

2016-10-30 06:31:14 FrankyHollywood

6

據我所知，大多數正則表達式引擎是默認的貪婪。在量詞末尾添加問號將啓用惰性匹配。

As @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"); 
     } 
    } 
}

結果是：

我greeedy，我想億美元。這是我能得到的最多。

我懶得拿到這麼多錢，只有100塊錢就夠了，我

來源

2016-11-09 16:39:06 Gearon

+1

我真的很喜歡你的榜樣。 – Xatenev 2017-03-13 11:46:22

0

貪婪匹配。正則表達式的默認行爲是貪婪的。這意味着儘可能多地提取它，直到它符合模式，即使小部分在語法上足夠的時候也是如此。

實施例：

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 Regex Examples

來源

2018-01-21 05:35:59 Selva

0

貪婪意味着直到有沒有人離開它會消耗你的模式，它可以不要再觀望。

只要遇到您請求的第一個模式，懶惰就會停止。

一個常見的例子，我經常遇到的是一個正則表達式([0-9]{2}\s*-\s*?[0-9]{7})

第一\s*被列爲貪婪，因爲*並尋找儘可能多的空格儘可能遇到數字後，然後尋找一個的\s*-\s*?短劃線字符「 - 」。第二個\s*?由於*?的存在而變得很懶，這意味着它將看起來是第一個空白字符並在那裏停下來。

來源

2018-02-06 15:41:32 stackFan

在正則表達式中，'懶'和'貪'是什麼意思？

回答

相關問題