Kwantyfikatory w wyrażeniach regularnychQuantifiers in Regular Expressions

Kwantyfikatory określają, ile wystąpień znaku, grupy lub klasy znaków musi być obecne w danych wejściowych, aby można było znaleźć dopasowanie.Quantifiers specify how many instances of a character, group, or character class must be present in the input for a match to be found. W poniższej tabeli wymieniono Kwantyfikatory obsługiwane przez platformę .NET.The following table lists the quantifiers supported by .NET.

Kwantyfikator zachłanneGreedy quantifier Kwantyfikator z opóźnieniemLazy quantifier OpisDescription
* *? Dopasowanie zero lub więcej razy.Match zero or more times.
+ +? Dopasowuje jeden lub więcej razy.Match one or more times.
? ?? Dopasowuje zero lub jeden raz.Match zero or one time.
{n}{ n } {n}?{ n }? Dopasowuje dokładnie n razy.Match exactly n times.
{n,}{ n ,} {n,}?{ n ,}? Dopasowanie co najmniej n razy.Match at least n times.
{n m,``}{ n , m } {n m,``}?{ n , m }? Dopasowuje od n do m razy.Match from n to m times.

Ilości n im są stałymi całkowitymi.The quantities n and m are integer constants. Zwykle Kwantyfikatory są zachłanne; powodują, że aparat wyrażeń regularnych dopasowuje jako wiele wystąpień określonych wzorców, jak to możliwe.Ordinarily, quantifiers are greedy; they cause the regular expression engine to match as many occurrences of particular patterns as possible. Dołączanie ? znaku do kwantyfikatora powoduje jego odłączenie. powoduje to, że aparat wyrażeń regularnych dopasowuje jak najmniejszej liczby wystąpień.Appending the ? character to a quantifier makes it lazy; it causes the regular expression engine to match as few occurrences as possible. Aby uzyskać pełny opis różnicy między zachłanne i kwantyfikatorami z opóźnieniem, zobacz sekcję zachłanne i Kwantyfikatory z opóźnieniem w dalszej części tego tematu.For a complete description of the difference between greedy and lazy quantifiers, see the section Greedy and Lazy Quantifiers later in this topic.

Ważne

Zagnieżdżanie kwantyfikatorów (na przykład jako wzorca (a*)* wyrażenia regularnego) może zwiększyć liczbę porównań, które musi wykonać aparat wyrażeń regularnych, jako funkcję wykładniczą liczby znaków w ciągu wejściowym.Nesting quantifiers (for example, as the regular expression pattern (a*)* does) can increase the number of comparisons that the regular expression engine must perform, as an exponential function of the number of characters in the input string. Aby uzyskać więcej informacji na temat tego zachowania i jego obejść , zobacz wycofywanie.For more information about this behavior and its workarounds, see Backtracking.

Kwantyfikatory wyrażeń regularnychRegular Expression Quantifiers

W poniższych sekcjach wymieniono Kwantyfikatory obsługiwane przez wyrażenia regularne programu .NET.The following sections list the quantifiers supported by .NET regular expressions.

Uwaga

Jeśli znaki *, +,?, {i} są napotkane we wzorcu wyrażenia regularnego, aparat wyrażeń regularnych interpretuje je jako Kwantyfikatory lub część konstrukcji kwantyfikatora, chyba że znajdują się w klasie znaków.If the *, +, ?, {, and } characters are encountered in a regular expression pattern, the regular expression engine interprets them as quantifiers or part of quantifier constructs unless they are included in a character class. Aby interpretować te jako znaki literału poza klasą znaków, należy je zmienić, poprzedzając je ukośnikiem odwrotnym.To interpret these as literal characters outside a character class, you must escape them by preceding them with a backslash. Na przykład ciąg \* we wzorcu wyrażenia regularnego jest interpretowany jako literał gwiazdki ("*").For example, the string \* in a regular expression pattern is interpreted as a literal asterisk ("*") character.

Dopasowanie zero lub więcej razy: *Match Zero or More Times: *

* Kwantyfikator dopasowuje poprzedni element zero lub więcej razy.The * quantifier matches the preceding element zero or more times. Jest to odpowiednik {0,} kwantyfikatora.It is equivalent to the {0,} quantifier. *jest kwantyfikatorem zachłanne, którego odpowiednikiem opóźnionym jest *?.* is a greedy quantifier whose lazy equivalent is *?.

Poniższy przykład ilustruje to wyrażenie regularne.The following example illustrates this regular expression. Dziewięć cyfr w ciągu wejściowym, pięć pasuje do wzorca i cztery95( 9219, 929, i 9919) nie.Of the nine digits in the input string, five match the pattern and four (95, 929, 9219, and 9919) do not.

string pattern = @"\b91*9*\b";   
string input = "99 95 919 929 9119 9219 999 9919 91119";
foreach (Match match in Regex.Matches(input, pattern))
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);
     
// The example displays the following output:   
//       '99' found at position 0.
//       '919' found at position 6.
//       '9119' found at position 14.
//       '999' found at position 24.
//       '91119' found at position 33.
Dim pattern As String = "\b91*9*\b"   
Dim input As String = "99 95 919 929 9119 9219 999 9919 91119"
For Each match As Match In Regex.Matches(input, pattern)
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)
Next     
' The example displays the following output:   
'       '99' found at position 0.
'       '919' found at position 6.
'       '9119' found at position 14.
'       '999' found at position 24.
'       '91119' found at position 33.

Wzorzec wyrażenia regularnego jest zdefiniowany, jak pokazano w poniższej tabeli.The regular expression pattern is defined as shown in the following table.

WzorzecPattern OpisDescription
\b Rozpoczyna na granicy wyrazu.Start at a word boundary.
91* Dopasowuje "9", po którym następuje zero lub więcej znaków "1".Match a "9" followed by zero or more "1" characters.
9* Dopasowuje zero lub więcej znaków "9".Match zero or more "9" characters.
\b Kończy na granicy wyrazu.End at a word boundary.

Dopasowuje jeden lub więcej razy: +Match One or More Times: +

+ Kwantyfikator dopasowuje poprzedni element jeden lub więcej razy.The + quantifier matches the preceding element one or more times. Jest równoważne {1,}.It is equivalent to {1,}. +jest kwantyfikatorem zachłanne, którego odpowiednikiem opóźnionym jest +?.+ is a greedy quantifier whose lazy equivalent is +?.

Na przykład wyrażenie \ban+\w*?\b regularne próbuje dopasować całe wyrazy, które zaczynają się od litery a , po którym następuje co najmniej jedno wystąpienie litery n.For example, the regular expression \ban+\w*?\b tries to match entire words that begin with the letter a followed by one or more instances of the letter n. Poniższy przykład ilustruje to wyrażenie regularne.The following example illustrates this regular expression. Wyrażenie regularne pasuje do wyrazów an annual,, announcement, i antiquei prawidłowo nie można dopasować autumn i all.The regular expression matches the words an, annual, announcement, and antique, and correctly fails to match autumn and all.

string pattern = @"\ban+\w*?\b";

string input = "Autumn is a great time for an annual announcement to all antique collectors.";
foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);
   
// The example displays the following output:   
//       'an' found at position 27.
//       'annual' found at position 30.
//       'announcement' found at position 37.
//       'antique' found at position 57.      
Dim pattern As String = "\ban+\w*?\b"

Dim input As String = "Autumn is a great time for an annual announcement to all antique collectors."
For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)
Next   
' The example displays the following output:   
'       'an' found at position 27.
'       'annual' found at position 30.
'       'announcement' found at position 37.
'       'antique' found at position 57.      

Wzorzec wyrażenia regularnego jest zdefiniowany, jak pokazano w poniższej tabeli.The regular expression pattern is defined as shown in the following table.

WzorzecPattern OpisDescription
\b Rozpoczyna na granicy wyrazu.Start at a word boundary.
an+ Dopasowuje "a", po którym następuje co najmniej jeden znak "n".Match an "a" followed by one or more "n" characters.
\w*? Dopasowuje znak słowa zero lub więcej razy, ale tyle razy, ile to możliwe.Match a word character zero or more times, but as few times as possible.
\b Kończy na granicy wyrazu.End at a word boundary.

Dopasowanie zero lub jeden raz:?Match Zero or One Time: ?

? Kwantyfikator dopasowuje poprzedni element zero lub jeden raz.The ? quantifier matches the preceding element zero or one time. Jest równoważne {0,1}.It is equivalent to {0,1}. ?jest kwantyfikatorem zachłanne, którego odpowiednikiem opóźnionym jest ??.? is a greedy quantifier whose lazy equivalent is ??.

Na przykład wyrażenie \ban?\b regularne próbuje dopasować całe wyrazy rozpoczynające się od litery a , po której następuje zero lub jedno wystąpienie litery n.For example, the regular expression \ban?\b tries to match entire words that begin with the letter a followed by zero or one instances of the letter n. Innymi słowy, próbuje dopasować słowa a i. anIn other words, it tries to match the words a and an. Poniższy przykład ilustruje to wyrażenie regularne.The following example illustrates this regular expression.

string pattern = @"\ban?\b";
string input = "An amiable animal with a large snount and an animated nose.";
foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);
  
// The example displays the following output:   
//        'An' found at position 0.
//        'a' found at position 23.
//        'an' found at position 42.
Dim pattern As String = "\ban?\b"
Dim input As String = "An amiable animal with a large snount and an animated nose."
For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)
Next  
' The example displays the following output:   
'       'An' found at position 0.
'       'a' found at position 23.
'       'an' found at position 42.

Wzorzec wyrażenia regularnego jest zdefiniowany, jak pokazano w poniższej tabeli.The regular expression pattern is defined as shown in the following table.

WzorzecPattern OpisDescription
\b Rozpoczyna na granicy wyrazu.Start at a word boundary.
an? Dopasowuje "a", po którym następuje zero lub jeden znak "n".Match an "a" followed by zero or one "n" character.
\b Kończy na granicy wyrazu.End at a word boundary.

Dopasuj dokładnie n razy: {n}Match Exactly n Times: {n}

Kwantyfikator n dopasowuje poprzedni element dokładnie n razy, gdzie n jest dowolną liczbą całkowitą. {``}The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n}? {jest kwantyfikatorem zachłanne, którego odpowiednik opóźniony to n.}{n} is a greedy quantifier whose lazy equivalent is {n}?.

Na przykład wyrażenie \b\d+\,\d{3}\b regularne próbuje dopasować granicę wyrazu, po którym następuje co najmniej jedna cyfra dziesiętna, po której następują trzy cyfry dziesiętne, a po niej granicę wyrazu.For example, the regular expression \b\d+\,\d{3}\b tries to match a word boundary followed by one or more decimal digits followed by three decimal digits followed by a word boundary. Poniższy przykład ilustruje to wyrażenie regularne.The following example illustrates this regular expression.

string pattern = @"\b\d+\,\d{3}\b";
string input = "Sales totaled 103,524 million in January, " + 
                      "106,971 million in February, but only " + 
                      "943 million in March.";
foreach (Match match in Regex.Matches(input, pattern))
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);
     
//  The example displays the following output:   
//        '103,524' found at position 14.
//        '106,971' found at position 45.
Dim pattern As String = "\b\d+\,\d{3}\b"
Dim input As String = "Sales totaled 103,524 million in January, " + _
                      "106,971 million in February, but only " + _
                      "943 million in March."
For Each match As Match In Regex.Matches(input, pattern)
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)
Next     
' The example displays the following output:   
'       '103,524' found at position 14.
'       '106,971' found at position 45.

Wzorzec wyrażenia regularnego jest zdefiniowany, jak pokazano w poniższej tabeli.The regular expression pattern is defined as shown in the following table.

WzorzecPattern OpisDescription
\b Rozpoczyna na granicy wyrazu.Start at a word boundary.
\d+ Dopasowanie do co najmniej jednej cyfry dziesiętnej.Match one or more decimal digits.
\, Dopasowuje znak przecinka.Match a comma character.
\d{3} Dopasowuje trzy cyfry dziesiętne.Match three decimal digits.
\b Kończy na granicy wyrazu.End at a word boundary.

Dopasowuje co najmniej n razy: {n,}Match at Least n Times: {n,}

Kwantyfikator n dopasowuje poprzedni element co najmniej n razy, gdzie n jest dowolną liczbą całkowitą. {``,}The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,}? {jest kwantyfikatorem zachłanne, którego odpowiednik opóźniony to n.,}{n,} is a greedy quantifier whose lazy equivalent is {n,}?.

Na przykład wyrażenie \b\d{2,}\b\D+ regularne próbuje dopasować granicę wyrazu, po którym następuje co najmniej dwie cyfry, po których następuje granica słowa i znak niebędący cyfrą.For example, the regular expression \b\d{2,}\b\D+ tries to match a word boundary followed by at least two digits followed by a word boundary and a non-digit character. Poniższy przykład ilustruje to wyrażenie regularne.The following example illustrates this regular expression. Wyrażenie regularne nie pasuje do frazy "7 days" , ponieważ zawiera tylko jedną cyfrę dziesiętną, ale pomyślnie dopasowuje frazy. "10 weeks and 300 years"The regular expression fails to match the phrase "7 days" because it contains just one decimal digit, but it successfully matches the phrases "10 weeks and 300 years".

string pattern = @"\b\d{2,}\b\D+";   
string input = "7 days, 10 weeks, 300 years";
foreach (Match match in Regex.Matches(input, pattern))
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);
 
//  The example displays the following output:
//        '10 weeks, ' found at position 8.
//        '300 years' found at position 18.
 Dim pattern As String = "\b\d{2,}\b\D+"  
 Dim input As String = "7 days, 10 weeks, 300 years"
For Each match As Match In Regex.Matches(input, pattern)
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)
Next 
' The example displays the following output:
'       '10 weeks, ' found at position 8.
'       '300 years' found at position 18.

Wzorzec wyrażenia regularnego jest zdefiniowany, jak pokazano w poniższej tabeli.The regular expression pattern is defined as shown in the following table.

WzorzecPattern OpisDescription
\b Rozpoczyna na granicy wyrazu.Start at a word boundary.
\d{2,} Dopasowuje co najmniej dwie cyfry dziesiętne.Match at least two decimal digits.
\b Dopasowuje granicę wyrazu.Match a word boundary.
\D+ Dopasowuje co najmniej jedną cyfrę niedziesiętną.Match at least one non-decimal digit.

Dopasowanie między n i m razy: {n, m}Match Between n and m Times: {n,m}

Kwantyfikator n m dopasowuje poprzedni element co najmniej n razy, ale nie więcej niż m razy, gdzie n i m są liczbami całkowitymi.} , {The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n {``,``}? mjestkwantyfikatoremzachłanne,któregoodpowiednikopóźnionytonm.} ,{n,m} is a greedy quantifier whose lazy equivalent is {n,m}?.

W poniższym przykładzie wyrażenie (00\s){2,4} regularne próbuje dopasować między dwoma i czterema wystąpieniami dwóch cyfr zerowych, po których występuje spacja.In the following example, the regular expression (00\s){2,4} tries to match between two and four occurrences of two zero digits followed by a space. Należy zauważyć, że końcowa część ciągu wejściowego zawiera ten wzorzec pięć razy, a nie maksymalnie cztery.Note that the final portion of the input string includes this pattern five times rather than the maximum of four. Jednak tylko początkowa część tego podciągu (do spacji i piąta para zer) pasuje do wzorca wyrażenia regularnego.However, only the initial portion of this substring (up to the space and the fifth pair of zeros) matches the regular expression pattern.

string pattern = @"(00\s){2,4}";
string input = "0x00 FF 00 00 18 17 FF 00 00 00 21 00 00 00 00 00";
foreach (Match match in Regex.Matches(input, pattern))
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);
 
//  The example displays the following output:
//        '00 00 ' found at position 8.
//        '00 00 00 ' found at position 23.
//        '00 00 00 00 ' found at position 35.
Dim pattern As String = "(00\s){2,4}"
Dim input As String = "0x00 FF 00 00 18 17 FF 00 00 00 21 00 00 00 00 00"
For Each match As Match In Regex.Matches(input, pattern)
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)
Next 
' The example displays the following output:
'       '00 00 ' found at position 8.
'       '00 00 00 ' found at position 23.
'       '00 00 00 00 ' found at position 35.

Dopasowuje zero lub więcej razy (dopasowanie z opóźnieniem): *?Match Zero or More Times (Lazy Match): *?

*? Kwantyfikator dopasowuje poprzedzający element zero lub więcej razy, ale tyle razy, ile to możliwe.The *? quantifier matches the preceding element zero or more times, but as few times as possible. Jest odpowiednikiem z opóźnieniem kwantyfikatora *zachłanne.It is the lazy counterpart of the greedy quantifier *.

W poniższym przykładzie wyrażenie \b\w*?oo\w*?\b regularne dopasowuje wszystkie wyrazy, które zawierają ciąg. ooIn the following example, the regular expression \b\w*?oo\w*?\b matches all words that contain the string oo.

 string pattern = @"\b\w*?oo\w*?\b";
 string input = "woof root root rob oof woo woe";
 foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
    Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);
  
 //  The example displays the following output:
//        'woof' found at position 0.
//        'root' found at position 5.
//        'root' found at position 10.
//        'oof' found at position 19.
//        'woo' found at position 23.
 Dim pattern As String = "\b\w*?oo\w*?\b"
 Dim input As String = "woof root root rob oof woo woe"
 For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
    Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)
 Next 
 ' The example displays the following output:
'       'woof' found at position 0.
'       'root' found at position 5.
'       'root' found at position 10.
'       'oof' found at position 19.
'       'woo' found at position 23.

Wzorzec wyrażenia regularnego jest zdefiniowany, jak pokazano w poniższej tabeli.The regular expression pattern is defined as shown in the following table.

WzorzecPattern OpisDescription
\b Rozpoczyna na granicy wyrazu.Start at a word boundary.
\w*? Dopasowuje zero lub więcej znaków słowa, ale jak najmniejsza liczba znaków.Match zero or more word characters, but as few characters as possible.
oo Dopasowuje ciąg "oo".Match the string "oo".
\w*? Dopasowuje zero lub więcej znaków słowa, ale jak najmniejsza liczba znaków.Match zero or more word characters, but as few characters as possible.
\b Koniec na granicy słowa.End on a word boundary.

Dopasowuje jeden lub więcej razy (dopasowanie z opóźnieniem): +?Match One or More Times (Lazy Match): +?

+? Kwantyfikator dopasowuje poprzedni element jeden lub więcej razy, ale jak najszybciej, jak to możliwe.The +? quantifier matches the preceding element one or more times, but as few times as possible. Jest odpowiednikiem z opóźnieniem kwantyfikatora +zachłanne.It is the lazy counterpart of the greedy quantifier +.

Na przykład wyrażenie \b\w+?\b regularne dopasowuje co najmniej jeden znak rozdzielony przez granice słowa.For example, the regular expression \b\w+?\b matches one or more characters separated by word boundaries. Poniższy przykład ilustruje to wyrażenie regularne.The following example illustrates this regular expression.

string pattern = @"\b\w+?\b";
string input = "Aa Bb Cc Dd Ee Ff";
foreach (Match match in Regex.Matches(input, pattern))
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);
 
//  The example displays the following output:
//        'Aa' found at position 0.
//        'Bb' found at position 3.
//        'Cc' found at position 6.
//        'Dd' found at position 9.
//        'Ee' found at position 12.
//        'Ff' found at position 15.
 Dim pattern As String = "\b\w+?\b"
 Dim input As String = "Aa Bb Cc Dd Ee Ff"
For Each match As Match In Regex.Matches(input, pattern)
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)
Next 
' The example displays the following output:
'       'Aa' found at position 0.
'       'Bb' found at position 3.
'       'Cc' found at position 6.
'       'Dd' found at position 9.
'       'Ee' found at position 12.
'       'Ff' found at position 15.

Dopasowuje zero lub jeden raz (dopasowanie z opóźnieniem):?Match Zero or One Time (Lazy Match): ??

?? Kwantyfikator dopasowuje poprzedni element zero lub jeden raz, ale tyle razy, ile to możliwe.The ?? quantifier matches the preceding element zero or one time, but as few times as possible. Jest odpowiednikiem z opóźnieniem kwantyfikatora ?zachłanne.It is the lazy counterpart of the greedy quantifier ?.

Na przykład wyrażenie ^\s*(System.)??Console.Write(Line)??\(?? regularne próbuje dopasować ciągi "Console. Write" lub "Console. WriteLine".For example, the regular expression ^\s*(System.)??Console.Write(Line)??\(?? attempts to match the strings "Console.Write" or "Console.WriteLine". Ciąg może również zawierać "system".The string can also include "System." przed "konsolą" i może następować nawias otwierający.before "Console", and it can be followed by an opening parenthesis. Ciąg musi znajdować się na początku wiersza, chociaż może być poprzedzony białym znakiem.The string must be at the beginning of a line, although it can be preceded by white space. Poniższy przykład ilustruje to wyrażenie regularne.The following example illustrates this regular expression.

string pattern = @"^\s*(System.)??Console.Write(Line)??\(??";
string input = "System.Console.WriteLine(\"Hello!\")\n" + 
                      "Console.Write(\"Hello!\")\n" + 
                      "Console.WriteLine(\"Hello!\")\n" + 
                      "Console.ReadLine()\n" + 
                      "   Console.WriteLine";
foreach (Match match in Regex.Matches(input, pattern, 
                                      RegexOptions.IgnorePatternWhitespace | 
                                      RegexOptions.IgnoreCase | 
                                      RegexOptions.Multiline))
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);
 
//  The example displays the following output:
//        'System.Console.Write' found at position 0.
//        'Console.Write' found at position 36.
//        'Console.Write' found at position 61.
//        '   Console.Write' found at position 110.
Dim pattern As String = "^\s*(System.)??Console.Write(Line)??\(??"
Dim input As String = "System.Console.WriteLine(""Hello!"")" + vbCrLf + _
                      "Console.Write(""Hello!"")" + vbCrLf + _
                      "Console.WriteLine(""Hello!"")" + vbCrLf + _
                      "Console.ReadLine()" + vbCrLf + _
                      "   Console.WriteLine"
For Each match As Match In Regex.Matches(input, pattern, _
                                         RegexOptions.IgnorePatternWhitespace Or RegexOptions.IgnoreCase Or RegexOptions.MultiLine)
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)
Next 
' The example displays the following output:
'       'System.Console.Write' found at position 0.
'       'Console.Write' found at position 36.
'       'Console.Write' found at position 61.
'       '   Console.Write' found at position 110.

Wzorzec wyrażenia regularnego jest zdefiniowany, jak pokazano w poniższej tabeli.The regular expression pattern is defined as shown in the following table.

WzorzecPattern OpisDescription
^ Dopasowuje początek strumienia wejściowego.Match the start of the input stream.
\s* Dopasowanie do zera lub większej liczby znaków odstępu.Match zero or more white-space characters.
(System.)?? Dopasowanie do zera lub jednego wystąpienia ciągu "System.".Match zero or one occurrence of the string "System.".
Console.Write Dopasowuje ciąg "Console. Write".Match the string "Console.Write".
(Line)?? Dopasowanie do zera lub jednego wystąpienia ciągu "line".Match zero or one occurrence of the string "Line".
\(?? Dopasowanie do zera lub jednego wystąpienia nawiasu otwierającego.Match zero or one occurrence of the opening parenthesis.

Dopasuj dokładnie n razy (dopasowanie z opóźnieniem): {n}?Match Exactly n Times (Lazy Match): {n}?

nKwantyfikatorn dopasowuje poprzedni element dokładnie raz, gdzie n jest dowolną liczbą całkowitą. {``}?The {n}? quantifier matches the preceding element exactly n times, where n is any integer. Jest to odpowiednik opóźniony kwantyfikatora {zachłanne n}.It is the lazy counterpart of the greedy quantifier {n}.

W poniższym przykładzie wyrażenie \b(\w{3,}?\.){2}?\w{3,}?\b regularne służy do identyfikowania adresu witryny sieci Web.In the following example, the regular expression \b(\w{3,}?\.){2}?\w{3,}?\b is used to identify a Web site address. Należy pamiętać, że pasuje do "www.microsoft.com" i "msdn.microsoft.com", ale nie pasuje do "Website" lub "mycompany.com".Note that it matches "www.microsoft.com" and "msdn.microsoft.com", but does not match "mywebsite" or "mycompany.com".

string pattern = @"\b(\w{3,}?\.){2}?\w{3,}?\b";
string input = "www.microsoft.com msdn.microsoft.com mywebsite mycompany.com";
foreach (Match match in Regex.Matches(input, pattern))
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);
     
//  The example displays the following output:
//        'www.microsoft.com' found at position 0.
//        'msdn.microsoft.com' found at position 18.
 Dim pattern As String = "\b(\w{3,}?\.){2}?\w{3,}?\b"
 Dim input As String = "www.microsoft.com msdn.microsoft.com mywebsite mycompany.com"
For Each match As Match In Regex.Matches(input, pattern)
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)
Next     
' The example displays the following output:
'       'www.microsoft.com' found at position 0.
'       'msdn.microsoft.com' found at position 18.

Wzorzec wyrażenia regularnego jest zdefiniowany, jak pokazano w poniższej tabeli.The regular expression pattern is defined as shown in the following table.

WzorzecPattern OpisDescription
\b Rozpoczyna na granicy wyrazu.Start at a word boundary.
(\w{3,}?\.) Dopasowuje co najmniej 3 znaki słowa, ale jak najmniejsza liczba znaków, po których następuje znak kropki lub kropki.Match at least 3 word characters, but as few characters as possible, followed by a dot or period character. Jest to pierwsza grupa przechwytywania.This is the first capturing group.
(\w{3,}?\.){2}? Dopasowuje wzorzec w pierwszej grupie dwa razy, ale tyle razy, ile to możliwe.Match the pattern in the first group two times, but as few times as possible.
\b Zakończ dopasowanie na granicy słowa.End the match on a word boundary.

Dopasowuje co najmniej n razy (dopasowanie z opóźnieniem): {n,}?Match at Least n Times (Lazy Match): {n,}?

nKwantyfikatorn dopasowuje poprzedni element co najmniej razy, gdzie n jest dowolną liczbą całkowitą, ale tyle razy, ile to możliwe. {``,}?The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. Jest to odpowiednik opóźniony kwantyfikatora {zachłanne n,}.It is the lazy counterpart of the greedy quantifier {n,}.

Zobacz przykład dla {kwantyfikatora n }? w poprzedniej sekcji dla ilustracji.See the example for the {n}? quantifier in the previous section for an illustration. Wyrażenie regularne w tym przykładzie używa {kwantyfikatora n ,} , aby dopasować ciąg, który zawiera co najmniej trzy znaki, po których następuje kropka.The regular expression in that example uses the {n,} quantifier to match a string that has at least three characters followed by a period.

Dopasowanie między n i m razy (dopasowanie z opóźnieniem): {n, m}?Match Between n and m Times (Lazy Match): {n,m}?

{Kwantyfikator n n m dopasowuje poprzedni element między im Times, gdzie n i m są liczbami całkowitymi, ale tyle razy, ile to możliwe.,``}?The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. Jest to {odpowiednik opóźniony kwantyfikatora zachłanne n,m}.It is the lazy counterpart of the greedy quantifier {n,m}.

W poniższym przykładzie wyrażenie \b[A-Z](\w*?\s*?){1,10}[.!?] regularne dopasowuje zdania zawierające od jednego do dziesięciu wyrazów.In the following example, the regular expression \b[A-Z](\w*?\s*?){1,10}[.!?] matches sentences that contain between one and ten words. Dopasowuje wszystkie zdania w ciągu wejściowym z wyjątkiem jednego zdania zawierającego 18 wyrazów.It matches all the sentences in the input string except for one sentence that contains 18 words.

string pattern = @"\b[A-Z](\w*?\s*?){1,10}[.!?]";
string input = "Hi. I am writing a short note. Its purpose is " + 
                      "to test a regular expression that attempts to find " + 
                      "sentences with ten or fewer words. Most sentences " + 
                      "in this note are short.";
foreach (Match match in Regex.Matches(input, pattern))
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);
 
//  The example displays the following output:
//        'Hi.' found at position 0.
//        'I am writing a short note.' found at position 4.
//        'Most sentences in this note are short.' found at position 132.
Dim pattern As String = "\b[A-Z](\w*\s?){1,10}?[.!?]"
Dim input As String = "Hi. I am writing a short note. Its purpose is " + _
                      "to test a regular expression that attempts to find " + _
                      "sentences with ten or fewer words. Most sentences " + _
                      "in this note are short."
For Each match As Match In Regex.Matches(input, pattern)
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)
Next 
' The example displays the following output:
'       'Hi.' found at position 0.
'       'I am writing a short note.' found at position 4.
'       'Most sentences in this note are short.' found at position 132.

Wzorzec wyrażenia regularnego jest zdefiniowany, jak pokazano w poniższej tabeli.The regular expression pattern is defined as shown in the following table.

WzorzecPattern OpisDescription
\b Rozpoczyna na granicy wyrazu.Start at a word boundary.
[A-Z] Dopasowuje wielką literę od A do Z.Match an uppercase character from A to Z.
(\w*?\s*?) Dopasowuje zero lub więcej znaków wyrazu, po którym następuje co najmniej jeden znak odstępu, ale tyle razy, ile to możliwe.Match zero or more word characters, followed by one or more white-space characters, but as few times as possible. Jest to pierwsza grupa przechwytywania.This is the first capture group.
{1,10} Dopasowuje poprzedni wzorzec od 1 do 10 razy.Match the previous pattern between 1 and 10 times.
[.!?] Dopasowuje dowolny z tych znaków interpunkcyjnych ".", "!" lub "?".Match any one of the punctuation characters ".", "!", or "?".

Zachłanne i Kwantyfikatory z opóźnieniemGreedy and Lazy Quantifiers

Liczba kwantyfikatorów ma dwie wersje:A number of the quantifiers have two versions:

  • Wersja zachłanne.A greedy version.

    Kwantyfikator zachłanne próbuje dopasować element tyle razy, ile to możliwe.A greedy quantifier tries to match an element as many times as possible.

  • Wersja innego typu niż zachłanne (lub z opóźnieniem).A non-greedy (or lazy) version.

    Kwantyfikator inny niż zachłanne próbuje dopasować element jak najprawdopodobniej, jak to możliwe.A non-greedy quantifier tries to match an element as few times as possible. Kwantyfikator zachłanne można przekształcić w kwantyfikator z opóźnieniem, po prostu dodając ?.You can turn a greedy quantifier into a lazy quantifier by simply adding a ?.

Rozważ proste wyrażenie regularne, które jest przeznaczone do wyodrębnienia ostatnich czterech cyfr z ciągu cyfr, takich jak numer karty kredytowej.Consider a simple regular expression that is intended to extract the last four digits from a string of numbers such as a credit card number. Wersja wyrażenia regularnego, która używa * kwantyfikatora \b.*([0-9]{4})\bzachłanne.The version of the regular expression that uses the * greedy quantifier is \b.*([0-9]{4})\b. Jeśli jednak ciąg zawiera dwie liczby, to wyrażenie regularne dopasowuje się do ostatnich czterech cyfr w drugiej liczbie, jak pokazano w poniższym przykładzie.However, if a string contains two numbers, this regular expression matches the last four digits of the second number only, as the following example shows.

string greedyPattern = @"\b.*([0-9]{4})\b";
string input1 = "1112223333 3992991999";
foreach (Match match in Regex.Matches(input1, greedyPattern))
   Console.WriteLine("Account ending in ******{0}.", match.Groups[1].Value);

// The example displays the following output:
//       Account ending in ******1999.
Dim greedyPattern As String = "\b.*([0-9]{4})\b"
Dim input1 As String = "1112223333 3992991999"
For Each match As Match In Regex.Matches(input1, greedypattern)
   Console.WriteLine("Account ending in ******{0}.", match.Groups(1).Value)
Next
' The example displays the following output:
'       Account ending in ******1999.

Wyrażenie regularne nie dopasowuje pierwszej liczby, ponieważ * kwantyfikator próbuje dopasować poprzedni element tyle razy, ile jest to możliwe w całym ciągu, i dlatego znalazł jego dopasowanie na końcu ciągu.The regular expression fails to match the first number because the * quantifier tries to match the previous element as many times as possible in the entire string, and so it finds its match at the end of the string.

Nie jest to pożądane zachowanie.This is not the desired behavior. Zamiast tego można użyć *?kwantyfikatora opóźnionego do wyodrębnienia cyfr z obu liczb, jak pokazano w poniższym przykładzie.Instead, you can use the *?lazy quantifier to extract digits from both numbers, as the following example shows.

string lazyPattern = @"\b.*?([0-9]{4})\b";
string input2 = "1112223333 3992991999";
foreach (Match match in Regex.Matches(input2, lazyPattern))
   Console.WriteLine("Account ending in ******{0}.", match.Groups[1].Value);

// The example displays the following output:
//       Account ending in ******3333.
//       Account ending in ******1999.
Dim lazyPattern As String = "\b.*?([0-9]{4})\b"
Dim input2 As String = "1112223333 3992991999"
For Each match As Match In Regex.Matches(input2, lazypattern)
   Console.WriteLine("Account ending in ******{0}.", match.Groups(1).Value)
Next     
' The example displays the following output:
'       Account ending in ******3333.
'       Account ending in ******1999.

W większości przypadków wyrażenia regularne z zachłanne i kwantyfikatorów opóźnionych zwracają te same dopasowania.In most cases, regular expressions with greedy and lazy quantifiers return the same matches. Najczęściej zwracają różne wyniki, gdy są używane z symbolem wieloznacznym.(), który dopasowuje dowolny znak.They most commonly return different results when they are used with the wildcard (.) metacharacter, which matches any character.

Kwantyfikatory i puste dopasowaniaQuantifiers and Empty Matches

Kwantyfikatory *, +i { n mi} ich odpowiedniki z opóźnieniem nigdy nie powtarzają się po pustym dopasowaniu po znalezieniu minimalnej liczby przechwytywania.,The quantifiers *, +, and {n,m} and their lazy counterparts never repeat after an empty match when the minimum number of captures has been found. Ta reguła uniemożliwia kwantyfikatorom wprowadzanie nieskończonych pętli przy pustym podrażeniu, gdy maksymalna liczba możliwych przechwycenia grupy jest nieskończona lub bliska nieskończoność.This rule prevents quantifiers from entering infinite loops on empty subexpression matches when the maximum number of possible group captures is infinite or near infinite.

Na przykład poniższy kod ilustruje wynik wywołania Regex.Match metody z wzorcem (a?)*wyrażenia regularnego, który odpowiada zero lub jeden znak "a" zero lub więcej razy.For example, the following code shows the result of a call to the Regex.Match method with the regular expression pattern (a?)*, which matches zero or one "a" character zero or more times. Należy zauważyć, że pojedyncza grupa przechwytywania przechwytuje każdy "a String.Empty", ale nie ma drugiego pustego dopasowania, ponieważ pierwsze puste dopasowanie powoduje, że kwantyfikator przestanie powtarzać się.Note that the single capturing group captures each "a" as well as String.Empty, but that there is no second empty match, because the first empty match causes the quantifier to stop repeating.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "(a?)*";
      string input = "aaabbb";
      Match match = Regex.Match(input, pattern);
      Console.WriteLine("Match: '{0}' at index {1}", 
                        match.Value, match.Index);
      if (match.Groups.Count > 1) {
         GroupCollection groups = match.Groups;
         for (int grpCtr = 1; grpCtr <= groups.Count - 1; grpCtr++) {
            Console.WriteLine("   Group {0}: '{1}' at index {2}", 
                              grpCtr, 
                              groups[grpCtr].Value,
                              groups[grpCtr].Index);
            int captureCtr = 0;
            foreach (Capture capture in groups[grpCtr].Captures) {
               captureCtr++;
               Console.WriteLine("      Capture {0}: '{1}' at index {2}", 
                                 captureCtr, capture.Value, capture.Index);
            }
         } 
      }   
   }
}
// The example displays the following output:
//       Match: 'aaa' at index 0
//          Group 1: '' at index 3
//             Capture 1: 'a' at index 0
//             Capture 2: 'a' at index 1
//             Capture 3: 'a' at index 2
//             Capture 4: '' at index 3
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(a?)*"
      Dim input As String = "aaabbb"
      Dim match As Match = Regex.Match(input, pattern)
      Console.WriteLine("Match: '{0}' at index {1}", 
                        match.Value, match.Index)
      If match.Groups.Count > 1 Then
         Dim groups As GroupCollection = match.Groups
         For grpCtr As Integer = 1 To groups.Count - 1
            Console.WriteLine("   Group {0}: '{1}' at index {2}", 
                              grpCtr, 
                              groups(grpCtr).Value,
                              groups(grpCtr).Index)
            Dim captureCtr As Integer = 0
            For Each capture As Capture In groups(grpCtr).Captures
               captureCtr += 1
               Console.WriteLine("      Capture {0}: '{1}' at index {2}", 
                                 captureCtr, capture.Value, capture.Index)
            Next
         Next 
      End If   
   End Sub
End Module
' The example displays the following output:
'       Match: 'aaa' at index 0
'          Group 1: '' at index 3
'             Capture 1: 'a' at index 0
'             Capture 2: 'a' at index 1
'             Capture 3: 'a' at index 2
'             Capture 4: '' at index 3

Aby zobaczyć praktyczną różnicę między grupą przechwytywania, która definiuje minimalną i maksymalną liczbę przechwytywania, i jedną, która definiuje stałą liczbę przechwytywania, należy wziąć pod uwagę wzorce (a\1|(?(1)\1)){0,2} wyrażeń regularnych i. (a\1|(?(1)\1)){2}To see the practical difference between a capturing group that defines a minimum and a maximum number of captures and one that defines a fixed number of captures, consider the regular expression patterns (a\1|(?(1)\1)){0,2} and (a\1|(?(1)\1)){2}. Oba wyrażenia regularne składają się z pojedynczej grupy przechwytywania, która jest zdefiniowana w poniższej tabeli.Both regular expressions consist of a single capturing group, which is defined as shown in the following table.

WzorzecPattern OpisDescription
(a\1 Dopasowuje wartość "a" wraz z wartością pierwszej przechwyconej grupy...Either match "a" along with the value of the first captured group …
|(?(1) lub Przetestuj, czy pierwsza przechwycona Grupa została zdefiniowana.or test whether the first captured group has been defined. (Należy zauważyć, (?(1) że konstrukcja nie definiuje grupy przechwytywania).(Note that the (?(1) construct does not define a capturing group.)
\1)) W przypadku istnienia pierwszej przechwyconej grupy Dopasuj jej wartość.If the first captured group exists, match its value. Jeśli grupa nie istnieje, grupa będzie pasować String.Empty.If the group does not exist, the group will match String.Empty.

Pierwsze wyrażenie regularne próbuje dopasować ten wzorzec od zera do dwóch razy; sekunda, dokładnie dwa razy.The first regular expression tries to match this pattern between zero and two times; the second, exactly two times. Ze względu na to String.Empty, że pierwszy wzorzec osiągnie swoją minimalną liczbę przechwytywania z pierwszym przechwyceniem, nigdy nie powtarza się, aby spróbować dopasować a\1; {0,2} kwantyfikator dopuszcza tylko puste dopasowania w ostatniej iteracji.Because the first pattern reaches its minimum number of captures with its first capture of String.Empty, it never repeats to try to match a\1; the {0,2} quantifier allows only empty matches in the last iteration. Natomiast drugie wyrażenie regularne dopasowuje się do "a", ponieważ szacuje a\1 drugi raz; minimalna liczba iteracji, 2, wymusza powtarzanie aparatu po pustym dopasowaniu.In contrast, the second regular expression does match "a" because it evaluates a\1 a second time; the minimum number of iterations, 2, forces the engine to repeat after an empty match.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern, input;
       
      pattern = @"(a\1|(?(1)\1)){0,2}";
      input = "aaabbb"; 

      Console.WriteLine("Regex pattern: {0}", pattern);
      Match match = Regex.Match(input, pattern);
      Console.WriteLine("Match: '{0}' at position {1}.", 
                        match.Value, match.Index);
      if (match.Groups.Count > 1) {
         for (int groupCtr = 1; groupCtr <= match.Groups.Count - 1; groupCtr++)
         {
            Group group = match.Groups[groupCtr];         
            Console.WriteLine("   Group: {0}: '{1}' at position {2}.", 
                              groupCtr, group.Value, group.Index);
            int captureCtr = 0;
            foreach (Capture capture in group.Captures) {
               captureCtr++;
               Console.WriteLine("      Capture: {0}: '{1}' at position {2}.", 
                                 captureCtr, capture.Value, capture.Index);
            }   
         }
      }
      Console.WriteLine();

      pattern = @"(a\1|(?(1)\1)){2}";
      Console.WriteLine("Regex pattern: {0}", pattern);
      match = Regex.Match(input, pattern);
         Console.WriteLine("Matched '{0}' at position {1}.", 
                           match.Value, match.Index);
      if (match.Groups.Count > 1) {
         for (int groupCtr = 1; groupCtr <= match.Groups.Count - 1; groupCtr++)
         {
            Group group = match.Groups[groupCtr];         
            Console.WriteLine("   Group: {0}: '{1}' at position {2}.", 
                              groupCtr, group.Value, group.Index);
            int captureCtr = 0;
            foreach (Capture capture in group.Captures) {
               captureCtr++;
               Console.WriteLine("      Capture: {0}: '{1}' at position {2}.", 
                                 captureCtr, capture.Value, capture.Index);
            }   
         }
      }
   }
}
// The example displays the following output:
//       Regex pattern: (a\1|(?(1)\1)){0,2}
//       Match: '' at position 0.
//          Group: 1: '' at position 0.
//             Capture: 1: '' at position 0.
//       
//       Regex pattern: (a\1|(?(1)\1)){2}
//       Matched 'a' at position 0.
//          Group: 1: 'a' at position 0.
//             Capture: 1: '' at position 0.
//             Capture: 2: 'a' at position 0.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern, input As String
       
      pattern = "(a\1|(?(1)\1)){0,2}"
      input = "aaabbb" 

      Console.WriteLine("Regex pattern: {0}", pattern)
      Dim match As Match = Regex.Match(input, pattern)
      Console.WriteLine("Match: '{0}' at position {1}.", 
                        match.Value, match.Index)
      If match.Groups.Count > 1 Then
         For groupCtr As Integer = 1 To match.Groups.Count - 1
            Dim group As Group = match.Groups(groupCtr)         
            Console.WriteLine("   Group: {0}: '{1}' at position {2}.", 
                              groupCtr, group.Value, group.Index)
            Dim captureCtr As Integer = 0
            For Each capture As Capture In group.Captures
               captureCtr += 1
               Console.WriteLine("      Capture: {0}: '{1}' at position {2}.", 
                                 captureCtr, capture.Value, capture.Index)
            Next   
         Next
      End If
      Console.WriteLine()

      pattern = "(a\1|(?(1)\1)){2}"
      Console.WriteLine("Regex pattern: {0}", pattern)
      match = Regex.Match(input, pattern)
         Console.WriteLine("Matched '{0}' at position {1}.", 
                           match.Value, match.Index)
      If match.Groups.Count > 1 Then
         For groupCtr As Integer = 1 To match.Groups.Count - 1
            Dim group As Group = match.Groups(groupCtr)         
            Console.WriteLine("   Group: {0}: '{1}' at position {2}.", 
                              groupCtr, group.Value, group.Index)
            Dim captureCtr As Integer = 0
            For Each capture As Capture In group.Captures
               captureCtr += 1
               Console.WriteLine("      Capture: {0}: '{1}' at position {2}.", 
                                 captureCtr, capture.Value, capture.Index)
            Next   
         Next
      End If
   End Sub
End Module
' The example displays the following output:
'       Regex pattern: (a\1|(?(1)\1)){0,2}
'       Match: '' at position 0.
'          Group: 1: '' at position 0.
'             Capture: 1: '' at position 0.
'       
'       Regex pattern: (a\1|(?(1)\1)){2}
'       Matched 'a' at position 0.
'          Group: 1: 'a' at position 0.
'             Capture: 1: '' at position 0.
'             Capture: 2: 'a' at position 0.

Zobacz takżeSee also