{"id":1939,"date":"2023-06-01T16:11:16","date_gmt":"2023-06-01T09:11:16","guid":{"rendered":"https:\/\/csharptutorial.net\/?page_id=1939"},"modified":"2023-06-01T16:12:32","modified_gmt":"2023-06-01T09:12:32","slug":"lazy-quantifiers","status":"publish","type":"page","link":"https:\/\/www.csharptutorial.net\/csharp-regular-expression\/lazy-quantifiers\/","title":{"rendered":"Lazy Quantifiers"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you will learn about the lazy quantifiers to find the smallest match in an input string.<\/p>\n\n\n\n

Introduction to lazy quantifiers<\/h2>\n\n\n\n

Lazy quantifiers, also known as non-greedy quantifiers, are a feature in regular expressions that modify the behavior of quantifiers<\/a> to match as little as possible. They provide the smallest possible match that satisfies the regular expression pattern.<\/p>\n\n\n\n

By default, quantifiers in regular expressions are greedy<\/a>, meaning they match as much as possible. However, lazy quantifiers work in the opposite way. They match as little as possible while still allowing the overall pattern to be satisfied.<\/p>\n\n\n\n

Lazy quantifiers are denoted by appending a question mark (?<\/code>) to the standard quantifiers.<\/p>\n\n\n\n

The following table shows the greedy quantifiers, lazy quantifiers, and the meanings of the lazy quantifiers:<\/p>\n\n\n\n

Greedy Quantifiers<\/th>Lazy Quantifiers<\/th>Lazy Quantifier Meaning<\/th><\/tr><\/thead>
*<\/td>*?<\/td>Match zero or more occurrences (as few as possible)<\/td><\/tr>
+<\/td>+?<\/td>Match one or more occurrences (as few as possible)<\/td><\/tr>
?<\/td>??<\/td>Match zero or one occurrence (preferably zero)<\/td><\/tr>
{n}<\/td>{n}?<\/td>Match exactly n occurrences<\/td><\/tr>
{n,}<\/td>{n,}?<\/td>Match n or more occurrences<\/td><\/tr>
{n,m}<\/td>{n,m}?<\/td>Match between n and m occurrences (as few as possible)<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n

Lazy quantifiers example<\/h2>\n\n\n\n

The following example illustrates how to use a lazy quantifier to extract attribute values of an input tag:<\/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>\"<input type=\"<\/span>submit\" values=\"<\/span>Send\">\"<\/span>\"\"<\/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
\"submit\"<\/span>\r\n\"Send\"<\/span><\/code><\/span>Code language:<\/span> JSON \/ JSON with Comments<\/span> (<\/span>json<\/span>)<\/span><\/small><\/pre>\n\n\n
How it works.<\/p>\n\n\n\n
    \n
  1. The program begins with the necessary using<\/code> directive to include the Regex<\/code> class from the System.Text.RegularExpressions<\/code> namespace.<\/li>\n\n\n\n
  2. The program then includes using static System.Console;<\/code> to allow the usage of the WriteLine<\/code> method without explicitly specifying the Console<\/code> class.<\/li>\n\n\n\n
  3. The HTML string is defined as html<\/code> using a raw string (\"\"\"<\/code>)  that contains an HTML input element with the attribute type=\"submit\"<\/code> and values=\"Send\"<\/code>.<\/li>\n\n\n\n
  4. The regular expression pattern is defined as pattern<\/code> using a raw string with triple quotes (\"\"\"<\/code>) to avoid escaping the ” inside the regular expression. The pattern \".+?\"<\/code> matches the attributes of the input HTML tag including quotes (“). The lazy quantifier ?<\/code> ensures that the match is as small as possible.<\/li>\n\n\n\n
  5. The program uses the Regex.Matches()<\/code> method to find all matches of the pattern in the HTML string html<\/code>. It takes the html<\/code> string and the pattern<\/code> as arguments and returns a collection of Match<\/code> objects representing the matches found.<\/li>\n\n\n\n
  6. The program then iterates over each Match<\/code> object in the matches<\/code> collection using a foreach<\/code> loop and use the WriteLine<\/code> method to print each match to the console inside the loop.<\/li>\n<\/ol>\n\n\n\n
    Summary<\/h2>\n\n\n\n
      \n
    • A lazy quantifier in regular expressions matches as little as possible while still satisfying the pattern.<\/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