{"id":1911,"date":"2023-06-01T11:02:31","date_gmt":"2023-06-01T04:02:31","guid":{"rendered":"https:\/\/csharptutorial.net\/?page_id=1911"},"modified":"2023-06-01T11:02:33","modified_gmt":"2023-06-01T04:02:33","slug":"regex-quantifiers","status":"publish","type":"page","link":"https:\/\/www.csharptutorial.net\/csharp-regular-expression\/regex-quantifiers\/","title":{"rendered":"Regex Quantifiers"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you will learn about regex quantifiers that specify the quantity of the preceding element in a regular expression pattern.<\/p>\n\n\n\n

Introduction to the Regex Quantifiers<\/h2>\n\n\n\n

The digit character class<\/a> \\d<\/code> matches any digit e.g., 0 to 9. To match two consecutive digits, you need to repeat the digit character class like \\d\\d<\/code>. Similarly, to match a group of four digits, you use four digit character classes \\d\\d\\d\\d<\/code>.<\/p>\n\n\n\n

If you want to match one or more digits, then this solution does not work because you don’t know the number of digits that you want to repeat. That’s why the quantifiers come to the rescue.<\/p>\n\n\n\n

Quantifiers are metacharacters in regular expressions that specify the quantity of the preceding element. They define a specified number of times a particular element should occur in an input string when matching.<\/p>\n\n\n\n

For example, the quantifier + matches the occurrences of the preceding element one or more times. Therefore, the \\d+<\/code> matches one or more digit characters.<\/p>\n\n\n\n

The following table lists all the quantifiers and their meanings:<\/p>\n\n\n\n

Quantifier<\/th>Name<\/th>Meaning<\/th><\/tr><\/thead>
*<\/td>Asterisk<\/td>Match the occurrences of the preceding element zero or more times.<\/td><\/tr>
+<\/td>Plus<\/td>Match the occurrences of the preceding element one or more times.<\/td><\/tr>
?<\/td>Question Mark<\/td>Match the occurrences of the preceding element zero or one time.<\/td><\/tr>
{ n<\/em> }<\/td>Curly Braces<\/td>Match the occurrences of the preceding element exactly n times.<\/td><\/tr>
{ n<\/em> ,}<\/td>Curly Braces<\/td>Match the occurrences of the preceding element at least n times.<\/td><\/tr>
{ n<\/em> , m<\/em> }<\/td>Curly Braces<\/td>Match the occurrences of the preceding element from n to m times.<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n

Regex Quantifier examples<\/h2>\n\n\n\n

Let’s take some examples of using the regex quantifiers.<\/p>\n\n\n\n

1) Matching the occurrences of the preceding element zero or more times (*)<\/h3>\n\n\n\n

The following example uses the quantifier (*<\/code>) to match a text that starts with zero or more characters and ends with the letters “at<\/code>“:<\/p>\n\n\n

using<\/span> System.Text.RegularExpressions;\nusing<\/span> static<\/span> System.Console;\n\n\nvar<\/span> text = \"The cat sat on the mat at the park.\"<\/span>;\nvar<\/span> pattern = @\"\\w*at\"<\/span>;\n\nvar<\/span> matches = Regex.Matches(text, pattern);\n\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
cat\nsat\nmat\nat<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
The following explains the meaning of the regular expression pattern \\w*at<\/code> :<\/p>\n\n\n\n
    \n
  • \\w<\/code> matches any word character.<\/li>\n\n\n\n
  • *<\/code> is a quantifier that matches zero or more occurrences of the preceding element, which in this case is \\w<\/code>.<\/li>\n\n\n\n
  • at<\/code> matches the literal character “at<\/code>“.<\/li>\n<\/ul>\n\n\n\n
    So the pattern \\w*at<\/code> will match any sequence of word characters followed by the letters “at<\/code>“.<\/p>\n\n\n\n
    2) Matching the occurrences of the preceding element zero or more times (+)<\/h3>\n\n\n\n
    The following example uses the quantifier (+<\/code>) with \\d<\/code> to match one or more consecutive digits in a string:<\/p>\n\n\n
    using<\/span> System.Text.RegularExpressions;\nusing<\/span> static<\/span> System.Console;\n\n\nvar<\/span> text = \"C# 12 and .NET 8\"<\/span>;\nvar<\/span> pattern = @\"\\d+\"<\/span>;\n\nvar<\/span> matches = Regex.Matches(text, pattern);\n\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
    12<\/span>\n8<\/span><\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    The pattern \\d+<\/code>:<\/p>\n\n\n\n
      \n
    • \\d<\/code> matches any digit.<\/li>\n\n\n\n
    • +<\/code> is a quantifier that matches one or more occurrences of the preceding element, which is \\d in this case.<\/li>\n<\/ul>\n\n\n\n
      So \\d+<\/code> matches a sequence of digits.<\/p>\n\n\n\n
      3) Matching the occurrences of the preceding element one or more times (?)<\/h3>\n\n\n\n
      The following example shows how to use the quantifier (*?) to match both words color<\/code> and colour<\/code>:<\/p>\n\n\n
      using<\/span> System.Text.RegularExpressions;\nusing<\/span> static<\/span> System.Console;\n\n\nvar<\/span> text = \"color or colour\"<\/span>;\nvar<\/span> pattern = @\"colou?r\"<\/span>;\n\nvar<\/span> matches = Regex.Matches(text, pattern);\n\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
      color\ncolour<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
      4) Matching the occurrences of the preceding element exactly n times {n}<\/h3>\n\n\n\n
      The following example uses the quantifier {n}<\/code> with the \\d<\/code> to match exactly two digits:<\/p>\n\n\n
      using<\/span> System.Text.RegularExpressions;\nusing<\/span> static<\/span> System.Console;\n\n\nvar<\/span> text = \"It's 12:30 December 1, 2000\"<\/span>;\nvar<\/span> pattern = @\"\\d{2}\"<\/span>;\n\nvar<\/span> matches = Regex.Matches(text, pattern);\n\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
      12<\/span>\n30<\/span>\n20<\/span>\n00<\/span><\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
      In this example, the regular expression pattern \\d{2}<\/code> matches exactly two consecutive digits. Therefore, it returns 12, 30, 20, and 00.<\/p>\n\n\n\n
      5) Match the occurrences of the preceding element at least n times {n, }<\/h3>\n\n\n\n
      The following example uses the {n,}<\/code> quantifier to match the time in both hh:mm<\/code> and h:mm<\/code> formats:<\/p>\n\n\n
      using<\/span> System.Text.RegularExpressions;\nusing<\/span> static<\/span> System.Console;\n\n\nvar<\/span> text = \"06:20 6:30\"<\/span>;\nvar<\/span> pattern = @\"\\d{1,}:\\d{1,}\"<\/span>;\n\nvar<\/span> matches = Regex.Matches(text, pattern);\n\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
      06<\/span>:20<\/span>\n6<\/span>:30<\/span><\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
      6) Match the occurrences of the preceding element from n to m times {n, m}<\/h3>\n\n\n\n
      The following example uses the {n,m}<\/code> quantifier to match a date in the format m-d-yyyy<\/code> or mm-dd-yyyy<\/code>:<\/p>\n\n\n
      using<\/span> System.Text.RegularExpressions;\nusing<\/span> static<\/span> System.Console;\n\n\nvar<\/span> text = \"12-31-1999 to 1-1-2000\"<\/span>;\nvar<\/span> pattern = @\"\\d{1,2}-\\d{1,2}-\\d{4}\"<\/span>;\n\nvar<\/span> matches = Regex.Matches(text, pattern);\n\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
      12<\/span>-31<\/span>-1999<\/span>\n1<\/span>-1<\/span>-2000<\/span><\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
      Summary<\/h2>\n\n\n\n
        \n
      • Use regex quantifiers to match a preceding pattern a specified number of times.<\/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