Конструкции группировки в регулярных выраженияхGrouping Constructs in Regular Expressions

Конструкции группирования отображают части выражений регулярных выражений и захватывают части строки входной строки.Grouping constructs delineate the subexpressions of a regular expression and capture the substrings of an input string. Конструкции группирования можно использовать в следующих целях.You can use grouping constructs to do the following:

  • Сопоставление с частью выражения, которая повторяется во входной строке.Match a subexpression that is repeated in the input string.

  • Применение квантификатору к части выражения с несколькими языковыми элементами регулярных выражений.Apply a quantifier to a subexpression that has multiple regular expression language elements. Дополнительные сведения о квантификаторах см. в разделе Quantifiers.For more information about quantifiers, see Quantifiers.

  • Добавление в строку части выражения, которая возвращается методами Regex.Replace и Match.Result .Include a subexpression in the string that is returned by the Regex.Replace and Match.Result methods.

  • Извлечение отдельных частей выражения из свойства Match.Groups и обработка их по отдельности от всего текста.Retrieve individual subexpressions from the Match.Groups property and process them separately from the matched text as a whole.

В следующей таблице перечислены конструкции группирования, поддерживаемые механизмом регулярных выражений .NET, с указанием, выполняют ли они захват выражений.The following table lists the grouping constructs supported by the .NET regular expression engine and indicates whether they are capturing or non-capturing.

Конструкция группированияGrouping construct Захватываемая или незахватываемаяCapturing or noncapturing
Сопоставляемые части выраженияMatched subexpressions ЗахватываемаяCapturing
Именованные сопоставленные части выраженияNamed matched subexpressions ЗахватываемаяCapturing
Сбалансированные определения группыBalancing group definitions ЗахватываемаяCapturing
Незахватываемые группыNoncapturing groups НезахватываемаяNoncapturing
Параметры группыGroup options НезахватываемаяNoncapturing
Утверждения положительного просмотра вперед нулевой шириныZero-width positive lookahead assertions НезахватываемаяNoncapturing
Утверждения отрицательного просмотра вперед нулевой шириныZero-width negative lookahead assertions НезахватываемаяNoncapturing
Утверждения положительного просмотра назад нулевой шириныZero-width positive lookbehind assertions НезахватываемаяNoncapturing
Утверждения отрицательного просмотра назад нулевой шириныZero-width negative lookbehind assertions НезахватываемаяNoncapturing
Невозвращающиеся части выраженияNonbacktracking subexpressions НезахватываемаяNoncapturing

Сведения о группах и объектной модели регулярных выражений см. в разделе Конструкции группирования и объекты регулярных выражений.For information on groups and the regular expression object model, see Grouping constructs and regular expression objects.

Сопоставляемые части выраженияMatched Subexpressions

Следующая конструкция группирования выделяет сопоставленную часть выражения:The following grouping construct captures a matched subexpression:

( часть выражения )( subexpression )

Где часть выражения — любой допустимый шаблон регулярного выражения.where subexpression is any valid regular expression pattern. Выделения, использующие круглые скобки, нумеруются автоматически слева направо в зависимости от порядка открывающих скобок в регулярном выражении, начиная с 1.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. Выделение с нулевым номером — это текст, сопоставленный всем регулярным выражением.The capture that is numbered zero is the text matched by the entire regular expression pattern.

Примечание

По умолчанию языковой элемент (часть выражения) выделяет сопоставленную часть выражения.By default, the (subexpression) language element captures the matched subexpression. Но если параметр RegexOptions метода сопоставления шаблона регулярного выражения содержит флаг RegexOptions.ExplicitCapture или к части выражения применен параметр n (см. Параметры группы далее в этой статье), сопоставленная часть выражения не выделяется.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.

Доступ к захватываемым группам можно получить четырьмя способами:You can access captured groups in four ways:

  • Используя конструкцию обратной ссылки в регулярном выражении.By using the backreference construct within the regular expression. Сопоставленная часть выражения указывается в том же регулярном выражении с помощью синтаксиса \number, где number — это порядковый номер выделенной части выражения.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.

  • Используя именованную конструкцию обратной ссылки в регулярном выражении.By using the named backreference construct within the regular expression. Сопоставленная часть выражения указывается в том же регулярном выражении с помощью синтаксиса \k<name>, где name — это имя захватываемой группы, или \k<number>, где number — это порядковый номер захватываемой группы.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. Имя захватываемой группы по умолчанию совпадает с ее порядковым номером.A capturing group has a default name that is identical to its ordinal number. Дополнительные сведения см. в разделе Именованные сопоставляемые части выражения далее в этой статье.For more information, see Named matched subexpressions later in this topic.

  • Используя последовательность замены $number в вызове метода Regex.Replace или Match.Result , где number — это порядковый номер выделенной части выражения.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.

  • Программным способом, используя объект GroupCollection , возвращаемый свойством Match.Groups .Programmatically, by using the GroupCollection object returned by the Match.Groups property. Член коллекции в нулевой позиции представляет все сопоставление регулярного выражения.The member at position zero in the collection represents the entire regular expression match. Каждый последующий член представляет сопоставленную часть выражения.Each subsequent member represents a matched subexpression. Дополнительные сведения см. в разделе Grouping Constructs and Regular Expression Objects .For more information, see the Grouping Constructs and Regular Expression Objects section.

В следующем примере показано регулярное выражение, которое определяет повторяющиеся слова в тексте.The following example illustrates a regular expression that identifies duplicated words in text. Две захватываемые группы шаблона регулярного выражения представляют два экземпляра повторяющегося слова.The regular expression pattern's two capturing groups represent the two instances of the duplicated word. Второй экземпляр выделяется для определения его начальной позиции во входной строке.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.

Шаблон регулярного выражения выглядит следующим образом:The regular expression pattern is the following:

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

В следующей таблице показано, как интерпретируется шаблон регулярного выражения.The following table shows how the regular expression pattern is interpreted.

ШаблонPattern ОПИСАНИЕDescription
(\w+) Совпадение с одним или несколькими символами слова.Match one or more word characters. Это первая группа записи.This is the first capturing group.
\s Соответствует пробелу.Match a white-space character.
(\1) Сопоставление строки в первой захватываемой группе.Match the string in the first captured group. Это вторая группа записи.This is the second capturing group. Этот пример назначает ее захватываемой группе таким образом, что начальную позицию повторяющегося слова можно извлечь из свойства Match.Index .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 Сопоставление несловообразующего символа, включая пробел и знак пунктуации.Match a non-word character, including white space and punctuation. Это не позволяет шаблону регулярного выражения сопоставить слово, которое начинается со слова из первой захватываемой группы.This prevents the regular expression pattern from matching a word that starts with the word from the first captured group.

Именованные сопоставленные части выраженияNamed Matched Subexpressions

Следующая конструкция группировки выделяет сопоставленную часть выражения и позволяет получить к ней доступ по имени или номеру:The following grouping construct captures a matched subexpression and lets you access it by name or by number:

(?<name>subexpression)

илиor:

(?'name'subexpression)

Где имя — это допустимое имя группы, а часть выражения — любой допустимый шаблон регулярного выражения.where name is a valid group name, and subexpression is any valid regular expression pattern. Параметримя не должен содержать знаки пунктуации и не может начинаться с цифры.name must not contain any punctuation characters and cannot begin with a number.

Примечание

Если параметр RegexOptions метода сопоставления шаблона регулярного выражения содержит флаг RegexOptions.ExplicitCapture или к части выражения применен параметр n (см. Параметры группы далее в этой статье), выделить часть выражения можно только с помощью явного имени захватываемых групп.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.

Доступ к именованным захватываемым группам можно получить следующими способами:You can access named captured groups in the following ways:

  • Используя именованную конструкцию обратной ссылки в регулярном выражении.By using the named backreference construct within the regular expression. Сопоставленная часть выражения указывается в том же регулярном выражении с помощью синтаксиса \k<name>, где name — это имя захватываемой части выражения.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.

  • Используя конструкцию обратной ссылки в регулярном выражении.By using the backreference construct within the regular expression. Сопоставленная часть выражения указывается в том же регулярном выражении с помощью синтаксиса \number, где number — это порядковый номер выделенной части выражения.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. Именованные сопоставленные части выражения нумеруются последовательно слева направо после сопоставленных частей выражения.Named matched subexpressions are numbered consecutively from left to right after matched subexpressions.

  • Используя последовательность замены ${name} в вызове метода Regex.Replace или Match.Result , где name — это имя захватываемой части выражения.By using the ${name} replacement sequence in a Regex.Replace or Match.Result method call, where name is the name of the captured subexpression.

  • Используя последовательность замены $число в вызове метода Regex.Replace или Match.Result, где число обозначает порядковый номер захваченной части выражения.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.

  • Программным способом, используя объект GroupCollection , возвращаемый свойством Match.Groups .Programmatically, by using the GroupCollection object returned by the Match.Groups property. Член коллекции в нулевой позиции представляет все сопоставление регулярного выражения.The member at position zero in the collection represents the entire regular expression match. Каждый последующий член представляет сопоставленную часть выражения.Each subsequent member represents a matched subexpression. Именованные захватываемые группы хранятся в коллекции после нумерованных захватываемых групп.Named captured groups are stored in the collection after numbered captured groups.

  • Программно, передавая имя части выражения индексатору объекта GroupCollection (в C#) или свойству Item[String] (в 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).

В простом шаблоне регулярного выражения показано, как нумерованные (безымянные) и именованные группы можно указывать программно или с помощью языка регулярных выражений.A simple regular expression pattern illustrates how numbered (unnamed) and named groups can be referenced either programmatically or by using regular expression language syntax. Регулярное выражение ((?<One>abc)\d+)?(?<Two>xyz)(.*) формирует следующие захватываемые группы по номеру и имени.The regular expression ((?<One>abc)\d+)?(?<Two>xyz)(.*) produces the following capturing groups by number and by name. Первая захватываемая группа (с номером 0) всегда указывает на весь шаблон.The first capturing group (number 0) always refers to the entire pattern.

numberNumber nameName ШаблонPattern
00 0 (имя по умолчанию)0 (default name) ((?<One>abc)\d+)?(?<Two>xyz)(.*)
11 1 (имя по умолчанию)1 (default name) ((?<One>abc)\d+)
22 2 (имя по умолчанию)2 (default name) (.*)
33 ОдинOne (?<One>abc)
44 ДваTwo (?<Two>xyz)

В следующем примере показано регулярное выражение, которое определяет повторяющиеся слова и слова, которые следуют за каждым повторяющимся словом.The following example illustrates a regular expression that identifies duplicated words and the word that immediately follows each duplicated word. Шаблон регулярного выражения определяет две именованных части выражения: duplicateWord, которая представляет повторяющееся слово, и nextWord, которая представляет слово после повторяющегося слова.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'.

Шаблон регулярного выражения выглядит следующим образом:The regular expression pattern is as follows:

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

В следующей таблице показано, как интерпретируется регулярное выражение.The following table shows how the regular expression is interpreted.

ШаблонPattern ОПИСАНИЕDescription
(?<duplicateWord>\w+) Совпадение с одним или несколькими символами слова.Match one or more word characters. Установка для группы имени duplicateWord.Name this capturing group duplicateWord.
\s Соответствует пробелу.Match a white-space character.
\k<duplicateWord> Сопоставление строки из захватываемой группы с именем duplicateWord.Match the string from the captured group that is named duplicateWord.
\W Сопоставление несловообразующего символа, включая пробел и знак пунктуации.Match a non-word character, including white space and punctuation. Это не позволяет шаблону регулярного выражения сопоставить слово, которое начинается со слова из первой захватываемой группы.This prevents the regular expression pattern from matching a word that starts with the word from the first captured group.
(?<nextWord>\w+) Совпадение с одним или несколькими символами слова.Match one or more word characters. Установка для группы имени nextWord.Name this capturing group nextWord.

Обратите внимание на то, что имя группы может повторяться в регулярном выражении.Note that a group name can be repeated in a regular expression. Например, несколько групп могут называться digit, как показано в примере ниже.For example, it is possible for more than one group to be named digit, as the following example illustrates. В случае повторяющихся имен значение объекта Group определяется последней успешной записью во входной строке.In the case of duplicate names, the value of the Group object is determined by the last successful capture in the input string. Кроме того, коллекция CaptureCollection заполняется сведениями о каждой записи так же, как и в случае, когда имя группы не повторяется.In addition, the CaptureCollection is populated with information about each capture just as it would be if the group name was not duplicated.

В примере ниже регулярное выражение \D+(?<digit>\d+)\D+(?<digit>\d+)? включает два вхождения группы с именем digit.In the following example, the regular expression \D+(?<digit>\d+)\D+(?<digit>\d+)? includes two occurrences of a group named digit. Первая группа с именем digit записывает одну или несколько цифр.The first digit named group captures one or more digit characters. Вторая группа с именем digit записывает нуль или одно вхождение одной или нескольких цифр.The second digit named group captures either zero or one occurrence of one or more digit characters. Как видно из выходных данных примера, если вторая захватывающая группа соответствует тексту, этот текст определяет значение объекта Group .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. Если вторая захватывающая группа не соответствует входной строке, значение последнего успешного сопоставления определяет значение объекта Group .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

В следующей таблице показано, как интерпретируется регулярное выражение.The following table shows how the regular expression is interpreted.

ШаблонPattern ОПИСАНИЕDescription
\D+ Совпадение с одной или несколькими недесятичными цифрами.Match one or more non-decimal digit characters.
(?<digit>\d+) Совпадение с одной или несколькими десятичными цифрами.Match one or more decimal digit characters. Назначение соответствия для группы с именем digit.Assign the match to the digit named group.
\D+ Совпадение с одной или несколькими недесятичными цифрами.Match one or more non-decimal digit characters.
(?<digit>\d+)? Совпадение с нулем или одним вхождением одной или нескольких десятичных цифр.Match zero or one occurrence of one or more decimal digit characters. Назначение соответствия для группы с именем digit .Assign the match to the digit named group.

Сбалансированные определения группыBalancing Group Definitions

Сбалансированное определение группы удаляет определение ранее заданной группы и сохраняет в текущей группе интервал между предыдущей и текущей группами.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. Конструкция группировки использует следующий формат:This grouping construct has the following format:

(?<name1-name2>subexpression)

илиor:

(?'name1-name2' subexpression)

Где name1 — текущая группа (необязательный параметр), name2 — ранее заданная группа, а subexpression — любой допустимый шаблон регулярного выражения.where name1 is the current group (optional), name2 is a previously defined group, and subexpression is any valid regular expression pattern. Это сбалансированное определение группы удаляет определение name2 и сохраняет интервал между name2 и name1 в name1.The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. Если группа name2 не определена, для соответствия выполняется обратный поиск.If no name2 group is defined, the match backtracks. Так как удаление последнего определения name2 предоставляет доступ к предыдущему определению name2, эта конструкция позволяет использовать стек выделений для группы name2 в качестве счетчика вложенный конструкций, например круглых скобок или открывающих и закрывающих квадратных скобок.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.

Сбалансированное определение группы использует в качестве стека name2 .The balancing group definition uses name2 as a stack. Начальный символ каждой вложенной конструкции размещается в группе и в коллекции Group.Captures .The beginning character of each nested construct is placed in the group and in its Group.Captures collection. При сопоставлении закрывающего символа соответствующий открывающий символ удаляется из группы, а коллекция Captures уменьшается на один элемент.When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. После сопоставления открывающих и закрывающих символов всех вложенных конструкций, группа name2 оказывается пустой.After the opening and closing characters of all nested constructs have been matched, name2 is empty.

Примечание

Если изменить регулярное выражение в следующем примере для использования соответствующего открывающего и закрывающего символа вложенной конструкции, вы сможете использовать его для обработки большинства вложенных конструкций, таких как математические выражения или строки программного кода, которые могут содержать множества вложенных вызовов методов.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.

В следующем примере сбалансированное определение группы используется для сопоставления левой и правой угловой скобки (<>) во входной строке.The following example uses a balancing group definition to match left and right angle brackets (<>) in an input string. В примере определены две именованные группы, Open и Close, которые используются как стек для отслеживания соответствующих пар угловых скобок.The example defines two named groups, Open and Close, that are used like a stack to track matching pairs of angle brackets. Каждая выделенная левая угловая скобка помещается в коллекцию группы Open , а каждая выделенная правая угловая скобка помещается в коллекцию группы Close .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. Сбалансированное определение группы позволяет убедиться, что для каждой левой угловой скобки существует соответствующая правая угловая скобка.The balancing group definition ensures that there is a matching right angle bracket for each left angle bracket. В противном случае последний подшаблон, (?(Open)(?!)), вычисляется, только если группа Open не пуста (следовательно, все вложенные конструкции не закрыты).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). Если последний подшаблон вычисляется, сопоставление вызывает ошибку, так как подшаблон (?!) является утверждением отрицательного поиска вперед нулевой ширины, которое всегда возвращает ошибку.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>

Шаблон регулярного выражения выглядит следующим образом:The regular expression pattern is:

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

Регулярное выражение интерпретируется следующим образом:The regular expression is interpreted as follows:

ШаблонPattern ОПИСАНИЕDescription
^ Начало с первого символа строки.Begin at the start of the string.
[^<>]* Сопоставление нуля или большего числа символов, которые не являются правой или левой угловой скобкой.Match zero or more characters that are not left or right angle brackets.
(?'Open'<) Сопоставление левой угловой скобки и ее назначение группе Open.Match a left angle bracket and assign it to a group named Open.
[^<>]* Сопоставление нуля или большего числа символов, которые не являются правой или левой угловой скобкой.Match zero or more characters that are not left or right angle brackets.
((?'Open'<)[^<>]*)+ Сопоставление одного или нескольких вхождений левой угловой скобки, за которой следует ноль или больше символов, не являющихся левой или правой угловой скобкой.Match one or more occurrences of a left angle bracket followed by zero or more characters that are not left or right angle brackets. Это вторая группа записи.This is the second capturing group.
(?'Close-Open'>) Сопоставление правой угловой скобки, назначение подстроки между группой Open и текущей группой группе Close и удаление определения группы Open .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.
[^<>]* Сопоставление нуля или большего числа вхождений любого символа, не являющегося левой или правой угловой скобкой.Match zero or more occurrences of any character that is neither a left nor a right angle bracket.
((?'Close-Open'>)[^<>]*)+ Сопоставление одного или нескольких вхождений правой угловой скобки, за которой следует ноль или больше символов, не являющихся левой или правой угловой скобкой.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. При сопоставлении правой угловой скобки подстрока между группой Open и текущей группой назначается группе Close , а определение группы Open удаляется.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. Это третья группа записи.This is the third capturing group.
(((?'Open'<)[^<>]*)+((?'Close-Open'>)[^<>]*)+)* Сопоставление нуля или большего числа вхождений следующего шаблона: одно или несколько вхождений левой угловой скобки, за которой следуют ноль или большее число символов, отличных от угловых скобок, одно или несколько вхождений правой угловой скобки и ноль или большее число символов, отличных от угловых скобок.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. При сопоставлении правой угловой скобки определение группы Open удаляется, а подстрока между группой Open и текущей группой назначается группе Close .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. Это первая группа записи.This is the first capturing group.
(?(Open)(?!)) Если группа Open существует, поиск совпадения прекращается, если возможно сопоставление пустой строки, но позиция механизма регулярных выражений в строке не изменяется.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. Это утверждение отрицательного просмотра вперед нулевой ширины.This is a zero-width negative lookahead assertion. Так как пустая строка всегда неявно присутствует во входной строке, это сопоставление всегда возвращает ошибку.Because an empty string is always implicitly present in an input string, this match always fails. Ошибка этого сопоставления указывает на то, что угловые скобки не сбалансированы.Failure of this match indicates that the angle brackets are not balanced.
$ Соответствует концу входной строки.Match the end of the input string.

Последняя часть выражения, (?(Open)(?!)), указывает, правильно ли сбалансированы вложенные конструкции во входной строке (например, существует ли для каждой левой угловой скобки соответствующая правая угловая скобка).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). В ней используется условное сопоставление на основе действительной захватываемой группы. Дополнительные сведения см. в разделе Alternation Constructs.It uses conditional matching based on a valid captured group; for more information, see Alternation Constructs. Если группа Open определена, механизм регулярных выражений пытается сопоставить часть выражения (?!) во входной строке.If the Open group is defined, the regular expression engine attempts to match the subexpression (?!) in the input string. Группа Open должна быть определена, только если вложенные конструкции не сбалансированы.The Open group should be defined only if nesting constructs are unbalanced. Поэтому шаблон для сопоставления во входной строке должен всегда вызывать ошибку соответствия.Therefore, the pattern to be matched in the input string should be one that always causes the match to fail. В этом случае (?!) — это утверждение отрицательного просмотра вперед нулевой ширины, которое всегда вызывает ошибку, так как пустая строка всегда неявно присутствует в следующей позиции во входной строке.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.

В этом примере механизм регулярных выражений обрабатывает входную строку "<abc><mno<xyz>>" так, как показано в следующей таблице.In the example, the regular expression engine evaluates the input string "<abc><mno<xyz>>" as shown in the following table.

ШагStep ШаблонPattern РезультатResult
11 ^ Начало соответствия в начале входной строки.Starts the match at the beginning of the input string
22 [^<>]* Поиск символов, отличных от угловых скобок, до левой угловой скобки. Совпадения не найдены.Looks for non-angle bracket characters before the left angle bracket;finds no matches.
33 (((?'Open'<) Сопоставляет левую угловую скобку в строке "<abc>" и присваивает ее группе Open.Matches the left angle bracket in "<abc>" and assigns it to the Open group.
44 [^<>]* Сопоставляется строка "abc".Matches "abc".
55 )+ "<abc" — это значение второй захватываемой группы."<abc" is the value of the second captured group.

Следующий символ во входной строке не является левой угловой скобкой, поэтому механизм регулярных выражений не возвращается к подшаблону (?'Open'<)[^<>]*) .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'>) Сопоставляет правую угловую скобку в "<abc<" и назначает подстроку "abc", расположенную между группой Open и правой угловой скобкой, группе записи Close, а также удаляет текущее значение ("<") из группы записи Open, которая теперь становится пустой.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 [^<>]* Поиск символов, отличных от угловых скобок, после правой угловой скобки. Совпадения не найдены.Looks for non-angle bracket characters after the right angle bracket; finds no matches.
88 )+ Значение третьей захватываемой группы — ">".The value of the third captured group is ">".

Следующий символ во входной строке не является правой угловой скобкой, поэтому механизм регулярных выражений не возвращается к подшаблону ((?'Close-Open'>)[^<>]*) .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 )* Первой группе записи присвоено значение "<abc>".The value of the first captured group is "<abc>".

Следующий символ во входной строке является левой угловой скобкой, поэтому механизм регулярных выражений возвращается к подшаблону (((?'Open'<) .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'<) Сопоставляет левую угловую скобку в строке "<mno" и назначает ее группе Open.Matches the left angle bracket in "<mno" and assigns it to the Open group. Теперь ее коллекция Group.Captures содержит один символ, "<".Its Group.Captures collection now has a single value, "<".
1111 [^<>]* Сопоставляется подстрока "mno".Matches "mno".
1212 )+ "<mno" — это значение второй захватываемой группы."<mno" is the value of the second captured group.

Следующий символ во входной строке является левой угловой скобкой, поэтому механизм регулярных выражений возвращается к подшаблону (?'Open'<)[^<>]*) .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'<) Сопоставляет левую угловую скобку в строке "<xyz>" и назначает ее группе Open.Matches the left angle bracket in "<xyz>" and assigns it to the Open group. Коллекция Group.Captures группы записи Open теперь содержит два захвата: левую угловую скобку из "<mno" и левую угловую скобку из "<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 [^<>]* Сопоставляется подстрока "xyz".Matches "xyz".
1515 )+ "<xyz" — это значение второй захватываемой группы."<xyz" is the value of the second captured group.

Следующий символ во входной строке не является левой угловой скобкой, поэтому механизм регулярных выражений не возвращается к подшаблону (?'Open'<)[^<>]*) .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'>) Сопоставляет правую угловую скобку в строке "<xyz>".Matches the right angle bracket in "<xyz>". "xyz" задает подстроку между группой Open и правой угловой скобкой группы Close и удаляет текущее значение группы Open ."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. Значение предыдущего захвата (левая угловая скобка из "<mno") становится текущим значением группы Open.The value of the previous capture (the left angle bracket in "<mno") becomes the current value of the Open group. Коллекция Captures группы Open теперь содержит один символ: левую угловую скобку из "<xyz>".The Captures collection of the Open group now includes a single capture, the left angle bracket from "<xyz>".
1717 [^<>]* Поиск символов, отличных от угловых скобок. Совпадения не найдены.Looks for non-angle bracket characters; finds no matches.
1818 )+ Значение третьей захватываемой группы — ">".The value of the third captured group is ">".

Следующий символ во входной строке является правой угловой скобкой, поэтому механизм регулярных выражений возвращается к подшаблону ((?'Close-Open'>)[^<>]*) .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'>) Сопоставляет последнюю правую угловую скобку в "xyz>>" и назначает подстроку "mno<xyz>", которая располагается между группой Open и правой угловой скобкой, группе Close, а также удаляет текущее значение группы Open.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 пуста.The Open group is now empty.
2020 [^<>]* Поиск символов, отличных от угловых скобок. Совпадения не найдены.Looks for non-angle bracket characters; finds no matches.
2121 )+ Значение третьей захватываемой группы — ">".The value of the third captured group is ">".

Следующий символ во входной строке не является правой угловой скобкой, поэтому механизм регулярных выражений не возвращается к подшаблону ((?'Close-Open'>)[^<>]*) .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 )* Присваивает первой группе записи значение "<mno<xyz>>".The value of the first captured group is "<mno<xyz>>".

Следующий символ во входной строке не является левой угловой скобкой, поэтому механизм регулярных выражений не возвращается к подшаблону (((?'Open'<) .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 не определена, поиск соответствий не выполняется.The Open group is not defined, so no match is attempted.
2424 $ Сопоставление конца входной строки.Matches the end of the input string.

Незахватываемые группыNoncapturing Groups

Следующая конструкция группировки не захватывает подстроку, сопоставленную частью выражения:The following grouping construct does not capture the substring that is matched by a subexpression:

(?:subexpression)

Где часть выражения — любой допустимый шаблон регулярного выражения.where subexpression is any valid regular expression pattern. Незахватываемая конструкция группировки обычно используется, если к группе применяется квантификатор, но подстроки, выделенные группой, не представляют интереса.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.

Примечание

Если регулярное выражение содержит вложенные конструкции группировки, внешняя незахватываемая конструкция группировки не применяется к внутренним вложенным конструкциям группировки.If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs.

В следующем примере показано регулярное выражение, содержащее незахватываемые группы.The following example illustrates a regular expression that includes noncapturing groups. Обратите внимание, что результат не содержит захватываемые группы.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.

Регулярное выражение (?:\b(?:\w+)\W*)+\. сопоставляет предложение, которое заканчивается точкой.The regular expression (?:\b(?:\w+)\W*)+\. matches a sentence that is terminated by a period. Так как оно ищет предложения, а не отдельные слова, конструкции группировки используются только как квантификаторы.Because the regular expression focuses on sentences and not on individual words, grouping constructs are used exclusively as quantifiers. Возможные интерпретации шаблона регулярного выражения показаны в следующей таблице.The regular expression pattern is interpreted as shown in the following table.

ШаблонPattern ОПИСАНИЕDescription
\b Совпадение должно начинаться на границе слова.Begin the match at a word boundary.
(?:\w+) Совпадение с одним или несколькими символами слова.Match one or more word characters. Сопоставленные текст не назначается захватываемой группе.Do not assign the matched text to a captured group.
\W* Совпадение с нулем или большим числом несловообразующих символов.Match zero or more non-word characters.
(?:\b(?:\w+)\W*)+ Совпадение шаблона с одним или несколькими словообразующими символами начиная с границы слова, за которыми следует ноль и более несловообразующих символов, один или более раз.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. Сопоставленные текст не назначается захватываемой группе.Do not assign the matched text to a captured group.
\. Сопоставляется точка.Match a period.

Параметры группыGroup Options

Следующая конструкция группировки применяет или отключает указанные параметры в части выражения:The following grouping construct applies or disables the specified options within a subexpression:

(?imnsx-imnsx: часть выражения )(?imnsx-imnsx: subexpression )

Где часть выражения — любой допустимый шаблон регулярного выражения.where subexpression is any valid regular expression pattern. Например, (?i-s:) отключает учет регистра и однострочный режим.For example, (?i-s:) turns on case insensitivity and disables single-line mode. Дополнительные сведения о доступных встроенных параметрах см. в разделе Параметры регулярных выражений.For more information about the inline options you can specify, see Regular Expression Options.

Примечание

Вы можете указать параметры, которые применяются ко всему регулярному выражению, а не его части, используя конструктор класса System.Text.RegularExpressions.Regex или статичный метод.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. Также можно указать встроенные параметры, которые применяются после определенной точки в регулярном выражении с использованием языковой конструкции (?imnsx-imnsx) .You can also specify inline options that apply after a specific point in a regular expression by using the (?imnsx-imnsx) language construct.

Конструкция параметров группы не является захватываемой группой.The group options construct is not a capturing group. Это значит, что несмотря на то, что любая часть строки, захватываемая частью выражения , включается в соответствие, она не добавляется в захватываемую группу и не используется для заполнения объекта GroupCollection .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.

Например, регулярное выражение \b(?ix: d \w+)\s в следующем примере использует встроенные параметры в конструкции группировки, чтобы включить сопоставление без учета регистра и игнорировать пробелы при определении слов, начинающихся с буквы "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". Определение регулярного выражения показано в следующей таблице.The regular expression is defined as shown in the following table.

ШаблонPattern ОПИСАНИЕDescription
\b Совпадение должно начинаться на границе слова.Begin the match at a word boundary.
(?ix: d \w+) Выполняется сопоставление буквы "d", за которой следует один или более словообразующих символов без учета регистра, пробелы в шаблоне пропускаются.Using case-insensitive matching and ignoring white space in this pattern, match a "d" followed by one or more word characters.
\s Соответствует пробелу.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.      

Утверждения положительного просмотра вперед нулевой шириныZero-Width Positive Lookahead Assertions

Следующая конструкция группировки определяет утверждение положительного просмотра вперед нулевой ширины:The following grouping construct defines a zero-width positive lookahead assertion:

(?= часть выражения )(?= subexpression )

Где часть выражения — любой шаблон регулярного выражения.where subexpression is any regular expression pattern. Для успешного сопоставления входная строка должна соответствовать шаблону регулярного выражения в части выражения, хотя сопоставленная подстрока не включается в результат сопоставления.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. Утверждение положительного просмотра вперед нулевой ширины не выполняет обратный поиск.A zero-width positive lookahead assertion does not backtrack.

Обычно утверждение положительного просмотра вперед нулевой ширины находится в конце шаблона регулярного выражения.Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. Оно определяет подстроку, которую необходимо найти в конце строки для сопоставления, но которая не включается в сопоставление.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. Это также полезно для предотвращения излишнего обратного поиска.It is also useful for preventing excessive backtracking. Утверждение положительного просмотра вперед нулевой ширины можно использовать, чтобы определенная захватываемая группа начиналась с текста, соответствующего подмножеству шаблона, заданного для этой группы.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. Например, если захватываемая группа соответствует последовательным словообразующим символом, вы можете использовать утверждение положительного просмотра вперед нулевой ширины, чтобы указать, что первый символ должен быть прописной буквой.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.

Следующий пример использует утверждение положительного просмотра вперед нулевой ширины для сопоставления слова, которое идет перед глаголом "is" во входной строке.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'.

Возможные интерпретации регулярного выражения \b\w+(?=\sis\b) показаны в следующей таблице.The regular expression \b\w+(?=\sis\b) is interpreted as shown in the following table.

ШаблонPattern ОПИСАНИЕDescription
\b Совпадение должно начинаться на границе слова.Begin the match at a word boundary.
\w+ Совпадение с одним или несколькими символами слова.Match one or more word characters.
(?=\sis\b) Определяется, следуют ли за словообразующими словами пробел и строка "is", которая оканчивается на границе слова.Determine whether the word characters are followed by a white-space character and the string "is", which ends on a word boundary. Если это так, совпадение успешно.If so, the match is successful.

Утверждения отрицательного просмотра вперед нулевой шириныZero-Width Negative Lookahead Assertions

Следующая конструкция группировки определяет утверждение отрицательного просмотра вперед нулевой ширины:The following grouping construct defines a zero-width negative lookahead assertion:

(?! часть выражения )(?! subexpression )

Где часть выражения — любой шаблон регулярного выражения.where subexpression is any regular expression pattern. Для успешного сопоставления входная строка не должна соответствовать шаблону регулярного выражения в части выражения, хотя сопоставленная подстрока не включается в результат сопоставления.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.

Утверждение отрицательного просмотра вперед нулевой ширины обычно используется в начале или в конце регулярного выражения.A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. В начале регулярного выражения оно может определить шаблон, для которого не должно быть совпадения, когда в начале регулярного выражения определен похожий, но более общий шаблон для сопоставления.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. В этом случае утверждение часто используется для ограничения обратного поиска.In this case, it is often used to limit backtracking. В конце регулярного выражения утверждение может определять часть выражения, которое не должно присутствовать в конце совпадения.At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match.

В следующем примере определяется регулярное выражение, использующее утверждение просмотра вперед нулевой ширины в начале регулярного выражения для сопоставления слов, которые не начинаются на "un".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

Возможные интерпретации регулярного выражения \b(?!un)\w+\b показаны в следующей таблице.The regular expression \b(?!un)\w+\b is interpreted as shown in the following table.

ШаблонPattern ОПИСАНИЕDescription
\b Совпадение должно начинаться на границе слова.Begin the match at a word boundary.
(?!un) Определяется, являются ли два следующих символа "un".Determine whether the next two characters are "un". Если это не так, сопоставление возможно.If they are not, a match is possible.
\w+ Совпадение с одним или несколькими символами слова.Match one or more word characters.
\b Совпадение должно заканчиваться на границе слова.End the match at a word boundary.

В следующем примере определяется регулярное выражение, использующее утверждение просмотра вперед нулевой ширины в конце регулярного выражения для сопоставления слов, которые не начинаются на знак пунктуации.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

Возможные интерпретации регулярного выражения \b\w+\b(?!\p{P}) показаны в следующей таблице.The regular expression \b\w+\b(?!\p{P}) is interpreted as shown in the following table.

ШаблонPattern ОПИСАНИЕDescription
\b Совпадение должно начинаться на границе слова.Begin the match at a word boundary.
\w+ Совпадение с одним или несколькими символами слова.Match one or more word characters.
\b Совпадение должно заканчиваться на границе слова.End the match at a word boundary.
\p{P}) Если следующий символ — не знак пунктуации (например, точка или запятая), сопоставление выполняется успешно.If the next character is not a punctuation symbol (such as a period or a comma), the match succeeds.

Утверждения положительного просмотра назад нулевой шириныZero-Width Positive Lookbehind Assertions

Следующая конструкция группировки определяет утверждение положительного просмотра назад нулевой ширины:The following grouping construct defines a zero-width positive lookbehind assertion:

(?<= часть выражения )(?<= subexpression )

Где часть выражения — любой шаблон регулярного выражения.where subexpression is any regular expression pattern. Для успешного сопоставления часть выражения должна содержаться во входной строке слева от текущей позиции, хотя subexpression не включается в результат.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. Утверждение положительного просмотра назад нулевой ширины не выполняет обратный поиск.A zero-width positive lookbehind assertion does not backtrack.

Утверждения положительного просмотра назад нулевой ширины обычно используются в начале регулярных выражений.Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. Определяемый ими шаблон — это предварительное условие сопоставления, но не часть результата сопоставления.The pattern that they define is a precondition for a match, although it is not a part of the match result.

Например, следующий пример сопоставляет две последних цифры года для 21-го века (т. е. сопоставляемой строке должны предшествовать цифры "20").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

Возможные интерпретации шаблона регулярного выражения (?<=\b20)\d{2}\b показаны в следующей таблице.The regular expression pattern (?<=\b20)\d{2}\b is interpreted as shown in the following table.

ШаблонPattern ОПИСАНИЕDescription
\d{2} Совпадение с двумя десятичными цифрами.Match two decimal digits.
(?<=\b20) Сопоставление продолжается, если двум десятичным цифрам предшествуют десятичные цифры "20" на границе слова.Continue the match if the two decimal digits are preceded by the decimal digits "20" on a word boundary.
\b Совпадение должно заканчиваться на границе слова.End the match at a word boundary.

Утверждения положительного просмотра назад нулевой ширины также используются для ограничения обратного поиска, если последний символ или символы в захватываемой группе должны быть подмножеством символов, соответствующих шаблону регулярного выражения.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. Например, если группа захватывает все последовательные словообразующие символы, вы можете использовать утверждение положительного просмотра назад нулевой ширины, чтобы указать, что последний символ должен быть буквой.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.

Утверждения отрицательного просмотра назад нулевой шириныZero-Width Negative Lookbehind Assertions

Следующая конструкция группировки определяет утверждение отрицательного просмотра назад нулевой ширины:The following grouping construct defines a zero-width negative lookbehind assertion:

(?<! часть выражения )(?<! subexpression )

Где часть выражения — любой шаблон регулярного выражения.where subexpression is any regular expression pattern. Для успешного сопоставления часть выражения не должна находиться во входной строке слева от текущей позиции.For a match to be successful, subexpression must not occur at the input string to the left of the current position. Однако любая подстрока, не соответствующая subexpression , не включается в результат сопоставления.However, any substring that does not match subexpression is not included in the match result.

Утверждения отрицательного просмотра назад нулевой ширины обычно используются в начале регулярных выражений.Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. Определяемый ими шаблон препятствует сопоставлению в последующей строке.The pattern that they define precludes a match in the string that follows. Они также используются для ограничения обратного поиска, если последний символ или символы в захватываемой группе не должны соответствовать одному или нескольким символам, соответствующим шаблону регулярного выражения группы.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. Например, если группа захватывает все последовательные словообразующие символы, вы можете использовать утверждение положительного просмотра назад нулевой ширины, чтобы указать, что последний символ не должен быть символом подчеркивания (_).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 (_).

Следующий пример сопоставляет дату каждого дня буднего недели (т. е. не субботы или воскресенья).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

Возможные интерпретации шаблона регулярного выражения (?<!(Saturday|Sunday) )\b\w+ \d{1,2}, \d{4}\b показаны в следующей таблице.The regular expression pattern (?<!(Saturday|Sunday) )\b\w+ \d{1,2}, \d{4}\b is interpreted as shown in the following table.

ШаблонPattern ОПИСАНИЕDescription
\b Совпадение должно начинаться на границе слова.Begin the match at a word boundary.
\w+ Сопоставляется один или несколько словообразующих символов, за которыми следует пробел.Match one or more word characters followed by a white-space character.
\d{1,2}, Сопоставляется одна или две десятичные цифры, за которыми следует пробел и запятая.Match either one or two decimal digits followed by a white-space character and a comma.
\d{4}\b Сопоставляются 4 десятичные цифры, сопоставление прекращается на границе слова.Match four decimal digits, and end the match at a word boundary.
(?<!(Saturday|Sunday) ) Если сопоставлению предшествуют строки, отличные от "Saturday" или "Sunday", за которыми следует пробел, сопоставление выполняется успешно.If the match is preceded by something other than the strings "Saturday" or "Sunday" followed by a space, the match is successful.

Невозвращающиеся части выраженияNonbacktracking Subexpressions

Следующая конструкция группировки представляет невозвращающуюся часть выражения (так называемую "жадную" часть выражения):The following grouping construct represents a nonbacktracking subexpression (also known as a "greedy" subexpression):

(?> часть выражения )(?> subexpression )

Где часть выражения — любой шаблон регулярного выражения.where subexpression is any regular expression pattern.

Обычно, если регулярное выражение содержит необязательный или альтернативный шаблон сопоставления, а сопоставление завершается неудачно, механизм регулярных выражений может разветвляться по разным направлениям для сопоставления входной строки с шаблоном.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. Если сопоставление не найдено в первой ветви, механизм регулярных выражений может вернуться к точке, где было найдено первое сопоставление и повторить попытку во второй ветви.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. Этот процесс может продолжаться, пока не будут обойдены все ветви.This process can continue until all branches have been tried.

Группа (?>часть выражения) отключает обратное отслеживание.The (?>subexpression) language construct disables backtracking. Механизм регулярных выражений сопоставляет максимально возможное число символов во входной строке.The regular expression engine will match as many characters in the input string as it can. Если дальнейшее сопоставление невозможно, обратный поиск для применения альтернативных шаблонов не выполняется.When no further match is possible, it will not backtrack to attempt alternate pattern matches. (Т. е. часть выражения сопоставляет только строки, которые могут быть сопоставлены только частью выражения, попытка сопоставить строку на основе этой и последующих частей выражения не осуществляется.)(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.)

Этот вариант рекомендуется, если вы знаете, что обратный поиск не даст результатов.This option is recommended if you know that backtracking will not succeed. Если запретить механизму регулярных выражений выполнять ненужные операции поиска, производительность станет выше.Preventing the regular expression engine from performing unnecessary searching improves performance.

В следующем примере показано, как невозвращающаяся часть выражения изменяет результаты сопоставления шаблона.The following example illustrates how a nonbacktracking subexpression modifies the results of a pattern match. Возвращающееся регулярное выражение успешно сопоставляет ряд повторяющихся символов, за которыми следует один или более экземпляров того же символа на границе слова, а невозвращающееся регулярное выражение — нет.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

Определение невозвращающегося регулярного выражения (?>(\w)\1+).\b показано в следующей таблице.The nonbacktracking regular expression (?>(\w)\1+).\b is defined as shown in the following table.

ШаблонPattern ОПИСАНИЕDescription
(\w) Сопоставляется один словообразующий символ, который назначается первой захватываемой группе.Match a single word character and assign it to the first capturing group.
\1+ Значение первой захваченной подстроки сопоставляется один или несколько раз.Match the value of the first captured substring one or more times.
. Сопоставляется любой символ.Match any character.
\b Сопоставление заканчивается на границе слова.End the match on a word boundary.
(?>(\w)\1+) Сопоставляется один или несколько экземпляров повторяющегося словообразующего слова, но обратный поиск для сопоставления последнего символа на границе слова не выполняется.Match one or more occurrences of a duplicated word character, but do not backtrack to match the last character on a word boundary.

Конструкции группирования и объекты регулярных выраженийGrouping Constructs and Regular Expression Objects

Подстроки, сопоставляемые захватываемой группой регулярного выражения, представлены объектами System.Text.RegularExpressions.Group , которые можно извлечь из объекта System.Text.RegularExpressions.GroupCollection , возвращаемого свойством Match.Groups .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 заполняется следующим образом:The GroupCollection object is populated as follows:

  • Первый объект Group в коллекции (объект с нулевым индексом) представляет все сопоставление.The first Group object in the collection (the object at index zero) represents the entire match.

  • Следующий набор объектов Group представляет неименованные (нумерованные) захватываемые группы.The next set of Group objects represent unnamed (numbered) capturing groups. Они указываются в том порядке, в котором они определены в регулярном выражении, слева направо.They appear in the order in which they are defined in the regular expression, from left to right. Значения индекса этих групп лежат в диапазоне от 1 до числа неименованных захватываемых групп в коллекции.The index values of these groups range from 1 to the number of unnamed capturing groups in the collection. (Индекс определенной группы эквивалентен нумерованной обратной ссылке.(The index of a particular group is equivalent to its numbered backreference. Дополнительные сведения об обратных ссылках см. в разделе Backreference Constructs.)For more information about backreferences, see Backreference Constructs.)

  • Последний набор объектов Group представляет именованные захватываемые группы.The final set of Group objects represent named capturing groups. Они указываются в том порядке, в котором они определены в регулярном выражении, слева направо.They appear in the order in which they are defined in the regular expression, from left to right. Значение индекса первой именованной захватываемой группы на единицу больше индекса, последней неименованной захватываемой группы.The index value of the first named capturing group is one greater than the index of the last unnamed capturing group. Если в регулярном выражении нет неименованных захватываемых групп, индекс первой именованной захватываемой группы равен единице.If there are no unnamed capturing groups in the regular expression, the index value of the first named capturing group is one.

Если к захватываемой группе применяется квантификатор, соответствующие свойства Group , Capture.Valueи Capture.Indexобъекта Capture.Length отражают последнюю подстроку, выделяемую захватываемой группой.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. Вы можете получить полный набор подстрок, выделяемые группами с квантификаторами, из объекта CaptureCollection , возвращаемого свойством Group.Captures .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.

В следующем примере показана связь между объектами Group и Capture .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'

Шаблон регулярного выражения (\b(\w+)\W+)+ извлекает отдельные слова из строки.The regular expression pattern (\b(\w+)\W+)+ extracts individual words from a string. Определяется, как показано в следующей таблице.It is defined as shown in the following table.

ШаблонPattern ОПИСАНИЕDescription
\b Совпадение должно начинаться на границе слова.Begin the match at a word boundary.
(\w+) Совпадение с одним или несколькими символами слова.Match one or more word characters. Вместе эти символы формируют слово.Together, these characters form a word. Это вторая группа записи.This is the second capturing group.
\W+ Совпадение с одним или большим числом несловообразующих символов.Match one or more non-word characters.
(\b(\w+)\W+) Шаблон из одного или нескольких словообразующих символов, за которыми следует ноль или несколько словообразующих слов, выделяется один или несколько раз.Match the pattern of one or more word characters followed by one or more non-word characters one or more times. Это первая группа записи.This is the first capturing group.

Вторая группа сопоставляет каждое слово предложения.The second capturing group matches each word of the sentence. Первая группа сопоставляет каждое слово вместе со знаками пунктуации и пробелом после слова.The first capturing group matches each word along with the punctuation and white space that follow the word. Объект Group с индексом 2 предоставляет сведения о тексте, сопоставленном второй группой.The Group object whose index is 2 provides information about the text matched by the second capturing group. Полный набор слов, выделенных захватываемой группой, доступен в объекте CaptureCollection , который возвращается свойством Group.Captures .The complete set of words captured by the capturing group are available from the CaptureCollection object returned by the Group.Captures property.

См. такжеSee also