{"id":1927,"date":"2023-06-01T15:11:28","date_gmt":"2023-06-01T08:11:28","guid":{"rendered":"https:\/\/csharptutorial.net\/csharp-regular-expression\/greedy-quantifiers\/"},"modified":"2023-06-01T15:49:15","modified_gmt":"2023-06-01T08:49:15","slug":"greedy-quantifiers","status":"publish","type":"page","link":"https:\/\/www.csharptutorial.net\/csharp-regular-expression\/greedy-quantifiers\/","title":{"rendered":"Greedy Quantifiers"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you will learn how greedy quantifiers work and how to avoid unexpected results by using lazy quantifiers.<\/p>\n\n\n\n

Quantifiers are greedy<\/h2>\n\n\n\n

Quantifiers are metacharacters in regular expressions that specify the quantity of the preceding element. For example, the + quantifier matches one or more occurrences of the preceding element.<\/p>\n\n\n\n

By default, quantifiers are greedy, meaning that the quantifiers always try to match as much of the input text as possible while still allowing the whole pattern to match successfully.<\/p>\n\n\n\n

The reason that quantifiers are called greedy is that they try to consume as many characters in the input string as they can.<\/p>\n\n\n\n

Let’s take an example to understand how greedy quantifiers work.<\/p>\n\n\n\n

Suppose you have a link tag in an HTML fragment:<\/p>\n\n\n

<a<\/span> href<\/span>=\"https:\/\/csharptutorial.net\/\"<\/span> target<\/span>=\"_blank\"<\/span>><\/span>Click Me<\/a<\/span>><\/span><\/code><\/span>Code language:<\/span> HTML, XML<\/span> (<\/span>xml<\/span>)<\/span><\/small><\/pre>\n\n\n
To get attribute values like \"https:\/\/csharptutorial.net\/\"<\/code> and \"_blank\"<\/code>, you may come up with the following pattern:<\/p>\n\n\n
\".+\"<\/code><\/span>Code language:<\/span> plaintext<\/span> (<\/span>plaintext<\/span>)<\/span><\/small><\/pre>\n\n\n
This pattern matches a text that starts with quotes (\"<\/code>) followed by one or more characters (.) and ends with quotes (\"<\/code>).<\/p>\n\n\n
using<\/span> System.Text.RegularExpressions;\r\nusing<\/span> static<\/span> System.Console;\r\n\r\n\r\nvar<\/span> html = \"\"<\/span>\"<a href=\"<\/span>https:\/\/csharptutorial.net\/\" target=\"blank\">C# Tutorial<\/a>\"\"\";<\/span>\r\n\r\nvar<\/span> pattern = \"\"<\/span>\" \r\n              \"<\/span>.+\"\r\n              \"<\/span>\"\"<\/span>;\r\n\r\nvar<\/span> matches = Regex.Matches(html, pattern);\r\nforeach<\/span> (var<\/span> match in<\/span> matches)\n{\n    WriteLine(match);\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Note that we use a raw string<\/a> for an HTML string and a regular expression pattern, which contain the quotes (“). The raw string has been available since C# 11.<\/p>\n\n\n\n
Output:<\/p>\n\n\n
\"https:\/\/csharptutorial.net\/\" target=\"blank\"<\/code><\/span>Code language:<\/span> plaintext<\/span> (<\/span>plaintext<\/span>)<\/span><\/small><\/pre>\n\n\n
The result is not what we expected.<\/p>\n\n\n\n
The following describes how the greedy quantifier works in this example:<\/p>\n\n\n\n
    \n
  1. The regex pattern \".+\"<\/code> is applied to the input string.<\/li>\n\n\n\n
  2. The first character of the input string is <<\/code>, and the .<\/code> in the pattern matches any character. Therefore, the regex engine matches the opening <<\/code> character.<\/li>\n\n\n\n
  3. The greedy quantifier +<\/code> allows one or more occurrences, so the regex engine attempts to match as many characters as possible.<\/li>\n\n\n\n
  4. The engine continues matching all subsequent characters until it reaches the closing ><\/code> character. This includes the match \"https:\/\/csharptutorial.net\/\" target=\"blank\">C# Tutorial<\/a><\/code>.<\/li>\n\n\n\n
  5. Once the engine reaches the closing ><\/code> character, it realizes that the pattern still needs to match the remaining part of the input string.<\/li>\n\n\n\n
  6. At this point, the engine triggers backtracking<\/strong>. It backtracks from the last matched position, which is the closing ><\/code>, and starts considering shorter matches.<\/li>\n\n\n\n
  7. The engine removes the last character ><\/code> from the match and attempts to match again. However, it still doesn’t find a complete match.<\/li>\n\n\n\n
  8. The backtracking process continues, and the engine removes subsequent characters one by one until it finds a valid match.<\/li>\n\n\n\n
  9. Finally, the engine reaches a valid match with the last ” and returns the longest possible match: href=\"https:\/\/csharptutorial.net\/\" target=\"blank\"<\/code>.<\/li>\n<\/ol>\n\n\n\n
    Turn off the greedy mode<\/h2>\n\n\n\n
    To fix this issue, you need to explicitly force the quantifier (+) to use the non-greedy (lazy) mode instead by adding the question mark (?) after the + quantifier like this:<\/p>\n\n\n
    \".+?\"<\/span><\/code><\/span>Code language:<\/span> JSON \/ JSON with Comments<\/span> (<\/span>json<\/span>)<\/span><\/small><\/pre>\n\n\n
    For example:<\/p>\n\n\n
    using<\/span> System.Text.RegularExpressions;\r\nusing<\/span> static<\/span> System.Console;\r\n\r\n\r\nvar<\/span> html = \"\"<\/span>\"<a href=\"<\/span>https:\/\/csharptutorial.net\/\" target=\"blank\">Click Me<\/a>\"\"\";<\/span>\r\n\r\nvar<\/span> pattern = \"\"<\/span>\" \r\n              \"<\/span>.+?\"\r\n              \"<\/span>\"\"<\/span>;\r\n\r\nvar<\/span> matches = Regex.Matches(html, pattern);\r\nforeach<\/span> (var<\/span> match in<\/span> matches)\n{\n    WriteLine(match);\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    Output:<\/p>\n\n\n
    \"https:\/\/csharptutorial.net\/\"\r\n\"blank\"<\/code><\/span>Code language:<\/span> plaintext<\/span> (<\/span>plaintext<\/span>)<\/span><\/small><\/pre>\n\n\n
    Now, the program returns the expected result.<\/p>\n\n\n\n
    Summary<\/h2>\n\n\n\n
      \n
    • Quantifiers are greedy by default.<\/li>\n\n\n\n
    • A greedy quantifier matches as much of the input string as possible while still allowing the overall regular expression pattern to match successfully.<\/li>\n<\/ul>\n
      \n\t
      \n\t\t
      Was this tutorial helpful ?<\/div>\n\t\t
      \n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t Yes <\/span>\n\t\t\t<\/button>\n\n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t No <\/span>\n\t\t\t<\/button>\n\t\t<\/div>\n\t<\/header>\n\n\t
      \n\t\t
      \n\t\t\t
      <\/div>\n\t\t\t\n\t\t\t