Kwantyfikatory w wyrażeniach regularnychQuantifiers in Regular Expressions

Kwantyfikatory Określ, ile wystąpień znak, grupa lub Klasa znaków musi znajdować się w danych wejściowych, aby dopasowanie zakończyło się można znaleźć.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 kwantyfikatorów poparte .NET.The following table lists the quantifiers supported by .NET.

Zachłanne kwantyfikatorGreedy quantifier Kwantyfikatorem opóźniającymLazy quantifier OpisDescription
* *? Dopasowuje 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 }? Dokładnie n razy.Match exactly n times.
{ n ,}{ n ,} { n ,}?{ n ,}? Zgodne z 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 i m są stałe całkowite.The quantities n and m are integer constants. Zazwyczaj Kwantyfikatory są zachłanne; mogą spowodować, że aparat wyrażenia regularnego dopasowuje dowolną liczbę wystąpień danego 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 ? znak kwantyfikator sprawia, że z opóźnieniem; sprawia, że aparat wyrażeń regularnych dopasować jak najmniejszej liczby wystąpień, jak to możliwe.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 Kwantyfikatory zachłanne i z opóźnieniem, zobacz sekcję Greedy i Kwantyfikatory opóźniające 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 kwantyfikatory (na przykład, jako wzorca wyrażenia regularnego (a*)* jest) można zwiększyć liczbę porównania, które należy wykonać aparat wyrażeń regularnych, jak funkcja wykładnicza liczbę 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 dotyczących tego zachowania i jego obejścia, zobacz Backtracking.For more information about this behavior and its workarounds, see Backtracking.

Kwantyfikatory wyrażeń regularnychRegular Expression Quantifiers

W poniższych sekcjach wymieniono kwantyfikatorów poparte wyrażeń regularnych programu .NET.The following sections list the quantifiers supported by .NET regular expressions.

Uwaga

Jeśli *, +,?, {, i} znaki zostaną napotkane we wzorcu wyrażenia regularnego, aparat wyrażeń regularnych interpretuje je jako Kwantyfikatory lub jej część kwantyfikator konstrukcji, chyba że są one uwzględnione w klasy 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. Interpretowanie je jako znaki literału poza klasą znak, możesz je ucieczki poprzedzając je znakiem kreski ułamkowej odwróconej.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 \* w wyrażeniu regularnym wzorzec jest interpretowany jako literał gwiazdki ("*") znaków.For example, the string \* in a regular expression pattern is interpreted as a literal asterisk ("*") character.

Odpowiada 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 równoważne {0,} kwantyfikator.It is equivalent to the {0,} quantifier. * jest zachłanne kwantyfikator, którego opóźnieniem odpowiednik to *?.* is a greedy quantifier whose lazy equivalent is *?.

Poniższy przykład ilustruje tego wyrażenia regularnego.The following example illustrates this regular expression. Dziewięć cyfr w ciągu wejściowym, pięciu pasuje wzorzec i cztery (95, 929, 9219, i 9919) nie obsługują.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.

Definicję wzorca 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órej 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.

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

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

Na przykład, wyrażenie regularne \ban+\w*?\b próbuje dopasować całe wyrazy, które zaczynają się od litery a następuje co najmniej jednego wystąpienia 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 tego wyrażenia regularnego.The following example illustrates this regular expression. Wyrażenie regularne dopasowuje wyrazy an, annual, announcement, i antiquei poprawnie ulegnie awarii 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.      

Definicję wzorca 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+ Uwzględnij wiadomość "" następuje jeden lub więcej znaków "n".Match an "a" followed by one or more "n" characters.
\w*? Dopasuj znak wyrazu, zero lub więcej razy, ale jak 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.

Odpowiada Zero lub jeden raz:?Match Zero or One Time: ?

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

Na przykład, wyrażenie regularne \ban?\b próbuje dopasować całe wyrazy, które zaczynają się od litery a następuje zero lub jeden wystąpień 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łów a i an.In other words, it tries to match the words a and an. Poniższy przykład ilustruje tego wyrażenia regularnego.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.

Definicję wzorca 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? Uwzględnij wiadomość "" 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}

{ n } kwantyfikator dopasowuje poprzedzający 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 zachłanne kwantyfikator, którego opóźnieniem odpowiednik to { n}?.{n} is a greedy quantifier whose lazy equivalent is {n}?.

Na przykład, wyrażenie regularne \b\d+\,\d{3}\b próbuje dopasować granicę wyrazu, następuje jeden lub więcej cyfr dziesiętnych następują trzy cyfry dziesiętne, następuje granica 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 tego wyrażenia regularnego.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.

Definicję wzorca 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,}

{ n ,} kwantyfikator 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 zachłanne kwantyfikator, którego opóźnieniem odpowiednik to { n,}?.{n,} is a greedy quantifier whose lazy equivalent is {n,}?.

Na przykład, wyrażenie regularne \b\d{2,}\b\D+ próbuje dopasować granicę wyrazu, a następnie co najmniej dwie cyfry, następuje granica wyrazu a 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 tego wyrażenia regularnego.The following example illustrates this regular expression. Wyrażenie regularne nie powiedzie się dopasować frazę "7 days" , ponieważ zawiera ona tylko jedną cyfrę dziesiętną, ale pomyślnie odpowiada zwrotów "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.

Definicję wzorca 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ę niebędący cyfrą dziesiętną.Match at least one non-decimal digit.

Dopasowanie między wartościami godziny n i m: {n, m}Match Between n and m Times: {n,m}

{ n,m } kwantyfikator 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,m } jest zachłanne kwantyfikator, którego opóźnieniem odpowiednik to { n,m }?.{n,m} is a greedy quantifier whose lazy equivalent is {n,m}?.

W poniższym przykładzie, wyrażenie regularne (00\s){2,4} próbuje dopasować między dwoma i czterema wystąpieniami dwóch cyfr, zerowego nastę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 pamiętać, że końcowa część ciąg wejściowy zawiera ten wzorzec pięciokrotnie zamiast maksymalnie cztery.Note that the final portion of the input string includes this pattern five times rather than the maximum of four. Jednak początkowego fragmentu to substring (maksymalnie miejsce i piąty pary zera) 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.

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

*? Kwantyfikator dopasowuje poprzedni element zero lub więcej razy, ale jak tyle razy, ile to możliwe.The *? quantifier matches the preceding element zero or more times, but as few times as possible. Jest powolne odpowiednik metody zachłannego kwantyfikator *.It is the lazy counterpart of the greedy quantifier *.

W poniższym przykładzie, wyrażenie regularne \b\w*?oo\w*?\b dopasowuje wszystkie wyrazy, które zawierają ciąg oo.In 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.

Definicję wzorca 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 liczbę znaków, jak to możliwe.Match zero or more word characters, but as few characters as possible.
oo Pasuje do ciągu "wprowadzaniem".Match the string "oo".
\w*? Dopasowuje zero lub więcej znaków słowa, ale liczbę znaków, jak to możliwe.Match zero or more word characters, but as few characters as possible.
\b Kończy na granicy wyrazu.End on a word boundary.

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

+? Kwantyfikator dopasowuje poprzedzający element jeden lub więcej razy, ale jak tyle razy, ile to możliwe.The +? quantifier matches the preceding element one or more times, but as few times as possible. Jest powolne odpowiednik metody zachłannego kwantyfikator +.It is the lazy counterpart of the greedy quantifier +.

Na przykład, wyrażenie regularne \b\w+?\b dopasowuje jeden lub więcej znaków oddzielonych granicy słowa.For example, the regular expression \b\w+?\b matches one or more characters separated by word boundaries. Poniższy przykład ilustruje tego wyrażenia regularnego.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.

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

?? Kwantyfikator dopasowuje poprzedni element zero lub jeden podczas, ale jak tyle razy, ile to możliwe.The ?? quantifier matches the preceding element zero or one time, but as few times as possible. Jest powolne odpowiednik metody zachłannego kwantyfikator ?.It is the lazy counterpart of the greedy quantifier ?.

Na przykład, wyrażenie regularne ^\s*(System.)??Console.Write(Line)??\(?? próbuje dopasować ciągi "Console.Write —" lub "Elementu 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 "Konsoli" który może następować nawias otwierający.before "Console", and it can be followed by an opening parenthesis. Ciąg musi być na początku wiersza, chociaż może być poprzedzona znakiem odstępu.The string must be at the beginning of a line, although it can be preceded by white space. Poniższy przykład ilustruje tego wyrażenia regularnego.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.

Definicję wzorca 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.)?? Dopasowuje zero lub jeden wystąpienie ciągu "System.".Match zero or one occurrence of the string "System.".
Console.Write Pasuje do ciągu "Console.Write —".Match the string "Console.Write".
(Line)?? Dopasowuje zero lub jeden wystąpienie ciągu "Wiersz".Match zero or one occurrence of the string "Line".
\(?? Dopasowanie zera lub jednego wystąpienia nawias otwierający.Match zero or one occurrence of the opening parenthesis.

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

{ n }? kwantyfikator dopasowuje poprzedzający 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. Jest powolne odpowiednik metody zachłannego kwantyfikator { n}+.It is the lazy counterpart of the greedy quantifier {n}+.

W poniższym przykładzie, wyrażenie regularne \b(\w{3,}?\.){2}?\w{3,}?\b służy do identyfikowania adres 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ć, jego pasuje do "www.microsoft.com" i "msdn.microsoft.com", ale nie pasuje "MojaWitrynaSieciWeb" 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.

Definicję wzorca 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 znaków słowa, ale liczbę znaków, jak to możliwe, następuje kropka lub znak 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}? Pasuje do wzorca, 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 wyrazu.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,}?

{ n ,}? kwantyfikator dopasowuje poprzedni element co najmniej n razy, gdzie n jest dowolną liczbą całkowitą, ale jak 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 powolne odpowiednik metody zachłannego kwantyfikator { n,}.It is the lazy counterpart of the greedy quantifier {n,}.

Zobacz przykład { n }? kwantyfikator w poprzedniej sekcji do celów informacyjnych.See the example for the {n}? quantifier in the previous section for an illustration. Używa wyrażenia regularnego, w tym przykładzie { n ,} kwantyfikator próby dopasowania ciągu, który ma co najmniej trzy znaki 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.

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

{ n,m }? kwantyfikator dopasowuje poprzedni element między n i m razy, gdzie n i m są liczbami całkowitymi, ale jak 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 powolne odpowiednik metody zachłannego kwantyfikator { n,m}.It is the lazy counterpart of the greedy quantifier {n,m}.

W poniższym przykładzie, wyrażenie regularne \b[A-Z](\w*\s+){1,10}?[.!?] odpowiada zdania zawierające między wyrazami jednego do dziesięciu.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 jedno zdanie, które zawiera wyrazy 18.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.

Definicję wzorca 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 znak wielkie litery od A do Z.Match an uppercase character from A to Z.
(\w*\s+) Dopasowuje zero lub więcej znaków słowa, następuje co najmniej jeden znak odstępu.Match zero or more word characters, followed by one or more white-space characters. Jest to pierwsza grupa przechwytywania.This is the first capture group.
{1,10}? Dopasowuje poprzedni wzorzec między 1 a 10 razy, ale tyle razy, jak to możliwe.Match the previous pattern between 1 and 10 times, but as few times as possible.
[.!?] Pasuje do jednej znaków interpunkcyjnych ".","!", lub "?".Match any one of the punctuation characters ".", "!", or "?".

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

Liczba Kwantyfikatory są dwie wersje:A number of the quantifiers have two versions:

  • Zachłanne wersji.A greedy version.

    Zachłanne kwantyfikator próbuje dopasować element dowolną liczbę razy.A greedy quantifier tries to match an element as many times as possible.

  • Wersja niezachłanne (lub z opóźnieniem).A non-greedy (or lazy) version.

    Niezachłanne kwantyfikator próbuje dopasować element tyle razy, jak to możliwe.A non-greedy quantifier tries to match an element as few times as possible. Można przekształcić w zachłanne kwantyfikator kwantyfikatorem opóźniającym, po prostu dodając ?.You can turn a greedy quantifier into a lazy quantifier by simply adding a ?.

Należy wziąć pod uwagę prostych wyrażeń regularnych, które ma na celu prowadzenie cztery ostatnie cyfry ciąg liczb, takie 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óry używa * jest zachłanne kwantyfikator \b.*([0-9]{4})\b.The version of the regular expression that uses the * greedy quantifier is \b.*([0-9]{4})\b. Jednak jeśli ciąg zawiera dwie liczby, tego wyrażenia regularnego dopasowuje jak w poniższym przykładzie przedstawiono cztery ostatnie cyfry, druga liczba.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 jest zgodna z liczbą pierwszą, ponieważ * kwantyfikator próbuje dopasować poprzedni element tyle razy, jak to możliwe w ciągu całego, a więc znajdzie 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 żądane zachowanie.This is not the desired behavior. Zamiast tego można użyć *?kwantyfikatorem opóźniającym wyodrębniania cyfr z obu numerów, co ilustruje poniższy przykład.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żeń regularnych bez znaczących Kwantyfikatory zachłanne podręczne i leniwa zwracać ten sam dopasowań.In most cases, regular expressions with greedy and lazy quantifiers return the same matches. Najczęściej zwracają różne wyniki, jeśli są używane za pomocą symbolu wieloznacznego (.) metaznak, 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 dopasowańQuantifiers and Empty Matches

Kwantyfikatory *, +, i { n,m } i ich odpowiedniki z opóźnieniem nigdy nie Powtórz po pustą pasuje, gdy minimalna Znaleziono wiele 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 zasada uniemożliwia Kwantyfikatory wprowadzania pętli nieskończonej na pusty Podwyrażenie dopasowuje, jeśli maksymalna liczba możliwych grupy przechwytywania to nieskończoną lub w pobliżu nieskończone.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 przedstawia wynik wywołania Regex.Match metody z wzorcem wyrażenia regularnego (a?)*, który dopasowuje zero lub jeden "" znak 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 pamiętać, że pojedynczej grupy przechwytywania przechwytuje każdego "" jako także String.Empty, ale nie ma drugi pusty dopasowania, ponieważ pierwsze dopasowanie pusty powoduje kwantyfikator zatrzymać powtarzające 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 wyświetlić praktyczne różnicę między grupy przechwytywania, który definiuje co najmniej i maksymalną liczbę oraz danych, który definiuje stałą liczbą przechwytywania, należy wziąć pod uwagę wzorce wyrażeń regularnych (a\1|(?(1)\1)){0,2} 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łada się z pojedynczej grupy przechwytywania, która jest zdefiniowana, jak pokazano 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 Dopasowanie albo "", oraz wartość pierwszej przechwyconej grupy...Either match "a" along with the value of the first captured group …
|(?(1) lub sprawdzić, czy zdefiniowano pierwszej przechwyconej grupy.or test whether the first captured group has been defined. (Należy pamiętać, że (?(1) konstrukcja nie definiuje grupę przechwytywania.)(Note that the (?(1) construct does not define a capturing group.)
\1)) Jeśli istnieje pierwszej przechwyconej grupy, odpowiada jego wartości.If the first captured group exists, match its value. Jeśli grupa nie istnieje, grupa będzie odpowiadał String.Empty.If the group does not exist, the group will match String.Empty.

Pierwsze wyrażenie regularne próbuje dopasować tego wzorca między i cechujące się dwa razy; druga Strona, dokładnie dwa razy.The first regular expression tries to match this pattern between zero and two times; the second, exactly two times. Ponieważ pierwszy wzorzec osiągnie jego minimalną liczbę przechwytywania przy użyciu jego pierwszym przechwytywania String.Empty, nigdy nie jest powtarzany próbuje dopasować a\1; {0,2} kwantyfikator umożliwia tylko puste dopasowań 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. Z kolei drugie wyrażenie regularne jest zgodny "", ponieważ był oceniany a\1 po raz drugi; wymusza minimalną liczbę iteracji, 2, aparat powtórzyć po dopasowaniu puste.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