正規表現でのグループ化構成体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 )( 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. 番号が 0 になるキャプチャは、正規表現パターン全体と一致するテキストです。The capture that is numbered zero is the text matched by the entire regular expression pattern.

注意

既定では、 (subexpression) 言語要素が、一致する部分式をキャプチャします。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.

キャプチャされたグループにアクセスする方法は 4 つあります。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. コレクション内の位置 0 にあるメンバーは、正規表現に一致した文字列全体を表します。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. 正規表現パターンの 2 つのキャプチャ グループは、2 つの重複する単語を表します。The regular expression pattern's two capturing groups represent the two instances of the duplicated word. 2 番目の単語は、入力文字列内の開始位置を報告するためにキャプチャされます。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+) 1 つ以上の単語文字に一致します。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. これが 2 番目のキャプチャ グループです。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)  

ここで、 name は有効なグループ名、 subexpression は有効な正規表現パターンです。where name is a valid group name, and subexpression is any valid regular expression pattern. name は区切り記号を含まず、先頭が数字以外である必要があります。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.

  • $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. コレクション内の位置 0 にあるメンバーは、正規表現に一致した文字列全体を表します。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 1One (?<One>abc)
44 2Two (?<Two>xyz)

次の例は、重複している単語、および重複している各単語の直後にある単語を識別する正規表現を示しています。The following example illustrates a regular expression that identifies duplicated words and the word that immediately follows each duplicated word. この正規表現パターンでは、重複している単語を表す duplicateWordと重複している単語の後にある単語を表す nextWordの 2 つの名前付き部分式を定義しています。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+) 1 つ以上の単語文字に一致します。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+) 1 つ以上の単語文字に一致します。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という名前のグループの 2 回の出現が含まれています。In the following example, the regular expression \D+(?<digit>\d+)\D+(?<digit>\d+)? includes two occurrences of a group named digit. 最初の digit という名前のグループは、1 桁以上の数字をキャプチャします。The first digit named group captures one or more digit characters. 2 番目の digit という名前のグループは、1 桁以上の数字の 0 回か 1 回の出現をキャプチャします。The second digit named group captures either zero or one occurrence of one or more digit characters. 例の出力が示すように、2 番目のキャプチャ グループがテキストと正常に一致する場合、そのテキストの値は 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. 2 番目のキャプチャ グループが入力文字列と一致しない場合、最後に成功した一致の値によって 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+ 1 個以上の 10 進数以外の文字と一致します。Match one or more non-decimal digit characters.
(?<digit>\d+) 1 個以上の 10 進数の文字と一致します。Match one or more decimal digit characters. 一致を digit という名前のグループに割り当てます。Assign the match to the digit named group.
\D+ 1 個以上の 10 進数以外の文字と一致します。Match one or more non-decimal digit characters.
(?<digit>\d+)? 1 つ以上の 10 進数の文字の 0 回または 1 回の出現と一致します。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 の定義を削除し、 name2name1 の間隔を 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 コレクションが 1 つ減らされます。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という 2 つの名前付きグループを定義しています。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.
[^<>]* 左または右の山かっこではない 0 個以上の文字と一致します。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.
[^<>]* 左または右の山かっこではない 0 個以上の文字と一致します。Match zero or more characters that are not left or right angle brackets.
((?'Open'<)[^<>]*)+ 左山かっこの後に左または右の山かっこではない 0 個以上の文字が続くパターンの 1 回以上の出現と一致します。Match one or more occurrences of a left angle bracket followed by zero or more characters that are not left or right angle brackets. これが 2 番目のキャプチャ グループです。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.
[^<>]* 左または右の山かっこではない任意の文字の 0 回以上の出現と一致します。Match zero or more occurrences of any character that is neither a left nor a right angle bracket.
((?'Close-Open'>)[^<>]*)+ 右山かっこの後に左または右の山かっこではない任意の文字の 0 回以上の出現が続くパターンの 1 回以上の出現と一致します。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. これが 3 番目のキャプチャ グループです。This is the third capturing group.
(((?'Open'<)[^<>]*)+((?'Close-Open'>)[^<>]*)+)* 左山かっこの 1 回以上の出現の後に山かっこではない 0 個以上の文字が続き、その後に右山かっこの 1 回以上の出現が続き、その後に山かっこ以外の 0 回以上の出現が続くパターンの 0 回以上の出現と一致します。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" が 2 番目のキャプチャ グループの値になります。"<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>" の右山かっこと一致し、Open グループと右山かっこの間の部分文字列である "abc" を 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 )+ 3 番目のキャプチャ グループの値は ">" です。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" が 2 番目のキャプチャ グループの値になります。"<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. 現在、Open グループの Group.Captures コレクションには、"<mno" の左山かっこと "<xyz>" の左山かっこの 2 つのキャプチャが含まれています。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" が 2 番目のキャプチャ グループの値になります。"<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. Open グループの Captures コレクションには、現在、単一のキャプチャ ("<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 )+ 3 番目のキャプチャ グループの値は ">" です。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 )+ 3 番目のキャプチャ グループの値は ">" です。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)  

ここで、 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+) 1 つ以上の単語文字に一致します。Match one or more word characters. 一致したテキストをキャプチャされたグループに代入しません。Do not assign the matched text to a captured group.
\W* 0 個以上の単語文字に使用されない文字と一致します。Match zero or more non-word characters.
(?:\b(?:\w+)\W*)+ ワード境界から始まる 1 個以上の単語文字、および 0 個以上の単語文字に使用されない文字が 1 回以上続くパターンと一致します。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: subexpression )(?imnsx-imnsx: subexpression )

ここで、 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. つまり、 subexpression によってキャプチャされる文字列の一部は一致に含まれますが、キャプチャ グループに含まれることも 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" の後に単語文字に使用される文字が 1 個以上続くパターンと一致します。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 )(?= subexpression )

ここで、 subexpression は正規表現パターンです。where subexpression is any regular expression pattern. 一致と見なされるためには、入力文字列が subexpressionの正規表現パターンと一致する必要がありますが、一致した部分文字列は一致結果には含まれません。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+ 1 つ以上の単語文字に一致します。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 )(?! subexpression )

ここで、 subexpression は正規表現パターンです。where subexpression is any regular expression pattern. 一致と見なされるためには、入力文字列が subexpressionの正規表現パターンと一致しない必要がありますが、一致した文字列は一致結果には含まれません。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) 次の 2 文字が "un" であるかどうかを確認します。Determine whether the next two characters are "un". 該当しない場合は一致と考えられます。If they are not, a match is possible.
\w+ 1 つ以上の単語文字に一致します。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+ 1 つ以上の単語文字に一致します。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 )(?<= subexpression )

ここで、 subexpression は正規表現パターンです。where subexpression is any regular expression pattern. 一致と見なされるためには、 subexpression が入力文字列の現在の位置の左側に出現する必要がありますが、 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 世紀の西暦下 2 桁を照合します (つまり、一致する文字列の前に数字 "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} 2 桁の 10 進数と一致します。Match two decimal digits.
(?<=\b20) ワード境界で 2 桁の 10 進数の前に 10 進数 "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 )(?<! subexpression )

ここで、 subexpression は正規表現パターンです。where subexpression is any regular expression pattern. 一致と見なされるためには、 subexpression が入力文字列の現在の位置の左側に出現しない必要があります。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. このアサーションは、キャプチャされたグループの最後の文字がそのグループの正規表現パターンと一致する 1 つ以上の文字にならない必要がある場合に、バックトラッキングを制限するためにも使用されます。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+ 1 個以上の単語文字の後に空白文字が続くパターンと一致します。Match one or more word characters followed by a white-space character.
\d{1,2}, 1 桁または 2 桁の 10 進数の後に空白文字とコンマが続くパターンと一致します。Match either one or two decimal digits followed by a white-space character and a comma.
\d{4}\b 4 桁の 10 進数と一致し、ワード境界で照合を終了します。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 )(?> 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. 最初の分岐で一致する文字列が見つからなかった場合、正規表現エンジンは最初に一致した時点まで戻り (バックトラック)、2 番目の分岐を使用して照合を試みることができます。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.

インデックスが 2 の (?>subexpression) 言語コンストラクトでは、バックトラッキングが無効になります。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) 単語文字に使用される 1 文字と一致し、その文字を 1 番目のキャプチャ グループに代入します。Match a single word character and assign it to the first capturing group.
\1+ 最初にキャプチャされた部分文字列の値と 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+) 重複する単語文字の 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 オブジェクト (インデックス 0 の位置にあるオブジェクト) は、一致した文字列全体を表します。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. 最初の名前付きキャプチャ グループのインデックス値は、最後の名前のないキャプチャ グループのインデックスよりも 1 大きい数値になります。The index value of the first named capturing group is one greater than the index of the last unnamed capturing group. 正規表現に名前のないキャプチャ グループがない場合、最初の名前付きキャプチャ グループのインデックス値は 1 になります。If there are no unnamed capturing groups in the regular expression, the index value of the first named capturing group is one.

量指定子をキャプチャ グループに適用する場合、対応する Group オブジェクトの Capture.ValueCapture.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+) 1 つ以上の単語文字に一致します。Match one or more word characters. これらの文字が集まって、単語を形成しますTogether, these characters form a word. これが 2 番目のキャプチャ グループです。This is the second capturing group.
\W+ 1 個以上の単語文字に使用されない文字と一致します。Match one or more non-word characters.
(\b(\w+)\W+) 1 個以上の単語文字、および 1 個以上の単語文字に使用されない文字が 1 回以上続くパターンと一致します。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.

2 番目のキャプチャ グループは、文の各単語と一致します。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. インデックスが 2 の 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