Konstrukcje grupujące w wyrażeniach regularnychGrouping Constructs in Regular Expressions

Konstrukcje grupujące odróżnić podwyrażenia wyrażeń regularnych i przechwytywane podciągi ciągu wejściowego.Grouping constructs delineate the subexpressions of a regular expression and capture the substrings of an input string. Można użyć konstrukcji grupowania, wykonaj następujące czynności:You can use grouping constructs to do the following:

  • Dopasowuje Wyrażenie cząstkowe powtarzające się w ciągu wejściowym.Match a subexpression that is repeated in the input string.

  • Zastosować kwantyfikator do podwyrażenia, który ma wiele elementów języka wyrażeń regularnych.Apply a quantifier to a subexpression that has multiple regular expression language elements. Aby uzyskać więcej informacji na temat Kwantyfikatory zobacz Kwantyfikatory.For more information about quantifiers, see Quantifiers.

  • Dołączyć ciąg, który jest zwracany przez wyrażenie cząstkowe Regex.Replace i Match.Result metody.Include a subexpression in the string that is returned by the Regex.Replace and Match.Result methods.

  • Pobierz poszczególne podwyrażenia z Match.Groups właściwości i przetwarzać je oddzielnie od dopasowany tekst jako całości.Retrieve individual subexpressions from the Match.Groups property and process them separately from the matched text as a whole.

W poniższej tabeli wymieniono konstrukcje grupujące obsługiwane przez aparat wyrażeń regularnych platformy .NET i wskazuje, czy są one przechwytywania lub nieprzechwytujące.The following table lists the grouping constructs supported by the .NET regular expression engine and indicates whether they are capturing or non-capturing.

Konstrukcja grupującaGrouping construct Przechwytywania lub niezapamiętywaneCapturing or noncapturing
Matched subexpressionsMatched subexpressions PrzechwytywanieCapturing
O nazwie dopasowane podwyrażeniaNamed matched subexpressions PrzechwytywanieCapturing
Równoważenie definicji grupBalancing group definitions PrzechwytywanieCapturing
Grupy niezapamiętywaneNoncapturing groups NiezapamiętywaneNoncapturing
Wyświetlone są opcje grupyGroup options NiezapamiętywaneNoncapturing
Potwierdzenia pozytywna asercja wyprzedzająca o zerowej szerokościZero-width positive lookahead assertions NiezapamiętywaneNoncapturing
Potwierdzenia negatywna asercja wyprzedzająca o zerowej szerokościZero-width negative lookahead assertions NiezapamiętywaneNoncapturing
Potwierdzenia dodatnie asercje wsteczne o zerowej szerokościZero-width positive lookbehind assertions NiezapamiętywaneNoncapturing
Potwierdzenia negatywna asercja wsteczna o zerowej szerokościZero-width negative lookbehind assertions NiezapamiętywaneNoncapturing
Podwyrażenia bez nawrotówNonbacktracking subexpressions NiezapamiętywaneNoncapturing

Aby uzyskać informacje na temat grup i model obiektów wyrażeń regularnych, zobacz konstrukty grupujące i obiekty wyrażeń regularnych.For information on groups and the regular expression object model, see Grouping constructs and regular expression objects.

Dopasowane podwyrażenieMatched Subexpressions

Następujące konstrukcja grupująca przechwytuje dopasowane Podwyrażenie:The following grouping construct captures a matched subexpression:

( Podwyrażenie )( subexpression )

gdzie Podwyrażenie jest wzorzec dowolnym prawidłowym wyrażeniem regularnym.where subexpression is any valid regular expression pattern. Rejestruje, że Użyj nawiasów są numerowane automatycznie od lewej do prawej, na podstawie kolejności nawiasów otwierających w wyrażeniu regularnym, zaczynając od jednego.Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. Przechwytywanie, który wynosi zero numerowane jest tekst pasuje wzorzec całego wyrażenia regularnego.The capture that is numbered zero is the text matched by the entire regular expression pattern.

Uwaga

Domyślnie ( Podwyrażenie ) element języka przechwytuje dopasowane Podwyrażenie.By default, the (subexpression) language element captures the matched subexpression. Ale w tym przypadku RegexOptions parametr metody dopasowania do wzorca wyrażenia regularnego zawiera RegexOptions.ExplicitCapture flagi, lub jeśli n opcja jest stosowana do tego podwyrażenia (zobacz grupie Opcje w dalszej części tego tematu), dopasowane Podwyrażenie nie są przechwytywane.But if the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression (see Group options later in this topic), the matched subexpression is not captured.

Aby uzyskać dostęp przechwyconych grupach na cztery sposoby:You can access captured groups in four ways:

  • Za pomocą dopasowywania wstecznego skonstruować w wyrażeniu regularnym.By using the backreference construct within the regular expression. Dopasowane Podwyrażenie o której mowa w tym samym wyrażeniu regularnym przy użyciu składni \ numer, gdzie numer jest numerem porządkowym przechwyconego podwyrażenia.The matched subexpression is referenced in the same regular expression by using the syntax \number, where number is the ordinal number of the captured subexpression.

  • Za pomocą nazwane dopasowanie wsteczne skonstruować w wyrażeniu regularnym.By using the named backreference construct within the regular expression. Dopasowane Podwyrażenie o której mowa w tym samym wyrażeniu regularnym przy użyciu składni \k< nazwa>, gdzie nazwa to nazwa grupy przechwytywania, lub \k< numer>, gdzie numer jest numerem porządkowym grupy przechwytywania.The matched subexpression is referenced in the same regular expression by using the syntax \k<name>, where name is the name of a capturing group, or \k<number>, where number is the ordinal number of a capturing group. Grupa przechwytywania ma domyślną nazwę, która jest taka sama na odpowiadającą mu liczbę porządkową.A capturing group has a default name that is identical to its ordinal number. Aby uzyskać więcej informacji, zobacz o nazwie dopasowane podwyrażenia w dalszej części tego tematu.For more information, see Named matched subexpressions later in this topic.

  • Za pomocą $ numer sekwencji zastąpienia w Regex.Replace lub Match.Result wywołania metody, gdzie numer jest numerem porządkowym przechwyconego podwyrażenia.By using the $number replacement sequence in a Regex.Replace or Match.Result method call, where number is the ordinal number of the captured subexpression.

  • Programowo, za pomocą GroupCollection obiektu zwróconego przez Match.Groups właściwości.Programmatically, by using the GroupCollection object returned by the Match.Groups property. Element członkowski w pozycji zero w kolekcji reprezentuje dopasowanie całego wyrażenia regularnego.The member at position zero in the collection represents the entire regular expression match. Każdy członek kolejnych reprezentuje dopasowane Podwyrażenie.Each subsequent member represents a matched subexpression. Aby uzyskać więcej informacji, zobacz Grouping Constructs i obiekty wyrażeń regularnych sekcji.For more information, see the Grouping Constructs and Regular Expression Objects section.

W poniższym przykładzie pokazano wyrażenie regularne, który identyfikuje zduplikowane wyrazy w tekście.The following example illustrates a regular expression that identifies duplicated words in text. Wzorzec wyrażenia regularnego dwie grupy przechwytywania reprezentują dwa wystąpienia zduplikowane programu word.The regular expression pattern's two capturing groups represent the two instances of the duplicated word. Drugie wystąpienie ciągu są przechwytywane do zgłaszania jego pozycję początkową w ciągu wejściowym.The second instance is captured to report its starting position in the input string.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\w+)\s(\1)";
      string input = "He said that that was the the correct answer.";
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
         Console.WriteLine("Duplicate '{0}' found at positions {1} and {2}.", 
                           match.Groups[1].Value, match.Groups[1].Index, match.Groups[2].Index);
   }
}
// The example displays the following output:
//       Duplicate 'that' found at positions 8 and 13.
//       Duplicate 'the' found at positions 22 and 26.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(\w+)\s(\1)\W"
      Dim input As String = "He said that that was the the correct answer."
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
         Console.WriteLine("Duplicate '{0}' found at positions {1} and {2}.", _
                           match.Groups(1).Value, match.Groups(1).Index, match.Groups(2).Index)
      Next
   End Sub
End Module
' The example displays the following output:
'       Duplicate 'that' found at positions 8 and 13.
'       Duplicate 'the' found at positions 22 and 26.

Definicję wzorca wyrażenia regularnego jest następująca:The regular expression pattern is the following:

(\w+)\s(\1)\W  

W poniższej tabeli przedstawiono, jak wzorzec wyrażenia regularnego jest interpretowany.The following table shows how the regular expression pattern is interpreted.

WzorzecPattern OpisDescription
(\w+) Dopasowuje co najmniej jeden znak słowa.Match one or more word characters. Jest to pierwsza grupa przechwytywania.This is the first capturing group.
\s Dopasowuje znak odstępu.Match a white-space character.
(\1) Pasuje do ciągu w pierwszej przechwyconej grupy.Match the string in the first captured group. Jest to druga grupa przechwytywania.This is the second capturing group. Przykład przypisuje go do przechwyconej grupy tak, że pozycja początkowa zduplikowane wyrazu mogą być pobierane z Match.Index właściwości.The example assigns it to a captured group so that the starting position of the duplicate word can be retrieved from the Match.Index property.
\W Dopasowuje znak niebędące znakami słowa, w tym białych znaków i znaków interpunkcyjnych.Match a non-word character, including white space and punctuation. Zapobiega to dopasowania wyrazu, który rozpoczyna się od słowa z pierwszej przechwyconej grupy wzorzec wyrażenia regularnego.This prevents the regular expression pattern from matching a word that starts with the word from the first captured group.

O nazwie dopasowane podwyrażeniaNamed Matched Subexpressions

Następujące konstrukcja grupująca przechwytuje dopasowane Podwyrażenie i pozwala uzyskiwać dostęp do według nazwy lub numeru:The following grouping construct captures a matched subexpression and lets you access it by name or by number:

(?<name>subexpression)  

lub:or:

(?'name'subexpression)  

gdzie nazwa jest nazwą prawidłowej grupy i Podwyrażenie jest wzorzec dowolnym prawidłowym wyrażeniem regularnym.where name is a valid group name, and subexpression is any valid regular expression pattern. Nazwa nie może zawierać żadnych znaków interpunkcyjnych i nie może zaczynać się liczbą.name must not contain any punctuation characters and cannot begin with a number.

Uwaga

Jeśli RegexOptions parametr metody dopasowania do wzorca wyrażenia regularnego zawiera RegexOptions.ExplicitCapture flagi, lub jeśli n opcja jest stosowana do tego podwyrażenia (zobacz grupie Opcje w dalszej części tego tematu), tylko Aby Przechwyć Podwyrażenie należy jawnie nazwę grupy przechwytywania.If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression (see Group options later in this topic), the only way to capture a subexpression is to explicitly name capturing groups.

Nazwane przechwyconych grupach można uzyskać dostęp, w następujący sposób:You can access named captured groups in the following ways:

  • Za pomocą nazwane dopasowanie wsteczne skonstruować w wyrażeniu regularnym.By using the named backreference construct within the regular expression. Dopasowane Podwyrażenie o której mowa w tym samym wyrażeniu regularnym przy użyciu składni \k< nazwa>, gdzie nazwa nazywa się przechwyconego podwyrażenia.The matched subexpression is referenced in the same regular expression by using the syntax \k<name>, where name is the name of the captured subexpression.

  • Za pomocą dopasowywania wstecznego skonstruować w wyrażeniu regularnym.By using the backreference construct within the regular expression. Dopasowane Podwyrażenie o której mowa w tym samym wyrażeniu regularnym przy użyciu składni \ numer, gdzie numer jest numerem porządkowym przechwyconego podwyrażenia.The matched subexpression is referenced in the same regular expression by using the syntax \number, where number is the ordinal number of the captured subexpression. O nazwie dopasowane podwyrażenia są numerowane kolejno od lewej do prawej po dopasowane podwyrażenia.Named matched subexpressions are numbered consecutively from left to right after matched subexpressions.

  • Przy użyciu ${ nazwa } sekwencji zastąpienia w Regex.Replace lub Match.Result wywołania metody, gdzie nazwa nazywa się przechwyconego podwyrażenia.By using the ${name} replacement sequence in a Regex.Replace or Match.Result method call, where name is the name of the captured subexpression.

  • Za pomocą $ numer sekwencji zastąpienia w Regex.Replace lub Match.Result wywołania metody, gdzie numer jest numerem porządkowym przechwyconego podwyrażenia.By using the $number replacement sequence in a Regex.Replace or Match.Result method call, where number is the ordinal number of the captured subexpression.

  • Programowo, za pomocą GroupCollection obiektu zwróconego przez Match.Groups właściwości.Programmatically, by using the GroupCollection object returned by the Match.Groups property. Element członkowski w pozycji zero w kolekcji reprezentuje dopasowanie całego wyrażenia regularnego.The member at position zero in the collection represents the entire regular expression match. Każdy członek kolejnych reprezentuje dopasowane Podwyrażenie.Each subsequent member represents a matched subexpression. Nazwane przechwyconej grupy są przechowywane w kolekcji po numerowane przechwyconych grupach.Named captured groups are stored in the collection after numbered captured groups.

  • Programowo, podając nazwę Podwyrażenie do GroupCollection indeksatora obiektu (w języku C#) lub jego Item[String] właściwości (Visual Basic).Programmatically, by providing the subexpression name to the GroupCollection object's indexer (in C#) or to its Item[String] property (in Visual Basic).

Wzorzec wyrażenia regularnego proste ilustruje sposób ponumerowane (bez nazwy) i nazwanych grup mogą być przywoływane programowo lub za pomocą składni języka wyrażeń regularnych.A simple regular expression pattern illustrates how numbered (unnamed) and named groups can be referenced either programmatically or by using regular expression language syntax. Wyrażenie regularne ((?<One>abc)\d+)?(?<Two>xyz)(.*) generuje następujące przechwytywania grupy według numeru i według nazwy.The regular expression ((?<One>abc)\d+)?(?<Two>xyz)(.*) produces the following capturing groups by number and by name. Pierwsza grupa (liczba 0) przechwytywania zawsze odwołuje się do całego wzorca.The first capturing group (number 0) always refers to the entire pattern.

Wartość liczbowaNumber NazwaName WzorzecPattern
00 0 (nazwa domyślna)0 (default name) ((?<One>abc)\d+)?(?<Two>xyz)(.*)
11 1 (domyślna nazwa)1 (default name) ((?<One>abc)\d+)
22 2 (nazwa domyślna)2 (default name) (.*)
33 JedenOne (?<One>abc)
44 DwaTwo (?<Two>xyz)

W poniższym przykładzie pokazano wyrażenie regularne, który identyfikuje zduplikowanych słów i word, który poprzedza każdy wyraz zduplikowane.The following example illustrates a regular expression that identifies duplicated words and the word that immediately follows each duplicated word. Wzorzec wyrażenia regularnego definiuje dwa podwyrażenia o nazwie: duplicateWord, która reprezentuje zduplikowany word; i nextWord, która reprezentuje wyrazu, który następuje po zduplikowane programu word.The regular expression pattern defines two named subexpressions: duplicateWord, which represents the duplicated word; and nextWord, which represents the word that follows the duplicated word.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(?<duplicateWord>\w+)\s\k<duplicateWord>\W(?<nextWord>\w+)";
      string input = "He said that that was the the correct answer.";
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
         Console.WriteLine("A duplicate '{0}' at position {1} is followed by '{2}'.", 
                           match.Groups["duplicateWord"].Value, match.Groups["duplicateWord"].Index, 
                           match.Groups["nextWord"].Value);

   }
}
// The example displays the following output:
//       A duplicate 'that' at position 8 is followed by 'was'.
//       A duplicate 'the' at position 22 is followed by 'correct'.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(?<duplicateWord>\w+)\s\k<duplicateWord>\W(?<nextWord>\w+)"
      Dim input As String = "He said that that was the the correct answer."
      Console.WriteLine(Regex.Matches(input, pattern, RegexOptions.IgnoreCase).Count)
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
         Console.WriteLine("A duplicate '{0}' at position {1} is followed by '{2}'.", _
                           match.Groups("duplicateWord").Value, match.Groups("duplicateWord").Index, _
                           match.Groups("nextWord").Value)
      Next
   End Sub
End Module
' The example displays the following output:
'    A duplicate 'that' at position 8 is followed by 'was'.
'    A duplicate 'the' at position 22 is followed by 'correct'.

Definicję wzorca wyrażenia regularnego jest następująca:The regular expression pattern is as follows:

(?<duplicateWord>\w+)\s\k<duplicateWord>\W(?<nextWord>\w+)  

W poniższej tabeli przedstawiono, jak wyrażenia regularnego jest interpretowany.The following table shows how the regular expression is interpreted.

WzorzecPattern OpisDescription
(?<duplicateWord>\w+) Dopasowuje co najmniej jeden znak słowa.Match one or more word characters. Określ nazwę tej grupy przechwytywania duplicateWord.Name this capturing group duplicateWord.
\s Dopasowuje znak odstępu.Match a white-space character.
\k<duplicateWord> Pasuje do ciągu z przechwyconej grupy, który nosi nazwę duplicateWord.Match the string from the captured group that is named duplicateWord.
\W Dopasowuje znak niebędące znakami słowa, w tym białych znaków i znaków interpunkcyjnych.Match a non-word character, including white space and punctuation. Zapobiega to dopasowania wyrazu, który rozpoczyna się od słowa z pierwszej przechwyconej grupy wzorzec wyrażenia regularnego.This prevents the regular expression pattern from matching a word that starts with the word from the first captured group.
(?<nextWord>\w+) Dopasowuje co najmniej jeden znak słowa.Match one or more word characters. Określ nazwę tej grupy przechwytywania nextWord.Name this capturing group nextWord.

Należy pamiętać, że nazwa grupy można powtarzać w wyrażeniu regularnym.Note that a group name can be repeated in a regular expression. Na przykład, istnieje możliwość przez więcej niż jednej grupy, można go nazwać digit, tak jak pokazano w poniższym przykładzie.For example, it is possible for more than one group to be named digit, as the following example illustrates. W przypadku takich samych nazwach wartość Group obiekt jest określany przez ostatnie pomyślne przechwytywania w ciągu wejściowym.In the case of duplicate names, the value of the Group object is determined by the last successful capture in the input string. Ponadto CaptureCollection jest wypełniana przy użyciu informacji o każdym przechwytywania tak, jak możesz ją, jeśli nie została zduplikowana nazwa grupy.In addition, the CaptureCollection is populated with information about each capture just as it would be if the group name was not duplicated.

W poniższym przykładzie, wyrażenie regularne \D+(?<digit>\d+)\D+(?<digit>\d+)? obejmuje dwa wystąpienia grupę o nazwie digit.In the following example, the regular expression \D+(?<digit>\d+)\D+(?<digit>\d+)? includes two occurrences of a group named digit. Pierwszy digit nazwanymi przechwytywaniami grupy co najmniej jeden znak cyfry.The first digit named group captures one or more digit characters. Drugi digit nazwanej grupy przechwytywania zera lub jednego wystąpienia co najmniej jeden znak cyfry.The second digit named group captures either zero or one occurrence of one or more digit characters. Jako dane wyjściowe w przykładzie pokazano, jeśli drugi przechwytywania pomyślnie grupy jest zgodna z tekstem, wartość ten tekst Określa wartość Group obiektu.As the output from the example shows, if the second capturing group successfully matches text, the value of that text defines the value of the Group object. Jeśli jest to druga grupa przechwytywania nie nie pasuje ciąg wejściowy wartość ostatniego pomyślnego dopasowania definiuje wartość Group obiektu.If the second capturing group cannot does not match the input string, the value of the last successful match defines the value of the Group object.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      String pattern = @"\D+(?<digit>\d+)\D+(?<digit>\d+)?";
      String[] inputs = { "abc123def456", "abc123def" };
      foreach (var input in inputs) {
         Match m = Regex.Match(input, pattern);
         if (m.Success) {
            Console.WriteLine("Match: {0}", m.Value);
            for (int grpCtr = 1; grpCtr < m.Groups.Count; grpCtr++) {
               Group grp = m.Groups[grpCtr];
               Console.WriteLine("Group {0}: {1}", grpCtr, grp.Value);
               for (int capCtr = 0; capCtr < grp.Captures.Count; capCtr++)
                  Console.WriteLine("   Capture {0}: {1}", capCtr,
                                    grp.Captures[capCtr].Value);
            }
         }
         else {
            Console.WriteLine("The match failed.");
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//       Match: abc123def456
//       Group 1: 456
//          Capture 0: 123
//          Capture 1: 456
//
//       Match: abc123def
//       Group 1: 123
//          Capture 0: 123
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\D+(?<digit>\d+)\D+(?<digit>\d+)?"
      Dim inputs() As String = { "abc123def456", "abc123def" }
      For Each input As String In inputs
         Dim m As Match = Regex.Match(input, pattern)
         If m.Success Then
            Console.WriteLine("Match: {0}", m.Value)
            For grpCtr As Integer = 1 to m.Groups.Count - 1
               Dim grp As Group = m.Groups(grpCtr)
               Console.WriteLine("Group {0}: {1}", grpCtr, grp.Value)
               For capCtr As Integer = 0 To grp.Captures.Count - 1
                  Console.WriteLine("   Capture {0}: {1}", capCtr,
                                    grp.Captures(capCtr).Value)
               Next
            Next
         Else
            Console.WriteLine("The match failed.")
         End If
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output:
'       Match: abc123def456
'       Group 1: 456
'          Capture 0: 123
'          Capture 1: 456
'
'       Match: abc123def
'       Group 1: 123
'          Capture 0: 123

W poniższej tabeli przedstawiono, jak wyrażenia regularnego jest interpretowany.The following table shows how the regular expression is interpreted.

WzorzecPattern OpisDescription
\D+ Dopasowuje jeden lub więcej znaków niż cyfra niebędąca cyfrą dziesiętną.Match one or more non-decimal digit characters.
(?<digit>\d+) Dopasowuje co najmniej jeden znak cyfry dziesiętnej.Match one or more decimal digit characters. Dopasowanie, aby przypisać digit o nazwie grupy.Assign the match to the digit named group.
\D+ Dopasowuje jeden lub więcej znaków niż cyfra niebędąca cyfrą dziesiętną.Match one or more non-decimal digit characters.
(?<digit>\d+)? Dopasowanie zera lub jednego wystąpienia co najmniej jeden znak cyfry dziesiętnej.Match zero or one occurrence of one or more decimal digit characters. Dopasowanie, aby przypisać digit o nazwie grupy.Assign the match to the digit named group.

Równoważenie definicji grupBalancing Group Definitions

Definicję grupy równoważącej usuwa definicję wcześniej zdefiniowanej grupy i magazyny w bieżącej grupie, interwał pomiędzy wcześniej zdefiniowaną grupę i bieżącej grupy.A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. Ta konstrukcja grupująca ma następujący format:This grouping construct has the following format:

(?<name1-name2>subexpression)  

lub:or:

(?'name1-name2' subexpression)  

gdzie Nazwa1 jest bieżącą grupę (opcjonalnie) Nazwa2 jest wcześniej zdefiniowanej grupy i Podwyrażenie jest wzorzec dowolnym prawidłowym wyrażeniem regularnym.where name1 is the current group (optional), name2 is a previously defined group, and subexpression is any valid regular expression pattern. Równoważenie definicji grup usuwa definicję Nazwa2 i przechowuje odstęp między Nazwa2 i Nazwa1 w Nazwa1.The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. Jeśli nie Nazwa2 grupy jest zdefiniowany, provided dopasowanie.If no name2 group is defined, the match backtracks. Ponieważ usuwanie ostatnia definicja Nazwa2 poprzednią definicję, co spowoduje wyświetlenie Nazwa2, ta konstrukcja umożliwia używanie stosu przechwyconych obrazów dla grupy Nazwa2 jako Licznik rejestrowanie informacji o zagnieżdżonej konstrukcji, takich jak nawiasy lub otwierające i zamykające nawiasy kwadratowe.Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.

Równoważenie definicji grup używa Nazwa2 jako stosu.The balancing group definition uses name2 as a stack. Znak początku każdej zagnieżdżonej konstrukcji znajduje się w grupie, a w jego Group.Captures kolekcji.The beginning character of each nested construct is placed in the group and in its Group.Captures collection. Po dopasowaniu znak zamykającego odpowiadającymi mu dostawcami otwierania znaków zostanie usunięty z grupy, a Captures kolekcji zmniejszyła się o jeden.When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. Po otwierającym i znaki zamknięcia wszystkich zagnieżdżonych konstrukcji dopasowane, Nazwa2 jest pusty.After the opening and closing characters of all nested constructs have been matched, name2 is empty.

Uwaga

Po użytkownik modyfikuje wyrażenia regularnego w poniższym przykładzie do użycia odpowiednie otwieranie i zamykanie znak zagnieżdżonej konstrukcji, służy do obsługi najbardziej zagnieżdżonej konstrukcji, takich jak wyrażenia matematyczne lub linii kodu programu, które zawierają wiele zagnieżdżonych wywołań metody.After you modify the regular expression in the following example to use the appropriate opening and closing character of a nested construct, you can use it to handle most nested constructs, such as mathematical expressions or lines of program code that include multiple nested method calls.

W poniższym przykładzie użyto definicję grupy równoważącej, aby dopasować lewy i prawy nawias nawiasów kwadratowych (<>) w ciągu wejściowym.The following example uses a balancing group definition to match left and right angle brackets (<>) in an input string. W przykładzie zdefiniowano dwie grupy nazwane Open i Close, które są używane jak stos do śledzenia pary pasujące nawiasy.The example defines two named groups, Open and Close, that are used like a stack to track matching pairs of angle brackets. Każdy przechwyconych lewy nawias kątowy są przesyłane do przechwytywania zbiór Open grupy i wszystkich przechwyconych prawy nawias kątowy są przesyłane do przechwytywania zbiór Close grupy.Each captured left angle bracket is pushed into the capture collection of the Open group, and each captured right angle bracket is pushed into the capture collection of the Close group. Równoważenie definicji grup gwarantuje, że jest pasujący nawias klamrowy pod kątem dla każdego lewego nawiasu ostrego.The balancing group definition ensures that there is a matching right angle bracket for each left angle bracket. Jeśli nie, jest ostatnim podciąg wzorca, (?(Open)(?!)), jest oceniane tylko wtedy, gdy Open grupy nie jest pusty (a w związku z tym, jeśli wszystkie zagnieżdżone konstrukcje nie zostały zamknięte).If there is not, the final subpattern, (?(Open)(?!)), is evaluated only if the Open group is not empty (and, therefore, if all nested constructs have not been closed). Jeśli nie zostało ocenione końcowego podciąg wzorca, dopasowanie zakończy się niepowodzeniem, ponieważ (?!) podciąg wzorca jest asercja negatywna asercja wyprzedzająca o zerowej szerokości, która zawsze kończy się niepowodzeniem.If the final subpattern is evaluated, the match fails, because the (?!) subpattern is a zero-width negative lookahead assertion that always fails.

using System;
using System.Text.RegularExpressions;

class Example
{
   public static void Main() 
   {
      string pattern = "^[^<>]*" +
                       "(" + 
                       "((?'Open'<)[^<>]*)+" +
                       "((?'Close-Open'>)[^<>]*)+" +
                       ")*" +
                       "(?(Open)(?!))$";
      string input = "<abc><mno<xyz>>";

      Match m = Regex.Match(input, pattern);
      if (m.Success == true)
      {
         Console.WriteLine("Input: \"{0}\" \nMatch: \"{1}\"", input, m);
         int grpCtr = 0;
         foreach (Group grp in m.Groups)
         {
            Console.WriteLine("   Group {0}: {1}", grpCtr, grp.Value);
            grpCtr++;
            int capCtr = 0;
            foreach (Capture cap in grp.Captures)
            {            
                Console.WriteLine("      Capture {0}: {1}", capCtr, cap.Value);
                capCtr++;
            }
          }
      }
      else
      {
         Console.WriteLine("Match failed.");
      }   
    }
}
// The example displays the following output:
//    Input: "<abc><mno<xyz>>"
//    Match: "<abc><mno<xyz>>"
//       Group 0: <abc><mno<xyz>>
//          Capture 0: <abc><mno<xyz>>
//       Group 1: <mno<xyz>>
//          Capture 0: <abc>
//          Capture 1: <mno<xyz>>
//       Group 2: <xyz
//          Capture 0: <abc
//          Capture 1: <mno
//          Capture 2: <xyz
//       Group 3: >
//          Capture 0: >
//          Capture 1: >
//          Capture 2: >
//       Group 4:
//       Group 5: mno<xyz>
//          Capture 0: abc
//          Capture 1: xyz
//          Capture 2: mno<xyz>
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main() 
        Dim pattern As String = "^[^<>]*" & _
                                "(" + "((?'Open'<)[^<>]*)+" & _
                                "((?'Close-Open'>)[^<>]*)+" + ")*" & _
                                "(?(Open)(?!))$"
        Dim input As String = "<abc><mno<xyz>>"
        Dim rgx AS New Regex(pattern)'
        Dim m As Match = Regex.Match(input, pattern)
        If m.Success Then
            Console.WriteLine("Input: ""{0}"" " & vbCrLf & "Match: ""{1}""", _
                               input, m)
            Dim grpCtr As Integer = 0
            For Each grp As Group In m.Groups
               Console.WriteLine("   Group {0}: {1}", grpCtr, grp.Value)
               grpCtr += 1
               Dim capCtr As Integer = 0
               For Each cap As Capture In grp.Captures            
                  Console.WriteLine("      Capture {0}: {1}", capCtr, cap.Value)
                  capCtr += 1
               Next
            Next
        Else
            Console.WriteLine("Match failed.")
        End If
    End Sub
End Module  
' The example displays the following output:
'       Input: "<abc><mno<xyz>>"
'       Match: "<abc><mno<xyz>>"
'          Group 0: <abc><mno<xyz>>
'             Capture 0: <abc><mno<xyz>>
'          Group 1: <mno<xyz>>
'             Capture 0: <abc>
'             Capture 1: <mno<xyz>>
'          Group 2: <xyz
'             Capture 0: <abc
'             Capture 1: <mno
'             Capture 2: <xyz
'          Group 3: >
'             Capture 0: >
'             Capture 1: >
'             Capture 2: >
'          Group 4:
'          Group 5: mno<xyz>
'             Capture 0: abc
'             Capture 1: xyz
'             Capture 2: mno<xyz>

Definicję wzorca wyrażenia regularnego jest:The regular expression pattern is:

^[^<>]*(((?'Open'<)[^<>]*)+((?'Close-Open'>)[^<>]*)+)*(?(Open)(?!))$  

Wyrażenia regularnego jest interpretowany w następujący sposób:The regular expression is interpreted as follows:

WzorzecPattern OpisDescription
^ Rozpocznij na początku ciągu.Begin at the start of the string.
[^<>]* Dopasowuje zero lub więcej znaków, które nie są po lewej stronie lub pod kątem nawiasy kwadratowe.Match zero or more characters that are not left or right angle brackets.
(?'Open'<) Zgodne z lewego nawiasu ostrego i przypisz je do grupy o nazwie Open.Match a left angle bracket and assign it to a group named Open.
[^<>]* Dopasowuje zero lub więcej znaków, które nie są po lewej stronie lub pod kątem nawiasy kwadratowe.Match zero or more characters that are not left or right angle brackets.
((?'Open'<)[^<>]*) + Dopasowuje jeden lub więcej wystąpień lewego nawiasu ostrego następuje zero lub więcej znaków, które nie są po lewej stronie lub pod kątem nawiasy kwadratowe.Match one or more occurrences of a left angle bracket followed by zero or more characters that are not left or right angle brackets. Jest to druga grupa przechwytywania.This is the second capturing group.
(?'Close-Open'>) Prawy nawias kątowy odpowiada, należy przypisać podciąg między Open grupy i bieżącą grupą do Close grupy i usuń definicję Open grupy.Match a right angle bracket, assign the substring between the Open group and the current group to the Close group, and delete the definition of the Open group.
[^<>]* Dopasowuje zero lub więcej wystąpień dowolnego znaku, który nie jest lewe ani prawy nawias kątowy.Match zero or more occurrences of any character that is neither a left nor a right angle bracket.
((?'Close-Open'>)[^<>]*)+ Dopasowuje jeden lub więcej wystąpień prawy nawias kątowy, następuje zero lub więcej wystąpień dowolnego znaku jest prawy nawias kątowy ani po lewej stronie.Match one or more occurrences of a right angle bracket, followed by zero or more occurrences of any character that is neither a left nor a right angle bracket. Podczas dopasowywania prawego nawiasu ostrego, przypisz podciąg między Open grupy i bieżącą grupą do Close grupy i usuń definicję Open grupy.When matching the right angle bracket, assign the substring between the Open group and the current group to the Close group, and delete the definition of the Open group. Jest to trzecia grupa przechwytywania.This is the third capturing group.
(((?'Open'<)[^<>]*)+((?'Close-Open'>)[^<>]*)+)* Dopasowuje zero lub więcej wystąpień następującego wzorca: jeden lub więcej wystąpień lewego nawiasu ostrego następuje zero lub więcej znaków nawiasu ostrego następuje jeden lub więcej wystąpień prawy nawias kątowy, następuje zero lub więcej wystąpień inne niż nawiasy.Match zero or more occurrences of the following pattern: one or more occurrences of a left angle bracket, followed by zero or more non-angle bracket characters, followed by one or more occurrences of a right angle bracket, followed by zero or more occurrences of non-angle brackets. Podczas dopasowywania prawego nawiasu ostrego, usuń definicję Open grupy, a następnie przypisz podciąg między Open grupy i bieżącą grupą do Close grupy.When matching the right angle bracket, delete the definition of the Open group, and assign the substring between the Open group and the current group to the Close group. Jest to pierwsza grupa przechwytywania.This is the first capturing group.
(?(Open)(?!)) Jeśli Open grupa istnieje, Porzuć dopasowania, jeśli pusty ciąg, który można dopasować, ale nie Przejdź położenie aparat wyrażeń regularnych w ciągu.If the Open group exists, abandon the match if an empty string can be matched, but do not advance the position of the regular expression engine in the string. Jest to asercja negatywna asercja wyprzedzająca o zerowej szerokości.This is a zero-width negative lookahead assertion. Ponieważ pusty ciąg jest zawsze niejawnie obecne w ciągu wejściowym, tym dopasowanie nie zawsze powiedzie się.Because an empty string is always implicitly present in an input string, this match always fails. Błąd dopasowania to wskazuje, że nawiasy nie są równoważone.Failure of this match indicates that the angle brackets are not balanced.
$ Dopasowuje koniec ciągu wejściowego.Match the end of the input string.

Końcowe Podwyrażenie (?(Open)(?!)), wskazuje, czy zagnieżdżania tworzy się w ciągu wejściowym są prawidłowo równoważone, (na przykład, czy każdy lewego nawiasu ostrego dorównuje prawy nawias kątowy).The final subexpression, (?(Open)(?!)), indicates whether the nesting constructs in the input string are properly balanced (for example, whether each left angle bracket is matched by a right angle bracket). Używa ona dopasowanie warunkowe oparte na prawidłowo przechwyconych grupach; Aby uzyskać więcej informacji, zobacz konstrukcje.It uses conditional matching based on a valid captured group; for more information, see Alternation Constructs. Jeśli Open grupy jest zdefiniowany, aparat wyrażeń regularnych próbuje dopasować Podwyrażenie (?!) w ciągu wejściowym.If the Open group is defined, the regular expression engine attempts to match the subexpression (?!) in the input string. Open Grupy powinna być zdefiniowana tylko wtedy, gdy niezrównoważone konstrukcje zagnieżdżenia.The Open group should be defined only if nesting constructs are unbalanced. W związku z tym wzorzec, które mają zostać dopasowane w ciągu wejściowym powinna wynosić 1, który zawsze powoduje, że dopasowanie nie powiedzie się.Therefore, the pattern to be matched in the input string should be one that always causes the match to fail. W tym przypadku (?!) jest asercja negatywna asercja wyprzedzająca o zerowej szerokości która zawsze kończy się niepowodzeniem, ponieważ ciąg pusty występuje zawsze niejawnie w następnej pozycji w ciągu wejściowym.In this case, (?!) is a zero-width negative lookahead assertion that always fails, because an empty string is always implicitly present at the next position in the input string.

W przykładzie, aparat wyrażeń regularnych ocenia ciągu wejściowego "<abc >< mno<xyz >>" jak pokazano w poniższej tabeli.In the example, the regular expression engine evaluates the input string "<abc><mno<xyz>>" as shown in the following table.

KrokStep WzorzecPattern WynikResult
11 ^ Rozpoczyna dopasowanie na początku ciągu wejściowegoStarts the match at the beginning of the input string
22 [^<>]* Wyszukuje nawiasu ostrego znaków przed lewego nawiasu ostrego; znajdzie żadnych dopasowań.Looks for non-angle bracket characters before the left angle bracket;finds no matches.
33 (((?'Open'<) Pasuje do lewego nawiasu ostrego w "<abc >" i przypisuje go do Open grupy.Matches the left angle bracket in "<abc>" and assigns it to the Open group.
44 [^<>]* Pasuje do "abc".Matches "abc".
55 )+ "< abc" jest wartością drugiego przechwyconą grupę."<abc" is the value of the second captured group.

Następny znak w ciągu wejściowym nie jest lewy nawias kątowy, więc aparat wyrażeń regularnych nie sprzężenia zwrotnego (?'Open'<)[^<>]*) podciąg wzorca.The next character in the input string is not a left angle bracket, so the regular expression engine does not loop back to the (?'Open'<)[^<>]*) subpattern.
66 ((?'Close-Open'>) Pasuje do prawego nawiasu ostrego w "<abc >", "abc", czyli podciąg przypisuje między Open grupy i kąt prosty dopasowywanie do Close grupę, a następnie usuwa bieżącą wartość ("<") z Open grupy, zostawiać je puste.Matches the right angle bracket in "<abc>", assigns "abc", which is the substring between the Open group and the right angle bracket, to the Close group, and deletes the current value ("<") of the Open group, leaving it empty.
77 [^<>]* Wyszukuje nawiasu ostrego znaków od prawego nawiasu ostrego; Umożliwia znalezienie żadnych dopasowań.Looks for non-angle bracket characters after the right angle bracket; finds no matches.
88 )+ Wartość trzeciego przechwyconej grupy ">".The value of the third captured group is ">".

Następny znak w ciągu wejściowym nie jest prawy nawias kątowy, więc aparat wyrażeń regularnych nie sprzężenia zwrotnego ((?'Close-Open'>)[^<>]*) podciąg wzorca.The next character in the input string is not a right angle bracket, so the regular expression engine does not loop back to the ((?'Close-Open'>)[^<>]*) subpattern.
99 )* Wartość pierwszej przechwyconej grupy "<abc >".The value of the first captured group is "<abc>".

Następny znak w ciągu wejściowym jest lewy nawias kątowy, dlatego aparat wyrażeń regularnych w pętli do (((?'Open'<) podciąg wzorca.The next character in the input string is a left angle bracket, so the regular expression engine loops back to the (((?'Open'<) subpattern.
1010 (((?'Open'<) Pasuje do lewego nawiasu ostrego w "<mno >" i przypisuje go do Open grupy.Matches the left angle bracket in "<mno>" and assigns it to the Open group. Jego Group.Captures teraz kolekcja zawiera pojedynczą wartość "<".Its Group.Captures collection now has a single value, "<".
1111 [^<>]* Dopasowuje "mno".Matches "mno".
1212 )+ "< mno" jest wartością drugiego przechwyconą grupę."<mno" is the value of the second captured group.

Następny znak w ciągu wejściowym jest lewy nawias kątowy, dlatego aparat wyrażeń regularnych w pętli do (?'Open'<)[^<>]*) podciąg wzorca.The next character in the input string is an left angle bracket, so the regular expression engine loops back to the (?'Open'<)[^<>]*) subpattern.
1313 (((?'Open'<) Pasuje do lewego nawiasu ostrego w "<xyz >" i przypisuje go do Open grupy.Matches the left angle bracket in "<xyz>" and assigns it to the Open group. Group.Captures Zbiór Open grupy obejmuje teraz dwa przechwytywania: lewy nawias kątowy z "<mno >" i lewego nawiasu ostrego z "<xyz >".The Group.Captures collection of the Open group now includes two captures: the left angle bracket from "<mno>", and the left angle bracket from "<xyz>".
1414 [^<>]* Dopasowania "ciągu xyz".Matches "xyz".
1515 )+ "< xyz" jest wartością drugiego przechwyconą grupę."<xyz" is the value of the second captured group.

Następny znak w ciągu wejściowym nie jest lewy nawias kątowy, więc aparat wyrażeń regularnych nie sprzężenia zwrotnego (?'Open'<)[^<>]*) podciąg wzorca.The next character in the input string is not a left angle bracket, so the regular expression engine does not loop back to the (?'Open'<)[^<>]*) subpattern.
1616 ((?'Close-Open'>) Pasuje do prawego nawiasu ostrego w "<xyz >".Matches the right angle bracket in "<xyz>". ciągu "xyz", przypisuje podciąg między Open grupy i kąt prosty dopasowywanie do Close grupę, a następnie usuwa bieżącą wartość Open grupy."xyz", assigns the substring between the Open group and the right angle bracket to the Close group, and deletes the current value of the Open group. Wartość poprzedniego przechwytywania (lewego nawiasu ostrego w "<mno >") staje się bieżącą wartość Open grupy.The value of the previous capture (the left angle bracket in "<mno>") becomes the current value of the Open group. Captures Zbiór Open grupa zawiera teraz pojedynczy przechwytywania, lewy nawias kątowy z "<xyz >".The Captures collection of the Open group now includes a single capture, the left angle bracket from "<xyz>".
1717 [^<>]* Wyszukuje nawiasu ostrego znaków. Umożliwia znalezienie żadnych dopasowań.Looks for non-angle bracket characters; finds no matches.
1818 )+ Wartość trzeciego przechwyconej grupy ">".The value of the third captured group is ">".

Następny znak w ciągu wejściowym jest prawy nawias kątowy, dlatego aparat wyrażeń regularnych w pętli do ((?'Close-Open'>)[^<>]*) podciąg wzorca.The next character in the input string is a right angle bracket, so the regular expression engine loops back to the ((?'Close-Open'>)[^<>]*) subpattern.
1919 ((?'Close-Open'>) Pasuje do końcowego prawego nawiasu ostrego w "xyz >>", przypisuje "mno<xyz >" (podciąg między Open grupy i prawego nawiasu ostrego) do Close grupę, a następnie usuwa bieżącą wartość Open grupy.Matches the final right angle bracket in "xyz>>", assigns "mno<xyz>" (the substring between the Open group and the right angle bracket) to the Close group, and deletes the current value of the Open group. Open Grupy jest obecnie pusta.The Open group is now empty.
2020 [^<>]* Wyszukuje nawiasu ostrego znaków. Umożliwia znalezienie żadnych dopasowań.Looks for non-angle bracket characters; finds no matches.
2121 )+ Wartość trzeciego przechwyconej grupy ">".The value of the third captured group is ">".

Następny znak w ciągu wejściowym nie jest prawy nawias kątowy, więc aparat wyrażeń regularnych nie sprzężenia zwrotnego ((?'Close-Open'>)[^<>]*) podciąg wzorca.The next character in the input string is not a right angle bracket, so the regular expression engine does not loop back to the ((?'Close-Open'>)[^<>]*) subpattern.
2222 )* Wartość pierwszej przechwyconej grupy "< mno<xyz >>".The value of the first captured group is "<mno<xyz>>".

Następny znak w ciągu wejściowym nie jest lewy nawias kątowy, więc aparat wyrażeń regularnych nie sprzężenia zwrotnego (((?'Open'<) podciąg wzorca.The next character in the input string is not a left angle bracket, so the regular expression engine does not loop back to the (((?'Open'<) subpattern.
2323 (?(Open)(?!)) Open Grupy nie jest zdefiniowana, więc dopasowanie nie zostanie podjęta.The Open group is not defined, so no match is attempted.
2424 $ Pasuje do końca ciągu wejściowego.Matches the end of the input string.

Grupy niezapamiętywaneNoncapturing Groups

Następujące konstrukcji grupowania nie przechwytuje podciągu, który pasuje podwyrażenia:The following grouping construct does not capture the substring that is matched by a subexpression:

(?:subexpression)  

gdzie Podwyrażenie jest wzorzec dowolnym prawidłowym wyrażeniem regularnym.where subexpression is any valid regular expression pattern. Konstrukcja nieprzechwytywaną grupę zwykle jest używana, gdy do grupy jest stosowany kwantyfikator, ale podciągów przechwycone przez grupę są nie interesujące.The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest.

Uwaga

Wyrażenie regularne zawiera konstrukcje grupujące zagnieżdżonych, konstrukcja zewnętrzne nieprzechwytywaną grupę nie ma zastosowania do konstrukcji wewnętrzny grupach zagnieżdżonych.If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs.

W poniższym przykładzie pokazano wyrażenie regularne, które obejmuje grupy niezapamiętywane.The following example illustrates a regular expression that includes noncapturing groups. Należy pamiętać o tym, czy dane wyjściowe nie zawiera żadnych przechwyconych grupach.Note that the output does not include any captured groups.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(?:\b(?:\w+)\W*)+\.";
      string input = "This is a short sentence.";
      Match match = Regex.Match(input, pattern);
      Console.WriteLine("Match: {0}", match.Value);
      for (int ctr = 1; ctr < match.Groups.Count; ctr++)
         Console.WriteLine("   Group {0}: {1}", ctr, match.Groups[ctr].Value);
   }
}
// The example displays the following output:
//       Match: This is a short sentence.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(?:\b(?:\w+)\W*)+\."
      Dim input As String = "This is a short sentence."
      Dim match As Match = Regex.Match(input, pattern)
      Console.WriteLine("Match: {0}", match.Value)
      For ctr As Integer = 1 To match.Groups.Count - 1
         Console.WriteLine("   Group {0}: {1}", ctr, match.Groups(ctr).Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       Match: This is a short sentence.

Wyrażenie regularne (?:\b(?:\w+)\W*)+\. odpowiada zdania, który jest kończony kropką.The regular expression (?:\b(?:\w+)\W*)+\. matches a sentence that is terminated by a period. Ponieważ wyrażenie regularne skupia się na zdania, a nie na poszczególnych wyrazów, konstrukcje grupujące są używane wyłącznie jako Kwantyfikatory.Because the regular expression focuses on sentences and not on individual words, grouping constructs are used exclusively as quantifiers. Wzorzec wyrażenia regularnego jest interpretowany, jak pokazano w poniższej tabeli.The regular expression pattern is interpreted as shown in the following table.

WzorzecPattern OpisDescription
\b Rozpoczyna dopasowanie na granicy wyrazu.Begin the match at a word boundary.
(?:\w+) Dopasowuje co najmniej jeden znak słowa.Match one or more word characters. Nie należy przypisywać dopasowany tekst do przechwyconej grupy.Do not assign the matched text to a captured group.
\W* Dopasowuje zero lub więcej znaki niebędące znakami słowa.Match zero or more non-word characters.
(?:\b(?:\w+)\W*)+ Dopasowuje wzorzec jednego lub więcej znaków słowa, uruchamiania na granicy wyrazu, po której następuje zero lub więcej znaki niebędące znakami słowa, jeden lub więcej razy.Match the pattern of one or more word characters starting at a word boundary, followed by zero or more non-word characters, one or more times. Nie należy przypisywać dopasowany tekst do przechwyconej grupy.Do not assign the matched text to a captured group.
\. Dopasowanie kropki.Match a period.

Opcje grupyGroup Options

Następujące konstrukcja grupująca stosuje lub wyłącza określone opcje w podwyrażeniu:The following grouping construct applies or disables the specified options within a subexpression:

(?imnsx-imnsx: Podwyrażenie )(?imnsx-imnsx: subexpression )

gdzie Podwyrażenie jest wzorzec dowolnym prawidłowym wyrażeniem regularnym.where subexpression is any valid regular expression pattern. Na przykład (?i-s:) włącza ignorowanie wielkości liter i wyłączenie trybu jednowierszowego.For example, (?i-s:) turns on case insensitivity and disables single-line mode. Aby uzyskać więcej informacji dotyczących opcji wbudowanej, można określić, zobacz Regular Expression Options.For more information about the inline options you can specify, see Regular Expression Options.

Uwaga

Można określić opcje, które mają zastosowanie do całego wyrażenia regularnego zamiast podwyrażenia przy użyciu System.Text.RegularExpressions.Regex konstruktora klasy lub metody statycznej.You can specify options that apply to an entire regular expression rather than a subexpression by using a System.Text.RegularExpressions.Regex class constructor or a static method. Można również określić opcje określane w tekście, które są stosowane po określonego punktu w wyrażeniu regularnym przy użyciu (?imnsx-imnsx) konstrukcją języka pierwszej klasy.You can also specify inline options that apply after a specific point in a regular expression by using the (?imnsx-imnsx) language construct.

Konstrukcja opcje grupy nie jest grupa przechwytywania.The group options construct is not a capturing group. Oznacza to mimo że jakiejkolwiek jego części ciągu, która jest przechwytywana przez Podwyrażenie wchodzi w dopasowanie, są nie zawarte w przechwyconej grupy ani używanych do wypełniania GroupCollection obiektu.That is, although any portion of a string that is captured by subexpression is included in the match, it is not included in a captured group nor used to populate the GroupCollection object.

Na przykład, wyrażenie regularne \b(?ix: d \w+)\s w poniższym przykładzie używa opcji wbudowanej w konstrukcję grupującą aby umożliwić dopasowanie bez uwzględniania wielkości liter i Ignorowanie wzorca odstępu przy określaniu wszystkie wyrazy rozpoczynające się od litera "d".For example, the regular expression \b(?ix: d \w+)\s in the following example uses inline options in a grouping construct to enable case-insensitive matching and ignore pattern white space in identifying all words that begin with the letter "d". Wyrażenie regularne jest zdefiniowane, jak pokazano w poniższej tabeli.The regular expression is defined as shown in the following table.

WzorzecPattern OpisDescription
\b Rozpoczyna dopasowanie na granicy wyrazu.Begin the match at a word boundary.
(?ix: d \w+) Za pomocą dopasowanie bez uwzględniania wielkości liter i ignorowanie biały znak w tym wzorcu, dopasowuje "d", po której następuje jeden lub więcej znaków słowa.Using case-insensitive matching and ignoring white space in this pattern, match a "d" followed by one or more word characters.
\s Dopasowuje znak odstępu.Match a white-space character.
string pattern = @"\b(?ix: d \w+)\s";
string input = "Dogs are decidedly good pets.";

foreach (Match match in Regex.Matches(input, pattern))
   Console.WriteLine("'{0}// found at index {1}.", match.Value, match.Index);
// The example displays the following output:
//    'Dogs // found at index 0.
//    'decidedly // found at index 9.      
Dim pattern As String = "\b(?ix: d \w+)\s"
Dim input As String = "Dogs are decidedly good pets."

For Each match As Match In Regex.Matches(input, pattern)
   Console.WriteLine("'{0}' found at index {1}.", match.Value, match.Index)
Next
' The example displays the following output:
'    'Dogs ' found at index 0.
'    'decidedly ' found at index 9.      

Dodatnie asercje z patrzeniem w przód o zerowej szerokościZero-Width Positive Lookahead Assertions

Następujące konstrukcja grupująca definiuje asercja pozytywna asercja wyprzedzająca o zerowej szerokości:The following grouping construct defines a zero-width positive lookahead assertion:

(?= Podwyrażenie )(?= subexpression )

gdzie Podwyrażenie się wszelkie wzorzec wyrażenia regularnego.where subexpression is any regular expression pattern. Dopasowanie zakończy się powodzeniem, ciąg wejściowy musi być zgodna ze wzorcem wyrażenia regularnego w Podwyrażenie, mimo że dopasowany podciąg nie jest uwzględniony w wyniku dopasowania.For a match to be successful, the input string must match the regular expression pattern in subexpression, although the matched substring is not included in the match result. Asercja pozytywna asercja wyprzedzająca o zerowej szerokości nie używa wycofywania.A zero-width positive lookahead assertion does not backtrack.

Zazwyczaj asercja pozytywna asercja wyprzedzająca o zerowej szerokości znajduje się na końcu wzorca wyrażenia regularnego.Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. Definiuje podciąg, muszą znajdować się na końcu ciągu do aby wystąpiło dopasowanie, ale które nie powinny znajdować się dopasowania.It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. Jest to również przydatne w celu zapobiegania nadmiernego wycofywania.It is also useful for preventing excessive backtracking. Asercja pozytywna asercja wyprzedzająca o zerowej szerokości można użyć, aby upewnić się, że określonego przechwyconej grupy rozpoczyna się od tekst, który pasuje do podzbioru wzorca określonego przechwyconej grupy.You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. Na przykład jeśli grupa przechwytywania pasuje do słowa następujących po sobie znaków, umożliwia to asercja pozytywna asercja wyprzedzająca o zerowej szerokości wymagają pierwszym znakiem alfabetycznym, wielką literę.For example, if a capturing group matches consecutive word characters, you can use a zero-width positive lookahead assertion to require that the first character be an alphabetical uppercase character.

Następujące przykładowe zastosowania asercja pozytywna asercja wyprzedzająca o zerowej szerokości, aby dopasować wyrazu, który poprzedza zlecenie "is" w ciągu wejściowym.The following example uses a zero-width positive lookahead assertion to match the word that precedes the verb "is" in the input string.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+(?=\sis\b)";
      string[] inputs = { "The dog is a Malamute.", 
                          "The island has beautiful birds.", 
                          "The pitch missed home plate.", 
                          "Sunday is a weekend day." };

      foreach (string input in inputs)
      {
         Match match = Regex.Match(input, pattern);
         if (match.Success)
            Console.WriteLine("'{0}' precedes 'is'.", match.Value);
         else
            Console.WriteLine("'{0}' does not match the pattern.", input); 
      }
   }
}
// The example displays the following output:
//    'dog' precedes 'is'.
//    'The island has beautiful birds.' does not match the pattern.
//    'The pitch missed home plate.' does not match the pattern.
//    'Sunday' precedes 'is'.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\w+(?=\sis\b)"
      Dim inputs() As String = { "The dog is a Malamute.", _
                                 "The island has beautiful birds.", _
                                 "The pitch missed home plate.", _
                                 "Sunday is a weekend day." }

      For Each input As String In inputs
         Dim match As Match = Regex.Match(input, pattern)
         If match.Success Then
            Console.WriteLine("'{0}' precedes 'is'.", match.Value)
         Else
            Console.WriteLine("'{0}' does not match the pattern.", input) 
         End If     
      Next
   End Sub
End Module
' The example displays the following output:
'       'dog' precedes 'is'.
'       'The island has beautiful birds.' does not match the pattern.
'       'The pitch missed home plate.' does not match the pattern.
'       'Sunday' precedes 'is'.

Wyrażenie regularne \b\w+(?=\sis\b) jest interpretowane tak jak pokazano w poniższej tabeli.The regular expression \b\w+(?=\sis\b) is interpreted as shown in the following table.

WzorzecPattern OpisDescription
\b Rozpoczyna dopasowanie na granicy wyrazu.Begin the match at a word boundary.
\w+ Dopasowuje co najmniej jeden znak słowa.Match one or more word characters.
(?=\sis\b) Określ, czy znaków słowa, których następuje znak odstępu lub ciąg "is", której kończy się na granicy wyrazu.Determine whether the word characters are followed by a white-space character and the string "is", which ends on a word boundary. Jeśli tak, dopasowanie zakończy się pomyślnie.If so, the match is successful.

Ujemne asercje z patrzeniem w przód o zerowej szerokościZero-Width Negative Lookahead Assertions

Następujące konstrukcja grupująca definiuje asercja negatywna asercja wyprzedzająca o zerowej szerokości:The following grouping construct defines a zero-width negative lookahead assertion:

(?! Podwyrażenie )(?! subexpression )

gdzie Podwyrażenie się wszelkie wzorzec wyrażenia regularnego.where subexpression is any regular expression pattern. Dopasowanie zakończy się powodzeniem, ciąg wejściowy nie może odpowiadać wzorzec wyrażenia regularnego w Podwyrażenie, mimo że dopasowany ciąg nie jest uwzględniony w wyniku dopasowania.For the match to be successful, the input string must not match the regular expression pattern in subexpression, although the matched string is not included in the match result.

Asercja negatywna asercja wyprzedzająca o zerowej szerokości, jest zazwyczaj używany na początku lub na końcu wyrażenia regularnego.A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. Na początku wyrażenia regularnego, ją zdefiniować określony wzorzec, które nie powinny być dopasowane, gdy na początku wyrażenia regularnego definiuje podobne, ale bardziej ogólnych wzorzec do dopasowania.At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. W tym przypadku jest często używane do ograniczania wycofywania.In this case, it is often used to limit backtracking. Na końcu wyrażenia regularnego ją zdefiniować Podwyrażenie, który nie może wystąpić na końcu dopasowania.At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match.

W poniższym przykładzie zdefiniowano wyrażenie regularne, który używa asercja wyprzedzająca o zerowej szerokości na początku wyrażenia regularnego do dopasowania słów, które nie zaczynają się od "Uruchom".The following example defines a regular expression that uses a zero-width lookahead assertion at the beginning of the regular expression to match words that do not begin with "un".

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(?!un)\w+\b";
      string input = "unite one unethical ethics use untie ultimate";
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       one
//       ethics
//       use
//       ultimate
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b(?!un)\w+\b"
      Dim input As String = "unite one unethical ethics use untie ultimate"
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
         Console.WriteLine(match.Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       one
'       ethics
'       use
'       ultimate

Wyrażenie regularne \b(?!un)\w+\b jest interpretowane tak jak pokazano w poniższej tabeli.The regular expression \b(?!un)\w+\b is interpreted as shown in the following table.

WzorzecPattern OpisDescription
\b Rozpoczyna dopasowanie na granicy wyrazu.Begin the match at a word boundary.
(?!un) Określanie, czy następne dwa znaki są "Uruchom".Determine whether the next two characters are "un". Jeśli nie są one dopasowanie jest możliwe.If they are not, a match is possible.
\w+ Dopasowuje co najmniej jeden znak słowa.Match one or more word characters.
\b Kończy dopasowanie na granicy wyrazu.End the match at a word boundary.

W poniższym przykładzie zdefiniowano wyrażenie regularne, który używa asercja wyprzedzająca o zerowej szerokości na końcu wyrażenia regularnego do dopasowania słów, których nie kończy się znakiem interpunkcyjnym.The following example defines a regular expression that uses a zero-width lookahead assertion at the end of the regular expression to match words that do not end with a punctuation character.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+\b(?!\p{P})";
      string input = "Disconnected, disjointed thoughts in a sentence fragment.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       disjointed
//       thoughts
//       in
//       a
//       sentence
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\w+\b(?!\p{P})"
      Dim input As String = "Disconnected, disjointed thoughts in a sentence fragment."
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
      Next   
   End Sub
End Module
' The example displays the following output:
'       disjointed
'       thoughts
'       in
'       a
'       sentence

Wyrażenie regularne \b\w+\b(?!\p{P}) jest interpretowane tak jak pokazano w poniższej tabeli.The regular expression \b\w+\b(?!\p{P}) is interpreted as shown in the following table.

WzorzecPattern OpisDescription
\b Rozpoczyna dopasowanie na granicy wyrazu.Begin the match at a word boundary.
\w+ Dopasowuje co najmniej jeden znak słowa.Match one or more word characters.
\b Kończy dopasowanie na granicy wyrazu.End the match at a word boundary.
\p{P}) Jeśli następny znak nie jest symbolem interpunkcji (np. kropki lub przecinka), dopasowanie się powiedzie.If the next character is not a punctuation symbol (such as a period or a comma), the match succeeds.

Dodatnie asercje wsteczne o zerowej szerokościZero-Width Positive Lookbehind Assertions

Następujące konstrukcja grupująca definiuje potwierdzenia dodatnie asercje wsteczne o zerowej szerokości:The following grouping construct defines a zero-width positive lookbehind assertion:

(?<= Podwyrażenie )(?<= subexpression )

gdzie Podwyrażenie się wszelkie wzorzec wyrażenia regularnego.where subexpression is any regular expression pattern. Aby dopasowanie zakończyło się zakończyć się pomyślnie Podwyrażenie musi przypadać w ciągu wejściowym na lewo od aktualnej pozycji, mimo że subexpression nie jest uwzględniony w wyniku dopasowania.For a match to be successful, subexpression must occur at the input string to the left of the current position, although subexpression is not included in the match result. Asercja pozytywna asercja wsteczna o zerowej szerokości nie używa wycofywania.A zero-width positive lookbehind assertion does not backtrack.

Potwierdzenia dodatnie asercje wsteczne o zerowej szerokości są zwykle używane na początku wyrażenia regularne.Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. Wzorzec, który określają jest warunkiem wstępnym pod kątem dopasowania, chociaż nie jest częścią wyników dopasowania.The pattern that they define is a precondition for a match, although it is not a part of the match result.

Na przykład w poniższym przykładzie dopasowywane dwie ostatnie cyfry roku wieku dwudziestego pierwszego (czyli wymaga że cyfr "20" poprzedzać dopasowany ciąg).For example, the following example matches the last two digits of the year for the twenty first century (that is, it requires that the digits "20" precede the matched string).

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "2010 1999 1861 2140 2009";
      string pattern = @"(?<=\b20)\d{2}\b";
      
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       10
//       09
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "2010 1999 1861 2140 2009"
      Dim pattern As String = "(?<=\b20)\d{2}\b"
      
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
      Next      
   End Sub
End Module
' The example displays the following output:
'       10
'       09

Definicję wzorca wyrażenia regularnego (?<=\b20)\d{2}\b jest interpretowane tak jak pokazano w poniższej tabeli.The regular expression pattern (?<=\b20)\d{2}\b is interpreted as shown in the following table.

WzorzecPattern OpisDescription
\d{2} Dopasowuje dwie cyfry dziesiętne.Match two decimal digits.
(?<=\b20) Kontynuuje dopasowywanie, jeśli dwie cyfry dziesiętne są poprzedzone cyfr dziesiętnych "20" na granicy wyrazu.Continue the match if the two decimal digits are preceded by the decimal digits "20" on a word boundary.
\b Kończy dopasowanie na granicy wyrazu.End the match at a word boundary.

Potwierdzenia dodatnie asercje wsteczne o zerowej szerokości są również używane do ograniczania wycofywania, gdy ostatni znak lub znaki w przechwyconej grupy muszą być podzbiorem znaków, które pasuje do wzorca wyrażenia regularnego tej grupy.Zero-width positive lookbehind assertions are also used to limit backtracking when the last character or characters in a captured group must be a subset of the characters that match that group's regular expression pattern. Na przykład jeśli grupa przechwytywania wszystkich znaków słowa kolejnych, umożliwia asercja pozytywna asercja wsteczna o zerowej szerokości wymagać, aby ostatni znak alfabetyczny.For example, if a group captures all consecutive word characters, you can use a zero-width positive lookbehind assertion to require that the last character be alphabetical.

Ujemne asercje wsteczne o zerowej szerokościZero-Width Negative Lookbehind Assertions

Następujące konstrukcja grupująca definiuje asercja negatywna asercja wsteczna o zerowej szerokości:The following grouping construct defines a zero-width negative lookbehind assertion:

(?<! Podwyrażenie )(?<! subexpression )

gdzie Podwyrażenie się wszelkie wzorzec wyrażenia regularnego.where subexpression is any regular expression pattern. Aby dopasowanie zakończyło się zakończyć się pomyślnie Podwyrażenie nie może wystąpić w ciągu wejściowym na lewo od bieżącej pozycji.For a match to be successful, subexpression must not occur at the input string to the left of the current position. Jednak podciąg, która pasuje do subexpression nie jest uwzględniony w wyniku dopasowania.However, any substring that does not match subexpression is not included in the match result.

Negatywna asercja wsteczna o zerowej szerokości potwierdzenia są zwykle używane na początku wyrażenia regularne.Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. Wzorzec, który określają wykluczającą dopasowania w ciągu, który następuje.The pattern that they define precludes a match in the string that follows. Służą one również ograniczyć wycofywania, gdy ostatni znak lub znaki w przechwyconej grupy nie może być jeden lub więcej znaków, które pasują do wzorca wyrażenia regularnego tej grupy.They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. Na przykład jeśli grupa przechwytywania wszystkich znaków słowa kolejnych, umożliwia to asercja pozytywna asercja wsteczna o zerowej szerokości wymagają ostatni znak nie znaku podkreślenia ().For example, if a group captures all consecutive word characters, you can use a zero-width positive lookbehind assertion to require that the last character not be an underscore ().

W poniższym przykładzie dopasowywane Data dla każdego dnia, tygodnia, który nie jest weekendy (który jest sobota ani niedziela).The following example matches the date for any day of the week that is not a weekend (that is, that is neither Saturday nor Sunday).

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] dates = { "Monday February 1, 2010", 
                         "Wednesday February 3, 2010", 
                         "Saturday February 6, 2010", 
                         "Sunday February 7, 2010", 
                         "Monday, February 8, 2010" };
      string pattern = @"(?<!(Saturday|Sunday) )\b\w+ \d{1,2}, \d{4}\b";
      
      foreach (string dateValue in dates)
      {
         Match match = Regex.Match(dateValue, pattern);
         if (match.Success)
            Console.WriteLine(match.Value);
      }      
   }
}
// The example displays the following output:
//       February 1, 2010
//       February 3, 2010
//       February 8, 2010
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim dates() As String = { "Monday February 1, 2010", _
                                "Wednesday February 3, 2010", _
                                "Saturday February 6, 2010", _
                                "Sunday February 7, 2010", _
                                "Monday, February 8, 2010" }
      Dim pattern As String = "(?<!(Saturday|Sunday) )\b\w+ \d{1,2}, \d{4}\b"
      
      For Each dateValue As String In dates
         Dim match As Match = Regex.Match(dateValue, pattern)
         If match.Success Then
            Console.WriteLine(match.Value)
         End If   
      Next      
   End Sub
End Module
' The example displays the following output:
'       February 1, 2010
'       February 3, 2010
'       February 8, 2010

Definicję wzorca wyrażenia regularnego (?<!(Saturday|Sunday) )\b\w+ \d{1,2}, \d{4}\b jest interpretowane tak jak pokazano w poniższej tabeli.The regular expression pattern (?<!(Saturday|Sunday) )\b\w+ \d{1,2}, \d{4}\b is interpreted as shown in the following table.

WzorzecPattern OpisDescription
\b Rozpoczyna dopasowanie na granicy wyrazu.Begin the match at a word boundary.
\w+ Dopasowuje co najmniej jeden znak słowa, następuje znak odstępu.Match one or more word characters followed by a white-space character.
\d{1,2}, Dopasowuje co najmniej dwie cyfry dziesiętne, następuje znak odstępu i przecinek.Match either one or two decimal digits followed by a white-space character and a comma.
\d{4}\b Odpowiada czterem cyfrom po przecinku, a kończy dopasowanie na granicy wyrazu.Match four decimal digits, and end the match at a word boundary.
(?<!(Saturday|Sunday) ) Jeśli dopasowanie jest poprzedzony przez coś innego niż ciągi, "Sobota" lub "Niedziela", po której następuje spacja, dopasowanie zakończy się.If the match is preceded by something other than the strings "Saturday" or "Sunday" followed by a space, the match is successful.

Podwyrażenia bez nawrotówNonbacktracking Subexpressions

Następujące konstrukcja grupująca reprezentuje Podwyrażenie (znany także jako Podwyrażenie "zachłanne"):The following grouping construct represents a nonbacktracking subexpression (also known as a "greedy" subexpression):

(?> Podwyrażenie )(?> subexpression )

gdzie Podwyrażenie się wszelkie wzorzec wyrażenia regularnego.where subexpression is any regular expression pattern.

Normalnie Jeśli wyrażenie regularne zawiera opcjonalne lub alternatywne dopasowania wzorca i dopasowanie nie powiedzie się, aparat wyrażeń regularnych można rozgałęziać w wielu kierunkach do dopasowania ciągu wejściowego z wzorcem.Ordinarily, if a regular expression includes an optional or alternative matching pattern and a match does not succeed, the regular expression engine can branch in multiple directions to match an input string with a pattern. Jeśli nie zostanie znalezione dopasowanie, podczas pierwszej gałęzi, aparat wyrażeń regularnych można utworzyć kopię zapasową lub śledzenie wsteczne w punkcie, gdzie zajęło to pierwsze dopasowanie i spróbuj dopasowanie za pomocą drugiego oddziału.If a match is not found when it takes the first branch, the regular expression engine can back up or backtrack to the point where it took the first match and attempt the match using the second branch. Ten proces może być kontynuowany, dopóki nie wykonano wszystkich gałęzi.This process can continue until all branches have been tried.

(?> Podwyrażenie ) języka konstruowania wyłącza wycofywania.The (?>subexpression) language construct disables backtracking. Aparat wyrażeń regularnych będzie odpowiadał tak dużą liczbę znaków w ciągu wejściowym, ponieważ jest to możliwe.The regular expression engine will match as many characters in the input string as it can. Żadne dodatkowe dopasowanie jest możliwe, będzie śledzenie wsteczne nie próby dopasowania do wzorca alternatywne.When no further match is possible, it will not backtrack to attempt alternate pattern matches. (Czyli Podwyrażenie dopasowuje wyłącznie ciągi, które zostałyby dopasowane przez samo to Podwyrażenie; nie będzie podejmował próby dopasowania ciągu na podstawie Podwyrażenie i wszelkie podwyrażenia, które występują po nim).(That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.)

Ta opcja jest zalecana, jeśli wiesz, że używanie wycofywania nie powiedzie się.This option is recommended if you know that backtracking will not succeed. Aparat wyrażeń regularnych uniemożliwia wykonywanie niepotrzebne wyszukiwania poprawia wydajność.Preventing the regular expression engine from performing unnecessary searching improves performance.

W poniższym przykładzie pokazano, jak Podwyrażenie bez wycofywania modyfikuje wyników dopasowania do wzorca.The following example illustrates how a nonbacktracking subexpression modifies the results of a pattern match. Wycofywania wyrażenie regularne dopasowuje pomyślnie szereg powtarzające się znaki następuje jedno wystąpienie takiego samego znaku na granicy wyrazu, ale bez wyrażenia regularnego nie.The backtracking regular expression successfully matches a series of repeated characters followed by one more occurrence of the same character on a word boundary, but the nonbacktracking regular expression does not.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] inputs = { "cccd.", "aaad", "aaaa" };
      string back = @"(\w)\1+.\b";
      string noback = @"(?>(\w)\1+).\b";
      
      foreach (string input in inputs)
      {
         Match match1 = Regex.Match(input, back);
         Match match2 = Regex.Match(input, noback);
         Console.WriteLine("{0}: ", input);

         Console.Write("   Backtracking : ");
         if (match1.Success)
            Console.WriteLine(match1.Value);
         else
            Console.WriteLine("No match");
         
         Console.Write("   Nonbacktracking: ");
         if (match2.Success)
            Console.WriteLine(match2.Value);
         else
            Console.WriteLine("No match");
      }
   }
}
// The example displays the following output:
//    cccd.:
//       Backtracking : cccd
//       Nonbacktracking: cccd
//    aaad:
//       Backtracking : aaad
//       Nonbacktracking: aaad
//    aaaa:
//       Backtracking : aaaa
//       Nonbacktracking: No match
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim inputs() As String = { "cccd.", "aaad", "aaaa" }
      Dim back As String = "(\w)\1+.\b"
      Dim noback As String = "(?>(\w)\1+).\b"
      
      For Each input As String In inputs
         Dim match1 As Match = Regex.Match(input, back)
         Dim match2 As Match = Regex.Match(input, noback)
         Console.WriteLine("{0}: ", input)

         Console.Write("   Backtracking : ")
         If match1.Success Then
            Console.WriteLine(match1.Value)
         Else
            Console.WriteLine("No match")
         End If
         
         Console.Write("   Nonbacktracking: ")
         If match2.Success Then
            Console.WriteLine(match2.Value)
         Else
            Console.WriteLine("No match")
         End If
      Next
   End Sub
End Module
' The example displays the following output:
'    cccd.:
'       Backtracking : cccd
'       Nonbacktracking: cccd
'    aaad:
'       Backtracking : aaad
'       Nonbacktracking: aaad
'    aaaa:
'       Backtracking : aaaa
'       Nonbacktracking: No match

Podwyrażenia bez wycofywania wyrażenia regularnego (?>(\w)\1+).\b jest zdefiniowany jak pokazano w poniższej tabeli.The nonbacktracking regular expression (?>(\w)\1+).\b is defined as shown in the following table.

WzorzecPattern OpisDescription
(\w) Dopasowuje znak słowa i przypisz je do pierwszej grupy przechwytywania.Match a single word character and assign it to the first capturing group.
\1+ Odpowiada wartości pierwszego przechwyconego podciągu jedną lub więcej razy.Match the value of the first captured substring one or more times.
. Dopasowuje dowolny znak.Match any character.
\b Zakończ dopasowanie na granicy wyrazu.End the match on a word boundary.
(?>(\w)\1+) Pasuje jedno lub więcej wystąpień znaku słowa zduplikowane, ale nie wykonuj nawrotu do dopasowania ostatni znak na granicy wyrazu.Match one or more occurrences of a duplicated word character, but do not backtrack to match the last character on a word boundary.

Konstrukty grupujące i obiekty wyrażeń regularnychGrouping Constructs and Regular Expression Objects

Podciągi, które są dopasowane przez grupę przechwytywania wyrażenia regularnego są reprezentowane przez System.Text.RegularExpressions.Group obiektów, które mogą być pobierane z System.Text.RegularExpressions.GroupCollection obiektu, który jest zwracany przez Match.Groups właściwości.Substrings that are matched by a regular expression capturing group are represented by System.Text.RegularExpressions.Group objects, which can be retrieved from the System.Text.RegularExpressions.GroupCollection object that is returned by the Match.Groups property. GroupCollection Obiektu jest wypełniana w następujący sposób:The GroupCollection object is populated as follows:

  • Pierwszy Group obiektu w kolekcji (object o indeksie zero) reprezentuje całego dopasowania.The first Group object in the collection (the object at index zero) represents the entire match.

  • Zestaw następnego Group obiekty reprezentują nienazwane grupy przechwytywania (numerowana).The next set of Group objects represent unnamed (numbered) capturing groups. Pojawiają się w kolejności, w której są zdefiniowane w wyrażeniu regularnym, od lewej do prawej.They appear in the order in which they are defined in the regular expression, from left to right. Indeks wartości tych grup w zakresie od 1 do liczby nienazwane przechwytywania grup w kolekcji.The index values of these groups range from 1 to the number of unnamed capturing groups in the collection. (Indeks określonej grupy jest równoważne z jej numerowane odwołanie wsteczne.(The index of a particular group is equivalent to its numbered backreference. Aby uzyskać więcej informacji dotyczących dopasowywania wstecznego, zobacz konstrukcje dopasowywania wstecznego.)For more information about backreferences, see Backreference Constructs.)

  • Ostatni zestaw Group obiekty reprezentują nazwanych grup przechwytywania.The final set of Group objects represent named capturing groups. Pojawiają się w kolejności, w której są zdefiniowane w wyrażeniu regularnym, od lewej do prawej.They appear in the order in which they are defined in the regular expression, from left to right. Wartość indeksu pierwszego nazwanej grupy przechwytywania jest większa o jeden od indeksu ostatniej nienazwanej grupy przechwytywania.The index value of the first named capturing group is one greater than the index of the last unnamed capturing group. W przypadku nie nienazwane przechwytywania grup w wyrażeniu regularnym, wartość indeksu pierwszego nazwanej grupy przechwytywania jest jeden.If there are no unnamed capturing groups in the regular expression, the index value of the first named capturing group is one.

W przypadku zastosowania kwantyfikator do grupy przechwytywania, odpowiedni Group obiektu Capture.Value, Capture.Index, i Capture.Length właściwości odzwierciedlają ostatni podciąg, która jest przechwytywana przez grupę przechwytywania.If you apply a quantifier to a capturing group, the corresponding Group object's Capture.Value, Capture.Index, and Capture.Length properties reflect the last substring that is captured by a capturing group. Możesz pobrać kompletny zestaw podciągi, które są przechwytywane według grup, które mają Kwantyfikatory z CaptureCollection obiektu, który jest zwracany przez Group.Captures właściwości.You can retrieve a complete set of substrings that are captured by groups that have quantifiers from the CaptureCollection object that is returned by the Group.Captures property.

Poniższy przykład wyjaśnia stosunek między Group i Capture obiektów.The following example clarifies the relationship between the Group and Capture objects.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\b(\w+)\W+)+";
      string input = "This is a short sentence.";
      Match match = Regex.Match(input, pattern);
      Console.WriteLine("Match: '{0}'", match.Value);
      for (int ctr = 1; ctr < match.Groups.Count; ctr++)
      {
         Console.WriteLine("   Group {0}: '{1}'", ctr, match.Groups[ctr].Value);
         int capCtr = 0;
         foreach (Capture capture in match.Groups[ctr].Captures)
         {
            Console.WriteLine("      Capture {0}: '{1}'", capCtr, capture.Value);
            capCtr++;
         }
      }
   }
}
// The example displays the following output:
//       Match: 'This is a short sentence.'
//          Group 1: 'sentence.'
//             Capture 0: 'This '
//             Capture 1: 'is '
//             Capture 2: 'a '
//             Capture 3: 'short '
//             Capture 4: 'sentence.'
//          Group 2: 'sentence'
//             Capture 0: 'This'
//             Capture 1: 'is'
//             Capture 2: 'a'
//             Capture 3: 'short'
//             Capture 4: 'sentence'
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(\b(\w+)\W+)+"
      Dim input As String = "This is a short sentence."
      Dim match As Match = Regex.Match(input, pattern)
      Console.WriteLine("Match: '{0}'", match.Value)
      For ctr As Integer = 1 To match.Groups.Count - 1
         Console.WriteLine("   Group {0}: '{1}'", ctr, match.Groups(ctr).Value)
         Dim capCtr As Integer = 0
         For Each capture As Capture In match.Groups(ctr).Captures
            Console.WriteLine("      Capture {0}: '{1}'", capCtr, capture.Value)
            capCtr += 1
         Next
      Next
   End Sub
End Module
' The example displays the following output:
'       Match: 'This is a short sentence.'
'          Group 1: 'sentence.'
'             Capture 0: 'This '
'             Capture 1: 'is '
'             Capture 2: 'a '
'             Capture 3: 'short '
'             Capture 4: 'sentence.'
'          Group 2: 'sentence'
'             Capture 0: 'This'
'             Capture 1: 'is'
'             Capture 2: 'a'
'             Capture 3: 'short'
'             Capture 4: 'sentence'

Definicję wzorca wyrażenia regularnego \b(\w+)\W+)+ wyodrębnia poszczególnych wyrazów z ciągu.The regular expression pattern \b(\w+)\W+)+ extracts individual words from a string. Definicję tego wyrażenia pokazano w poniższej tabeli.It is defined as shown in the following table.

WzorzecPattern OpisDescription
\b Rozpoczyna dopasowanie na granicy wyrazu.Begin the match at a word boundary.
(\w+) Dopasowuje co najmniej jeden znak słowa.Match one or more word characters. Te znaki tworzą razem wyrazu.Together, these characters form a word. Jest to druga grupa przechwytywania.This is the second capturing group.
\W+ Dopasowuje znaki niebędące znakami słowa jeden lub więcej.Match one or more non-word characters.
(\w+)\W+)+ Dopasowuje wzorzec jednego lub więcej znaków słowa, następuje jedna lub więcej niebędące znakami słowa jeden lub więcej razy.Match the pattern of one or more word characters followed by one or more non-word characters one or more times. Jest to pierwsza grupa przechwytywania.This is the first capturing group.

Pierwsza grupa przechwytywania pasuje do każdego wyrazu w zdaniu.The first capturing group matches each word of the sentence. Druga grupa przechwytywania pasuje do każdego wyrazu oraz znaków interpunkcyjnych i odstęp wyrazie.The second capturing group matches each word along with the punctuation and white space that follow the word. Group Obiektu, którego indeks to 2 zawiera informacje dotyczące tekst uwzględniony przez to druga grupa przechwytywania.The Group object whose index is 2 provides information about the text matched by the second capturing group. Kompletny zestaw słów przechwycone przez grupę przechwytywania są dostępne z CaptureCollection obiektu zwróconego przez Group.Captures właściwości.The complete set of words captured by the capturing group are available from the CaptureCollection object returned by the Group.Captures property.

Zobacz takżeSee also