正規表現のオブジェクト モデルThe Regular Expression Object Model

ここでは、.NET の正規表現を扱うときに使用するオブジェクト モデルについて説明します。This topic describes the object model used in working with .NET regular expressions. このチュートリアルは、次のセクションで構成されています。It contains the following sections:

正規表現エンジンThe Regular Expression Engine

.NET の正規表現エンジンは、Regex クラスによって表されます。The regular expression engine in .NET is represented by the Regex class. 正規表現エンジンは、正規表現の解析とコンパイル、および正規表現パターンと入力文字列を照合する操作を実行します。The regular expression engine is responsible for parsing and compiling a regular expression, and for performing operations that match the regular expression pattern with an input string. エンジンは、.NET 正規表現のオブジェクト モデルの中核となるコンポーネントです。The engine is the central component in the .NET regular expression object model.

正規表現エンジンは、次のいずれかの方法で使用できます。You can use the regular expression engine in either of two ways:

  • Regex クラスの静的メソッドを呼び出す。By calling the static methods of the Regex class. メソッドのパラメーターには、入力文字列と正規表現パターンが含まれます。The method parameters include the input string and the regular expression pattern. 静的メソッド呼び出しで使用した正規表現は、正規表現エンジンによってキャッシュされるので、同じ正規表現を使用する静的正規表現メソッドを繰り返し呼び出す場合、パフォーマンスが比較的向上します。The regular expression engine caches regular expressions that are used in static method calls, so repeated calls to static regular expression methods that use the same regular expression offer relatively good performance.

  • 正規表現をクラス コンストラクターに渡して Regex オブジェクトをインスタンス化する。By instantiating a Regex object, by passing a regular expression to the class constructor. この場合、Regex オブジェクトは変更不可 (読み取り専用) で、単一の正規表現と密に結合された正規表現エンジンを表します。In this case, the Regex object is immutable (read-only) and represents a regular expression engine that is tightly coupled with a single regular expression. Regex インスタンスによって使用される正規表現はキャッシュされないので、同じ正規表現で Regex オブジェクトを複数回インスタンス化しないでください。Because regular expressions used by Regex instances are not cached, you should not instantiate a Regex object multiple times with the same regular expression.

Regex クラスのメソッドを呼び出すと、次のような処理を実行できます。You can call the methods of the Regex class to perform the following operations:

  • 文字列が正規表現パターンと一致するかどうかを確認する。Determine whether a string matches a regular expression pattern.

  • 単一の一致または最初の一致を抽出する。Extract a single match or the first match.

  • すべての一致を抽出する。Extract all matches.

  • 一致した部分文字列を置換する。Replace a matched substring.

  • 単一の文字列を文字列配列に分割する。Split a single string into an array of strings.

ここでは、これらの操作について説明します。These operations are described in the following sections.

正規表現パターンの照合Matching a Regular Expression Pattern

Regex.IsMatch メソッドは、文字列がパターンと一致する場合は true を返し、一致しない場合は false を返します。The Regex.IsMatch method returns true if the string matches the pattern, or false if it does not. IsMatch メソッドは、文字列入力を検証する場合によく使用されます。The IsMatch method is often used to validate string input. たとえば、次のコードでは、文字列は米国の有効な社会保障番号と一致します。For example, the following code ensures that a string matches a valid social security number in the United States.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] values = { "111-22-3333", "111-2-3333"};
      string pattern = @"^\d{3}-\d{2}-\d{4}$";
      foreach (string value in values) {
         if (Regex.IsMatch(value, pattern))
            Console.WriteLine("{0} is a valid SSN.", value);
         else
            Console.WriteLine("{0}: Invalid", value);
      }
   }
}
// The example displays the following output:
//       111-22-3333 is a valid SSN.
//       111-2-3333: Invalid
Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim values() As String = {"111-22-3333", "111-2-3333"}
        Dim pattern As String = "^\d{3}-\d{2}-\d{4}$"
        For Each value As String In values
            If Regex.IsMatch(value, pattern) Then
                Console.WriteLine("{0} is a valid SSN.", value)
            Else
                Console.WriteLine("{0}: Invalid", value)
            End If
        Next
    End Sub
End Module
' The example displays the following output:
'       111-22-3333 is a valid SSN.
'       111-2-3333: Invalid

この正規表現パターン ^\d{3}-\d{2}-\d{4}$ の解釈を次の表に示します。The regular expression pattern ^\d{3}-\d{2}-\d{4}$ is interpreted as shown in the following table.

パターンPattern 説明Description
^ 入力文字列の先頭と一致します。Match the beginning of the input string.
\d{3} 3 個の 10 進数と一致します。Match three decimal digits.
- ハイフンと一致します。Match a hyphen.
\d{2} 2 桁の 10 進数と一致します。Match two decimal digits.
- ハイフンと一致します。Match a hyphen.
\d{4} 4 桁の 10 進数と一致します。Match four decimal digits.
$ 入力文字列の末尾と一致します。Match the end of the input string.

単一の一致または最初の一致の抽出Extracting a Single Match or the First Match

Regex.Match メソッドは、正規表現パターンに一致する最初の部分文字列の情報を含む Match オブジェクトを返します。The Regex.Match method returns a Match object that contains information about the first substring that matches a regular expression pattern. Match.Success プロパティが true (一致する文字列が見つかったことを示す) を返す場合は、Match.NextMatch メソッドを呼び出すと後続の一致する文字列の情報を取得できます。If the Match.Success property returns true, indicating that a match was found, you can retrieve information about subsequent matches by calling the Match.NextMatch method. これらのメソッド呼び出しは、Match.Success プロパティによって false が返されるまで続行できます。These method calls can continue until the Match.Success property returns false. たとえば、次のコードでは、Regex.Match(String, String) メソッドを使用して、重複する単語が文字列内で最初に出現する位置を検索します。For example, the following code uses the Regex.Match(String, String) method to find the first occurrence of a duplicated word in a string. 次に、Match.NextMatch メソッドを呼び出してその他の出現位置を検索します。It then calls the Match.NextMatch method to find any additional occurrences. この例では、メソッドを呼び出すごとに Match.Success プロパティを調べ、現在の一致が成功したかどうか、および続けて Match.NextMatch メソッドを呼び出す必要があるかどうかを確認します。The example examines the Match.Success property after each method call to determine whether the current match was successful and whether a call to the Match.NextMatch method should follow.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is a a farm that that raises dairy cattle.";
      string pattern = @"\b(\w+)\W+(\1)\b";
      Match match = Regex.Match(input, pattern);
      while (match.Success)
      {
         Console.WriteLine("Duplicate '{0}' found at position {1}.",
                           match.Groups[1].Value, match.Groups[2].Index);
         match = match.NextMatch();
      }
   }
}
// The example displays the following output:
//       Duplicate 'a' found at position 10.
//       Duplicate 'that' found at position 22.
Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim input As String = "This is a a farm that that raises dairy cattle."
        Dim pattern As String = "\b(\w+)\W+(\1)\b"
        Dim match As Match = Regex.Match(input, pattern)
        Do While match.Success
            Console.WriteLine("Duplicate '{0}' found at position {1}.", _
                              match.Groups(1).Value, match.Groups(2).Index)
            match = match.NextMatch()
        Loop
    End Sub
End Module
' The example displays the following output:
'       Duplicate 'a' found at position 10.
'       Duplicate 'that' found at position 22.

この正規表現パターン \b(\w+)\W+(\1)\b の解釈を次の表に示します。The regular expression pattern \b(\w+)\W+(\1)\b is interpreted as shown in the following table.

パターンPattern 説明Description
\b ワード境界から照合を開始します。Begin the match on a word boundary.
(\w+) 1 つ以上の単語文字に一致します。Match one or more word characters. これが最初のキャプチャ グループです。This is the first capturing group.
\W+ 1 個以上の単語文字に使用されない文字と一致します。Match one or more non-word characters.
(\1) 最初にキャプチャされた文字列と一致します。Match the first captured string. これが 2 番目のキャプチャ グループです。This is the second capturing group.
\b ワード境界で照合を終了します。End the match on a word boundary.

すべての一致の抽出Extracting All Matches

Regex.Matches メソッドは、入力文字列で正規表現エンジンによって検出されたすべての一致文字列の情報を含む MatchCollection オブジェクトを返します。The Regex.Matches method returns a MatchCollection object that contains information about all matches that the regular expression engine found in the input string. たとえば、前の例を書き換えて、Matches メソッドと Match メソッドではなく NextMatch メソッドを呼び出すことができます。For example, the previous example could be rewritten to call the Matches method instead of the Match and NextMatch methods.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is a a farm that that raises dairy cattle.";
      string pattern = @"\b(\w+)\W+(\1)\b";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine("Duplicate '{0}' found at position {1}.",
                           match.Groups[1].Value, match.Groups[2].Index);
   }
}
// The example displays the following output:
//       Duplicate 'a' found at position 10.
//       Duplicate 'that' found at position 22.
Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim input As String = "This is a a farm that that raises dairy cattle."
        Dim pattern As String = "\b(\w+)\W+(\1)\b"
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine("Duplicate '{0}' found at position {1}.", _
                              match.Groups(1).Value, match.Groups(2).Index)
        Next
    End Sub
End Module
' The example displays the following output:
'       Duplicate 'a' found at position 10.
'       Duplicate 'that' found at position 22.

一致した部分文字列の置換Replacing a Matched Substring

Regex.Replace メソッドは、正規表現パターンに一致した各部分文字列を指定された文字列または正規表現パターンに置き換えて、置換が適用された入力文字列全体を返します。The Regex.Replace method replaces each substring that matches the regular expression pattern with a specified string or regular expression pattern, and returns the entire input string with replacements. たとえば、次のコードでは、文字列内の 10 進数の前に米国の通貨記号が追加されます。For example, the following code adds a U.S. currency symbol before a decimal number in a string.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\d+\.\d{2}\b";
      string replacement = "$$$&";
      string input = "Total Cost: 103.64";
      Console.WriteLine(Regex.Replace(input, pattern, replacement));
   }
}
// The example displays the following output:
//       Total Cost: $103.64
Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b\d+\.\d{2}\b"
        Dim replacement As String = "$$$&"
        Dim input As String = "Total Cost: 103.64"
        Console.WriteLine(Regex.Replace(input, pattern, replacement))
    End Sub
End Module
' The example displays the following output:
'       Total Cost: $103.64

この正規表現パターン \b\d+\.\d{2}\b の解釈を次の表に示します。The regular expression pattern \b\d+\.\d{2}\b is interpreted as shown in the following table.

パターンPattern 説明Description
\b ワード境界から照合を開始します。Begin the match at a word boundary.
\d+ 1 個以上の 10 進数と一致します。Match one or more decimal digits.
\. ピリオドと一致します。Match a period.
\d{2} 2 桁の 10 進数と一致します。Match two decimal digits.
\b ワード境界で照合を終了します。End the match at a word boundary.

置換パターン $$$& の解釈を次の表に示します。The replacement pattern $$$& is interpreted as shown in the following table.

パターンPattern 置換文字列Replacement string
$$ ドル記号 ($) 文字。The dollar sign ($) character.
$& 一致した部分文字列全体。The entire matched substring.

単一の文字列の文字列配列への分割Splitting a Single String into an Array of Strings

Regex.Split メソッドは、正規表現によって定義されている位置で、入力文字列を分割します。The Regex.Split method splits the input string at the positions defined by a regular expression match. たとえば、次のコードでは、番号付きリストの項目を文字列配列に配置します。For example, the following code places the items in a numbered list into a string array.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "1. Eggs 2. Bread 3. Milk 4. Coffee 5. Tea";
      string pattern = @"\b\d{1,2}\.\s";
      foreach (string item in Regex.Split(input, pattern))
      {
         if (! String.IsNullOrEmpty(item))
            Console.WriteLine(item);
      }
   }
}
// The example displays the following output:
//       Eggs
//       Bread
//       Milk
//       Coffee
//       Tea
Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim input As String = "1. Eggs 2. Bread 3. Milk 4. Coffee 5. Tea"
        Dim pattern As String = "\b\d{1,2}\.\s"
        For Each item As String In Regex.Split(input, pattern)
            If Not String.IsNullOrEmpty(item) Then
                Console.WriteLine(item)
            End If
        Next
    End Sub
End Module
' The example displays the following output:
'       Eggs
'       Bread
'       Milk
'       Coffee
'       Tea

この正規表現パターン \b\d{1,2}\.\s の解釈を次の表に示します。The regular expression pattern \b\d{1,2}\.\s is interpreted as shown in the following table.

パターンPattern 説明Description
\b ワード境界から照合を開始します。Begin the match at a word boundary.
\d{1,2} 1 桁または 2 桁の 10 進数と一致します。Match one or two decimal digits.
\. ピリオドと一致します。Match a period.
\s 空白文字と一致します。Match a white-space character.

MatchCollection オブジェクトと Match オブジェクトThe MatchCollection and Match Objects

Regex メソッドは、正規表現のオブジェクト モデルに含まれる MatchCollectionMatch の 2 つのオブジェクトを返します。Regex methods return two objects that are part of the regular expression object model: the MatchCollection object, and the Match object.

MatchCollectionThe Match Collection

Regex.Matches メソッドは、正規表現エンジンによって検出されたすべての一致文字列を入力文字列に出現する順序で表す MatchCollection オブジェクトを含む Match オブジェクトを返します。The Regex.Matches method returns a MatchCollection object that contains Match objects that represent all the matches that the regular expression engine found, in the order in which they occur in the input string. 一致文字列がない場合、このメソッドはメンバーを持たない MatchCollection オブジェクトを返します。If there are no matches, the method returns a MatchCollection object with no members. MatchCollection.Item[] プロパティを使用すると、コレクションの個々のメンバーに、0 から MatchCollection.Count プロパティの値より 1 小さい値までの範囲のインデックスでアクセスできます。The MatchCollection.Item[] property lets you access individual members of the collection by index, from zero to one less than the value of the MatchCollection.Count property. Item[] は、コレクションのインデクサー (C# の場合) および既定のプロパティ (Visual Basic の場合) です。Item[] is the collection's indexer (in C#) and default property (in Visual Basic).

既定では、Regex.Matches メソッドを呼び出すと、遅延評価を使用して MatchCollection オブジェクトに値が設定されます。By default, the call to the Regex.Matches method uses lazy evaluation to populate the MatchCollection object. 値の設定が完了しているコレクションを必要とするプロパティ (MatchCollection.Count プロパティや MatchCollection.Item[] プロパティなど) にアクセスする場合は、パフォーマンスが低下する可能性があります。Access to properties that require a fully populated collection, such as the MatchCollection.Count and MatchCollection.Item[] properties, may involve a performance penalty. そのため、IEnumerator メソッドによって返される MatchCollection.GetEnumerator オブジェクトを使用してコレクションにアクセスすることをお勧めします。As a result, we recommend that you access the collection by using the IEnumerator object that is returned by the MatchCollection.GetEnumerator method. 個々の言語には、コレクションの IEnumerator インターフェイスをラップする構成体 (Visual Basic の For Each や C# の foreach など) が用意されています。Individual languages provide constructs, such as For Each in Visual Basic and foreach in C#, that wrap the collection's IEnumerator interface.

次の例では、Regex.Matches(String) メソッドを使用して、入力文字列の中で見つかったすべての一致を MatchCollection オブジェクトに設定します。The following example uses the Regex.Matches(String) method to populate a MatchCollection object with all the matches found in an input string. この例では、コレクションを列挙して一致文字列を文字列配列にコピーし、文字位置を整数配列に記録します。The example enumerates the collection, copies the matches to a string array, and records the character positions in an integer array.

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
       MatchCollection matches;
       List<string> results = new List<string>();
       List<int> matchposition = new List<int>();

       // Create a new Regex object and define the regular expression.
       Regex r = new Regex("abc");
       // Use the Matches method to find all matches in the input string.
       matches = r.Matches("123abc4abcd");
       // Enumerate the collection to retrieve all matches and positions.
       foreach (Match match in matches)
       {
          // Add the match string to the string array.
           results.Add(match.Value);
           // Record the character position where the match was found.
           matchposition.Add(match.Index);
       }
       // List the results.
       for (int ctr = 0; ctr < results.Count; ctr++)
         Console.WriteLine("'{0}' found at position {1}.",
                           results[ctr], matchposition[ctr]);
   }
}
// The example displays the following output:
//       'abc' found at position 3.
//       'abc' found at position 7.
Imports System.Collections.Generic
Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim matches As MatchCollection
        Dim results As New List(Of String)
        Dim matchposition As New List(Of Integer)

        ' Create a new Regex object and define the regular expression.
        Dim r As New Regex("abc")
        ' Use the Matches method to find all matches in the input string.
        matches = r.Matches("123abc4abcd")
        ' Enumerate the collection to retrieve all matches and positions.
        For Each match As Match In matches
            ' Add the match string to the string array.
            results.Add(match.Value)
            ' Record the character position where the match was found.
            matchposition.Add(match.Index)
        Next
        ' List the results.
        For ctr As Integer = 0 To results.Count - 1
            Console.WriteLine("'{0}' found at position {1}.", _
                              results(ctr), matchposition(ctr))
        Next
    End Sub
End Module
' The example displays the following output:
'       'abc' found at position 3.
'       'abc' found at position 7.

MatchThe Match

Match クラスは、1 回の正規表現検索に一致した結果を表します。The Match class represents the result of a single regular expression match. Match オブジェクトには 2 つの方法でアクセスできます。You can access Match objects in two ways:

  • MatchCollection メソッドから返される Regex.Matches オブジェクトから取得する。By retrieving them from the MatchCollection object that is returned by the Regex.Matches method. 個々の Match オブジェクトを取得するには、foreach 構成体 (C# の場合) または For Each...Next 構成体 (Visual Basic の場合) を使用してコレクションを反復処理するか、MatchCollection.Item[] プロパティを使用してインデックスまたは名前で特定の Match オブジェクトを取得します。To retrieve individual Match objects, iterate the collection by using a foreach (in C#) or For Each...Next (in Visual Basic) construct, or use the MatchCollection.Item[] property to retrieve a specific Match object either by index or by name. また、0 からコレクションのオブジェクト数より 1 小さい値までの範囲のインデックスでコレクションを反復処理して、コレクションから個々の Match オブジェクトを取得することもできます。You can also retrieve individual Match objects from the collection by iterating the collection by index, from zero to one less that the number of objects in the collection. ただし、このメソッドは MatchCollection.Count プロパティにアクセスするので、遅延評価を活用できません。However, this method does not take advantage of lazy evaluation, because it accesses the MatchCollection.Count property.

    次の例では、Match 構成体または MatchCollection...foreach 構成体を使用してコレクションを反復処理することで、個々の For Each オブジェクトを Next オブジェクトから取得します。The following example retrieves individual Match objects from a MatchCollection object by iterating the collection using the foreach or For Each...Next construct. この正規表現は、単純に入力文字列内の文字列 "abc" と一致します。The regular expression simply matches the string "abc" in the input string.

    using System;
    using System.Text.RegularExpressions;
    
    public class Example
    {
       public static void Main()
       {
          string pattern = "abc";
          string input = "abc123abc456abc789";
          foreach (Match match in Regex.Matches(input, pattern))
             Console.WriteLine("{0} found at position {1}.",
                               match.Value, match.Index);
       }
    }
    // The example displays the following output:
    //       abc found at position 0.
    //       abc found at position 6.
    //       abc found at position 12.
    
    Imports System.Text.RegularExpressions
    
    Module Example
        Public Sub Main()
            Dim pattern As String = "abc"
            Dim input As String = "abc123abc456abc789"
            For Each match As Match In Regex.Matches(input, pattern)
                Console.WriteLine("{0} found at position {1}.", _
                                  match.Value, match.Index)
            Next
        End Sub
    End Module
    ' The example displays the following output:
    '       abc found at position 0.
    '       abc found at position 6.
    '       abc found at position 12.
    
  • 文字列または文字列の一部で最初に一致する文字列を表す Regex.Match オブジェクトを返す Match メソッドを呼び出す。By calling the Regex.Match method, which returns a Match object that represents the first match in a string or a portion of a string. Match.Success プロパティの値を取得すると、一致文字列が見つかったかどうかを確認できます。You can determine whether the match has been found by retrieving the value of the Match.Success property. 後続の一致する文字列を表す Match オブジェクトを取得するには、返された Match.NextMatch オブジェクトの Success プロパティが Match になるまで false メソッドを繰り返し呼び出します。To retrieve Match objects that represent subsequent matches, call the Match.NextMatch method repeatedly, until the Success property of the returned Match object is false.

    次の例では、入力文字列内の文字列 "abc" と一致する Regex.Match(String, String) メソッドと Match.NextMatch メソッドを使用します。The following example uses the Regex.Match(String, String) and Match.NextMatch methods to match the string "abc" in the input string.

    using System;
    using System.Text.RegularExpressions;
    
    public class Example
    {
       public static void Main()
       {
          string pattern = "abc";
          string input = "abc123abc456abc789";
          Match match = Regex.Match(input, pattern);
          while (match.Success)
          {
             Console.WriteLine("{0} found at position {1}.",
                               match.Value, match.Index);
             match = match.NextMatch();
          }
       }
    }
    // The example displays the following output:
    //       abc found at position 0.
    //       abc found at position 6.
    //       abc found at position 12.
    
    Imports System.Text.RegularExpressions
    
    Module Example
        Public Sub Main()
            Dim pattern As String = "abc"
            Dim input As String = "abc123abc456abc789"
            Dim match As Match = Regex.Match(input, pattern)
            Do While match.Success
                Console.WriteLine("{0} found at position {1}.", _
                                  match.Value, match.Index)
                match = match.NextMatch()
            Loop
        End Sub
    End Module
    ' The example displays the following output:
    '       abc found at position 0.
    '       abc found at position 6.
    '       abc found at position 12.
    

Match クラスの 2 つのプロパティによってコレクション オブジェクトが返されます。Two properties of the Match class return collection objects:

  • Match.Groups プロパティは、正規表現パターンのキャプチャ グループに一致する部分文字列の情報を含む GroupCollection オブジェクトを返します。The Match.Groups property returns a GroupCollection object that contains information about the substrings that match capturing groups in the regular expression pattern.

  • Match.Captures プロパティは、用途が限定された CaptureCollection オブジェクトを返します。The Match.Captures property returns a CaptureCollection object that is of limited use. Match オブジェクトの Success プロパティが false の場合、コレクションに値は設定されません。The collection is not populated for a Match object whose Success property is false. それ以外の場合は、Capture オブジェクトと同じ情報を含む単一の Match オブジェクトが格納されます。Otherwise, it contains a single Capture object that has the same information as the Match object.

これらのオブジェクトの詳細については、このトピックで後述する「GroupCollection」セクションおよび「CaptureCollection」セクションを参照してください。For more information about these objects, see The Group Collection and The Capture Collection sections later in this topic.

Match クラスの 2 つの追加プロパティに、一致文字列の情報が保持されます。Two additional properties of the Match class provide information about the match. Match.Value プロパティは、正規表現パターンに一致する入力文字列内の部分文字列を返します。The Match.Value property returns the substring in the input string that matches the regular expression pattern. Match.Index プロパティは、入力文字列内の一致する文字列の 0 から始まる開始位置を返します。The Match.Index property returns the zero-based starting position of the matched string in the input string.

Match クラスには、2 つのパターン一致メソッドもあります。The Match class also has two pattern-matching methods:

  • Match.NextMatch メソッドは、現在の Match オブジェクトで表される一致文字列の後の一致文字列を検索し、その一致文字列を表す Match オブジェクトを返します。The Match.NextMatch method finds the match after the match represented by the current Match object, and returns a Match object that represents that match.

  • Match.Result メソッドは、一致した文字列に対して指定された置換操作を実行し、その結果を返します。The Match.Result method performs a specified replacement operation on the matched string and returns the result.

次の例では、Match.Result メソッドを使用して、2 桁の小数部を含むすべての数値の前に $ 記号および空白を付加します。The following example uses the Match.Result method to prepend a $ symbol and a space before every number that includes two fractional digits.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\d+(,\d{3})*\.\d{2}\b";
      string input = "16.32\n194.03\n1,903,672.08";

      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Result("$$ $&"));
   }
}
// The example displays the following output:
//       $ 16.32
//       $ 194.03
//       $ 1,903,672.08
Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b\d+(,\d{3})*\.\d{2}\b"
        Dim input As String = "16.32" + vbCrLf + "194.03" + vbCrLf + "1,903,672.08"

        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine(match.Result("$$ $&"))
        Next
    End Sub
End Module
' The example displays the following output:
'       $ 16.32
'       $ 194.03
'       $ 1,903,672.08

正規表現パターン \b\d+(,\d{3})*\.\d{2}\b は、次の表に示すように定義されています。The regular expression pattern \b\d+(,\d{3})*\.\d{2}\b is defined as shown in the following table.

パターンPattern 説明Description
\b ワード境界から照合を開始します。Begin the match at a word boundary.
\d+ 1 個以上の 10 進数と一致します。Match one or more decimal digits.
(,\d{3})* コンマの後に 3 桁の 10 進数字が続くパターンの 0 回以上の出現と一致します。Match zero or more occurrences of a comma followed by three decimal digits.
\. 小数点文字と一致します。Match the decimal point character.
\d{2} 2 桁の 10 進数と一致します。Match two decimal digits.
\b ワード境界で照合を終了します。End the match at a word boundary.

置換パターン $$ $& は、一致した部分文字列がドル記号 ($) ($$ パターン)、空白、および一致文字列の値 ($& パターン) に置き換えられることを示します。The replacement pattern $$ $& indicates that the matched substring should be replaced by a dollar sign ($) symbol (the $$ pattern), a space, and the value of the match (the $& pattern).

ページのトップへBack to top

GroupCollectionThe Group Collection

Match.Groups プロパティは、単一の一致でキャプチャされたグループを表す GroupCollection オブジェクトを含む Group オブジェクトを返します。The Match.Groups property returns a GroupCollection object that contains Group objects that represent captured groups in a single match. コレクション内の最初の Group オブジェクト (インデックス 0 の位置にあるオブジェクト) は、一致した文字列全体を表します。The first Group object in the collection (at index 0) represents the entire match. 後続の各オブジェクトは、1 つのキャプチャ グループによるキャプチャの結果を表します。Each object that follows represents the results of a single capturing group.

コレクション内の個々の Group オブジェクトを取得するには、GroupCollection.Item[] プロパティを使用します。You can retrieve individual Group objects in the collection by using the GroupCollection.Item[] property. 名前のないグループはコレクション内の順序位置で取得でき、名前付きグループは名前または順序位置で取得できます。You can retrieve unnamed groups by their ordinal position in the collection, and retrieve named groups either by name or by ordinal position. 名前のないキャプチャはコレクションの最初に位置し、正規表現パターンで定義されている順序で左から右にインデックスが付けられます。Unnamed captures appear first in the collection, and are indexed from left to right in the order in which they appear in the regular expression pattern. 名前付きキャプチャは、名前のないキャプチャの後に、正規表現パターンで定義されている順序で左から右にインデックスが付けられます。Named captures are indexed after unnamed captures, from left to right in the order in which they appear in the regular expression pattern. 特定の正規表現一致メソッドで返されたコレクションで使用可能な番号付きグループを判別するには、インスタンス Regex.GetGroupNumbers メソッドを呼び出すことができます。To determine what numbered groups are available in the collection returned for a particular regular expression matching method, you can call the instance Regex.GetGroupNumbers method. コレクションで使用可能な名前付きグループを判別するには、インスタンス Regex.GetGroupNames メソッドを呼び出すことができます。To determine what named groups are available in the collection, you can call the instance Regex.GetGroupNames method. どちらのメソッドも、正規表現によって検出された一致を分析する汎用ルーチンで特に役立ちます。Both methods are particularly useful in general-purpose routines that analyze the matches found by any regular expression.

GroupCollection.Item[] プロパティは、コレクションのインデクサー (C# の場合) およびコレクション オブジェクトの既定のプロパティ (Visual Basic の場合) です。The GroupCollection.Item[] property is the indexer of the collection in C# and the collection object's default property in Visual Basic. つまり、個々の Group オブジェクトには、次のようにインデックスで (または名前付きグループの場合は名前で) アクセスできます。This means that individual Group objects can be accessed by index (or by name, in the case of named groups) as follows:

Group group = match.Groups[ctr];
Dim group As Group = match.Groups(ctr)

次の例では、グループ化構成体を使用して日付の月、日、および年をキャプチャする正規表現を定義します。The following example defines a regular expression that uses grouping constructs to capture the month, day, and year of a date.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\w+)\s(\d{1,2}),\s(\d{4})\b";
      string input = "Born: July 28, 1989";
      Match match = Regex.Match(input, pattern);
      if (match.Success)
         for (int ctr = 0; ctr <  match.Groups.Count; ctr++)
            Console.WriteLine("Group {0}: {1}", ctr, match.Groups[ctr].Value);
    }
}
// The example displays the following output:
//       Group 0: July 28, 1989
//       Group 1: July
//       Group 2: 28
//       Group 3: 1989
Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b(\w+)\s(\d{1,2}),\s(\d{4})\b"
        Dim input As String = "Born: July 28, 1989"
        Dim match As Match = Regex.Match(input, pattern)
        If match.Success Then
            For ctr As Integer = 0 To match.Groups.Count - 1
                Console.WriteLine("Group {0}: {1}", ctr, match.Groups(ctr).Value)
            Next
        End If
    End Sub
End Module
' The example displays the following output:
'       Group 0: July 28, 1989
'       Group 1: July
'       Group 2: 28
'       Group 3: 1989

正規表現パターン \b(\w+)\s(\d{1,2}),\s(\d{4})\b は、次の表に示すように定義されています。The regular expression pattern \b(\w+)\s(\d{1,2}),\s(\d{4})\b 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. これが最初のキャプチャ グループです。This is the first capturing group.
\s 空白文字と一致します。Match a white-space character.
(\d{1,2}) 1 桁または 2 桁の 10 進数と一致します。Match one or two decimal digits. これが 2 番目のキャプチャ グループです。This is the second capturing group.
, コンマに一致します。Match a comma.
\s 空白文字と一致します。Match a white-space character.
(\d{4}) 4 桁の 10 進数と一致します。Match four decimal digits. これが 3 番目のキャプチャ グループです。This is the third capturing group.
\b ワード境界で照合を終了します。End the match on a word boundary.

ページのトップへBack to top

キャプチャ グループThe Captured Group

Group クラスは、1 つのキャプチャ グループによるキャプチャの結果を表します。The Group class represents the result from a single capturing group. 正規表現で定義されているキャプチャ グループを表すグループ オブジェクトは、Item[] プロパティによって返される GroupCollection オブジェクトの Match.Groups プロパティによって返されます。Group objects that represent the capturing groups defined in a regular expression are returned by the Item[] property of the GroupCollection object returned by the Match.Groups property. Item[] プロパティは、Group クラスのインデクサー (C# の場合) および既定のプロパティ (Visual Basic の場合) です。The Item[] property is the indexer (in C#) and the default property (in Visual Basic) of the Group class. foreach 構成体または For Each 構成体を使用してコレクションを反復処理することで、個々のメンバーを取得することもできます。You can also retrieve individual members by iterating the collection using the foreach or For Each construct. 例については、前のセクションを参照してください。For an example, see the previous section.

次の例では、入れ子にしたグループ化構成体を使用して部分文字列をキャプチャし、グループ化します。The following example uses nested grouping constructs to capture substrings into groups. 正規表現パターン (a(b))c は、文字列 "abc" と一致します。The regular expression pattern (a(b))c matches the string "abc". 部分文字列 "ab" を最初のキャプチャ グループに代入し、部分文字列 "b" を 2 番目のキャプチャ グループに代入します。It assigns the substring "ab" to the first capturing group, and the substring "b" to the second capturing group.

var matchposition = new List<int>();
var results = new List<string>();
// Define substrings abc, ab, b.
var r = new Regex("(a(b))c");
Match m = r.Match("abdabc");
for (int i = 0; m.Groups[i].Value != ""; i++)
{
    // Add groups to string array.
    results.Add(m.Groups[i].Value);
    // Record character position.
    matchposition.Add(m.Groups[i].Index);
}

// Display the capture groups.
for (int ctr = 0; ctr < results.Count; ctr++)
    Console.WriteLine("{0} at position {1}",
                      results[ctr], matchposition[ctr]);
// The example displays the following output:
//       abc at position 3
//       ab at position 3
//       b at position 4
Dim matchposition As New List(Of Integer)
Dim results As New List(Of String)
' Define substrings abc, ab, b.
Dim r As New Regex("(a(b))c")
Dim m As Match = r.Match("abdabc")
Dim i As Integer = 0
While Not (m.Groups(i).Value = "")
    ' Add groups to string array.
    results.Add(m.Groups(i).Value)
    ' Record character position. 
    matchposition.Add(m.Groups(i).Index)
    i += 1
End While

' Display the capture groups.
For ctr As Integer = 0 to results.Count - 1
    Console.WriteLine("{0} at position {1}", _
                      results(ctr), matchposition(ctr))
Next
' The example displays the following output:
'       abc at position 3
'       ab at position 3
'       b at position 4

次の例では、名前付きグループ化構成体を使用して、"DATANAME:VALUE" 形式のデータを含む文字列から部分文字列をキャプチャします。この正規表現は、コロン (:) でデータを分割します。The following example uses named grouping constructs to capture substrings from a string that contains data in the format "DATANAME:VALUE", which the regular expression splits at the colon (:).

var r = new Regex(@"^(?<name>\w+):(?<value>\w+)");
Match m = r.Match("Section1:119900");
Console.WriteLine(m.Groups["name"].Value);
Console.WriteLine(m.Groups["value"].Value);
// The example displays the following output:
//       Section1
//       119900
Dim r As New Regex("^(?<name>\w+):(?<value>\w+)")
Dim m As Match = r.Match("Section1:119900")
Console.WriteLine(m.Groups("name").Value)
Console.WriteLine(m.Groups("value").Value)
' The example displays the following output:
'       Section1
'       119900

正規表現パターン ^(?<name>\w+):(?<value>\w+) は、次の表に示すように定義されています。The regular expression pattern ^(?<name>\w+):(?<value>\w+) is defined as shown in the following table.

パターンPattern 説明Description
^ 入力文字列の先頭から照合を開始します。Begin the match at the beginning of the input string.
(?<name>\w+) 1 つ以上の単語文字に一致します。Match one or more word characters. このキャプチャ グループの名前は name です。The name of this capturing group is name.
: コロンと一致します。Match a colon.
(?<value>\w+) 1 つ以上の単語文字に一致します。Match one or more word characters. このキャプチャ グループの名前は value です。The name of this capturing group is value.

Group クラスのプロパティには、キャプチャ グループの情報が保持されます。キャプチャされた部分文字列が Group.Value プロパティに含まれ、キャプチャ グループの入力テキスト内での開始位置が Group.Index プロパティによって示され、キャプチャされたテキストの長さが Group.Length プロパティに含まれ、部分文字列がキャプチャ グループによって定義されたパターンと一致したかどうかが Group.Success プロパティによって示されます。The properties of the Group class provide information about the captured group: The Group.Value property contains the captured substring, the Group.Index property indicates the starting position of the captured group in the input text, the Group.Length property contains the length of the captured text, and the Group.Success property indicates whether a substring matched the pattern defined by the capturing group.

量指定子をグループに適用する場合 (詳細については、「量指定子」を参照)、キャプチャ グループごとに 1 つのキャプチャという関係が 2 つの方法で変更されます。Applying quantifiers to a group (for more information, see Quantifiers) modifies the relationship of one capture per capturing group in two ways:

  • * 量指定子または *? 量指定子 (0 回以上の一致を指定する) をグループに適用した場合、キャプチャ グループには入力文字列で一致した文字列が含まれない可能性があります。If the * or *? quantifier (which specifies zero or more matches) is applied to a group, a capturing group may not have a match in the input string. キャプチャされたテキストがない場合、Group オブジェクトのプロパティは次の表に示すように設定されます。When there is no captured text, the properties of the Group object are set as shown in the following table.

    Group プロパティGroup property [値]Value
    Success false
    Value String.Empty
    Length 00

    具体的な例を次に示します。The following example provides an illustration. 正規表現パターン aaa(bbb)*ccc では、最初のキャプチャ グループ (部分文字列 "bbb") は 0 回以上一致できます。In the regular expression pattern aaa(bbb)*ccc, the first capturing group (the substring "bbb") can be matched zero or more times. 入力文字列 "aaaccc" はパターンに一致するので、キャプチャ グループには一致文字列が含まれません。Because the input string "aaaccc" matches the pattern, the capturing group does not have a match.

    using System;
    using System.Text.RegularExpressions;
    
    public class Example
    {
       public static void Main()
       {
          string pattern = "aaa(bbb)*ccc";
          string input = "aaaccc";
          Match match = Regex.Match(input, pattern);
          Console.WriteLine("Match value: {0}", match.Value);
          if (match.Groups[1].Success)
             Console.WriteLine("Group 1 value: {0}", match.Groups[1].Value);
          else
             Console.WriteLine("The first capturing group has no match.");
       }
    }
    // The example displays the following output:
    //       Match value: aaaccc
    //       The first capturing group has no match.
    
    Imports System.Text.RegularExpressions
    
    Module Example
        Public Sub Main()
            Dim pattern As String = "aaa(bbb)*ccc"
            Dim input As String = "aaaccc"
            Dim match As Match = Regex.Match(input, pattern)
            Console.WriteLine("Match value: {0}", match.Value)
            If match.Groups(1).Success Then
                Console.WriteLine("Group 1 value: {0}", match.Groups(1).Value)
            Else
                Console.WriteLine("The first capturing group has no match.")
            End If
        End Sub
    End Module
    ' The example displays the following output:
    '       Match value: aaaccc
    '       The first capturing group has no match.
    
  • 量指定子は、キャプチャ グループによって定義されたパターンの複数回の出現と一致できます。Quantifiers can match multiple occurrences of a pattern that is defined by a capturing group. この場合、Value オブジェクトの Length プロパティと Group プロパティには、最後にキャプチャされた部分文字列の情報のみが保持されます。In this case, the Value and Length properties of a Group object contain information only about the last captured substring. たとえば、次の正規表現は、ピリオドで終わる 1 文と一致します。For example, the following regular expression matches a single sentence that ends in a period. この正規表現では 2 つのグループ化構成体が使用されています。最初のグループ化構成体は個々の単語および空白文字をキャプチャし、2 番目のグループ化構成体は個々の単語をキャプチャします。It uses two grouping constructs: The first captures individual words along with a white-space character; the second captures individual words. この例の出力結果が示すように、正規表現では文全体が正常にキャプチャされますが、2 番目のキャプチャ グループでは最後の単語のみがキャプチャされます。As the output from the example shows, although the regular expression succeeds in capturing an entire sentence, the second capturing group captures only the last word.

    using System;
    using System.Text.RegularExpressions;
    
    public class Example
    {
       public static void Main()
       {
          string pattern = @"\b((\w+)\s?)+\.";
          string input = "This is a sentence. This is another sentence.";
          Match match = Regex.Match(input, pattern);
          if (match.Success)
          {
             Console.WriteLine("Match: " + match.Value);
             Console.WriteLine("Group 2: " + match.Groups[2].Value);
          }
       }
    }
    // The example displays the following output:
    //       Match: This is a sentence.
    //       Group 2: sentence
    
    Imports System.Text.RegularExpressions
    
    Module Example
        Public Sub Main()
            Dim pattern As String = "\b((\w+)\s?)+\."
            Dim input As String = "This is a sentence. This is another sentence."
            Dim match As Match = Regex.Match(input, pattern)
            If match.Success Then
                Console.WriteLine("Match: " + match.Value)
                Console.WriteLine("Group 2: " + match.Groups(2).Value)
            End If
        End Sub
    End Module
    ' The example displays the following output:
    '       Match: This is a sentence.
    '       Group 2: sentence
    

ページのトップへBack to top

CaptureCollectionThe Capture Collection

Group オブジェクトには、最後のキャプチャの情報のみが格納されます。The Group object contains information only about the last capture. ただし、キャプチャ グループによって行われたキャプチャのセット全体は、CaptureCollection プロパティによって返される Group.Captures オブジェクトから取得できます。However, the entire set of captures made by a capturing group is still available from the CaptureCollection object that is returned by the Group.Captures property. コレクションの各メンバーは、キャプチャ グループによって行われたキャプチャを表す Capture オブジェクトです。キャプチャされた順序 (したがって、キャプチャされた文字列が左から右に入力文字列と照合された順序) で並びます。Each member of the collection is a Capture object that represents a capture made by that capturing group, in the order in which they were captured (and, therefore, in the order in which the captured strings were matched from left to right in the input string). コレクション内の個々の Capture オブジェクトは、次のいずれかの方法で取得できます。You can retrieve individual Capture objects from the collection in either of two ways:

  • foreach (C# の場合) や For Each (Visual Basic の場合) などの構成体を使用してコレクションを反復処理する。By iterating through the collection using a construct such as foreach (in C#) or For Each (in Visual Basic).

  • CaptureCollection.Item[] プロパティを使用して特定のオブジェクトをインデックスで取得する。By using the CaptureCollection.Item[] property to retrieve a specific object by index. Item[] プロパティは、CaptureCollection オブジェクトの既定のプロパティ (Visual Basic の場合) またはインデクサー (C# の場合) です。The Item[] property is the CaptureCollection object's default property (in Visual Basic) or indexer (in C#).

量指定子がキャプチャ グループに適用されない場合、CaptureCollection オブジェクトには Capture オブジェクトと同じ一致文字列の情報が保持されるので、関心の低い単一の Group オブジェクトが含まれます。If a quantifier is not applied to a capturing group, the CaptureCollection object contains a single Capture object that is of little interest, because it provides information about the same match as its Group object. 量指定子がキャプチャ グループに適用される場合、CaptureCollection オブジェクトにはキャプチャ グループによって行われたすべてのキャプチャが含まれ、コレクションの最後のメンバーは Group オブジェクトと同じキャプチャを表します。If a quantifier is applied to a capturing group, the CaptureCollection object contains all captures made by the capturing group, and the last member of the collection represents the same capture as the Group object.

たとえば、正規表現パターン ((a(b))c)+ (量指定子 + は 1 つ以上の文字列が一致することを指定) を使用して文字列 "abcabcabc" から一致する文字列をキャプチャする場合、各 CaptureCollection オブジェクトの Group オブジェクトには、3 個のメンバーが含まれることになります。For example, if you use the regular expression pattern ((a(b))c)+ (where the + quantifier specifies one or more matches) to capture matches from the string "abcabcabc", the CaptureCollection object for each Group object contains three members.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "((a(b))c)+";
      string input = "abcabcabc";

      Match match = Regex.Match(input, pattern);
      if (match.Success)
      {
         Console.WriteLine("Match: '{0}' at position {1}",
                           match.Value, match.Index);
         GroupCollection groups = match.Groups;
         for (int ctr = 0; ctr < groups.Count; ctr++) {
            Console.WriteLine("   Group {0}: '{1}' at position {2}",
                              ctr, groups[ctr].Value, groups[ctr].Index);
            CaptureCollection captures = groups[ctr].Captures;
            for (int ctr2 = 0; ctr2 < captures.Count; ctr2++) {
               Console.WriteLine("      Capture {0}: '{1}' at position {2}",
                                 ctr2, captures[ctr2].Value, captures[ctr2].Index);
            }
         }
      }
   }
}
// The example displays the following output:
//       Match: 'abcabcabc' at position 0
//          Group 0: 'abcabcabc' at position 0
//             Capture 0: 'abcabcabc' at position 0
//          Group 1: 'abc' at position 6
//             Capture 0: 'abc' at position 0
//             Capture 1: 'abc' at position 3
//             Capture 2: 'abc' at position 6
//          Group 2: 'ab' at position 6
//             Capture 0: 'ab' at position 0
//             Capture 1: 'ab' at position 3
//             Capture 2: 'ab' at position 6
//          Group 3: 'b' at position 7
//             Capture 0: 'b' at position 1
//             Capture 1: 'b' at position 4
//             Capture 2: 'b' at position 7
Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "((a(b))c)+"
        Dim input As STring = "abcabcabc"

        Dim match As Match = Regex.Match(input, pattern)
        If match.Success Then
            Console.WriteLine("Match: '{0}' at position {1}", _
                              match.Value, match.Index)
            Dim groups As GroupCollection = match.Groups
            For ctr As Integer = 0 To groups.Count - 1
                Console.WriteLine("   Group {0}: '{1}' at position {2}", _
                                  ctr, groups(ctr).Value, groups(ctr).Index)
                Dim captures As CaptureCollection = groups(ctr).Captures
                For ctr2 As Integer = 0 To captures.Count - 1
                    Console.WriteLine("      Capture {0}: '{1}' at position {2}", _
                                      ctr2, captures(ctr2).Value, captures(ctr2).Index)
                Next
            Next
        End If
    End Sub
End Module
' The example dosplays the following output:
'       Match: 'abcabcabc' at position 0
'          Group 0: 'abcabcabc' at position 0
'             Capture 0: 'abcabcabc' at position 0
'          Group 1: 'abc' at position 6
'             Capture 0: 'abc' at position 0
'             Capture 1: 'abc' at position 3
'             Capture 2: 'abc' at position 6
'          Group 2: 'ab' at position 6
'             Capture 0: 'ab' at position 0
'             Capture 1: 'ab' at position 3
'             Capture 2: 'ab' at position 6
'          Group 3: 'b' at position 7
'             Capture 0: 'b' at position 1
'             Capture 1: 'b' at position 4
'             Capture 2: 'b' at position 7

次の例では、正規表現 (Abc)+ を使用して、文字列 "XYZAbcAbcAbcXYZAbcAb" の中から文字列 "Abc" の連続した出現を 1 つ以上検索します。The following example uses the regular expression (Abc)+ to find one or more consecutive runs of the string "Abc" in the string "XYZAbcAbcAbcXYZAbcAb". この例は、Group.Captures プロパティを使用して、キャプチャした部分文字列の複数のグループを返す方法を示しています。The example illustrates the use of the Group.Captures property to return multiple groups of captured substrings.

int counter;
Match m;
CaptureCollection cc;
GroupCollection gc;

// Look for groupings of "Abc".
var r = new Regex("(Abc)+");
// Define the string to search.
m = r.Match("XYZAbcAbcAbcXYZAbcAb");
gc = m.Groups;

// Display the number of groups.
Console.WriteLine("Captured groups = " + gc.Count.ToString());

// Loop through each group.
for (int i = 0; i < gc.Count; i++)
{
    cc = gc[i].Captures;
    counter = cc.Count;

    // Display the number of captures in this group.
    Console.WriteLine("Captures count = " + counter.ToString());

    // Loop through each capture in the group.
    for (int ii = 0; ii < counter; ii++)
    {
        // Display the capture and its position.
        Console.WriteLine(cc[ii] + "   Starts at character " +
             cc[ii].Index);
    }
}
// The example displays the following output:
//       Captured groups = 2
//       Captures count = 1
//       AbcAbcAbc   Starts at character 3
//       Captures count = 3
//       Abc   Starts at character 3
//       Abc   Starts at character 6
//       Abc   Starts at character 9
Dim counter As Integer
Dim m As Match
Dim cc As CaptureCollection
Dim gc As GroupCollection

' Look for groupings of "Abc".
Dim r As New Regex("(Abc)+")
' Define the string to search.
m = r.Match("XYZAbcAbcAbcXYZAbcAb")
gc = m.Groups

' Display the number of groups.
Console.WriteLine("Captured groups = " & gc.Count.ToString())

' Loop through each group.
Dim i, ii As Integer
For i = 0 To gc.Count - 1
    cc = gc(i).Captures
    counter = cc.Count

    ' Display the number of captures in this group.
    Console.WriteLine("Captures count = " & counter.ToString())

    ' Loop through each capture in the group.            
    For ii = 0 To counter - 1
        ' Display the capture and its position.
        Console.WriteLine(cc(ii).ToString() _
            & "   Starts at character " & cc(ii).Index.ToString())
    Next ii
Next i
' The example displays the following output:
'       Captured groups = 2
'       Captures count = 1
'       AbcAbcAbc   Starts at character 3
'       Captures count = 3
'       Abc   Starts at character 3
'       Abc   Starts at character 6
'       Abc   Starts at character 9  

ページのトップへBack to top

個々のキャプチャThe Individual Capture

Capture クラスには、単一の部分式キャプチャの結果が含まれます。The Capture class contains the results from a single subexpression capture. 一致したテキストが Capture.Value プロパティに含まれ、一致した部分文字列の入力文字列内での開始位置 (起点を 0 とする) が Capture.Index プロパティによって示されます。The Capture.Value property contains the matched text, and the Capture.Index property indicates the zero-based position in the input string at which the matched substring begins.

次の例では、選択した都市の気温の入力文字列を解析します。The following example parses an input string for the temperature of selected cities. 都市とその気温を区切るためにコンマ (",") が使用され、各都市のデータを区切るためにセミコロン (";") が使用されています。A comma (",") is used to separate a city and its temperature, and a semicolon (";") is used to separate each city's data. 入力文字列全体が単一の一致を表します。The entire input string represents a single match. 文字列の解析に使用される正規表現パターン ((\w+(\s\w+)*),(\d+);)+ では、都市名が 2 番目のキャプチャ グループに代入され、気温が 4 番目のキャプチャ グループに代入されます。In the regular expression pattern ((\w+(\s\w+)*),(\d+);)+, which is used to parse the string, the city name is assigned to the second capturing group, and the temperature is assigned to the fourth capturing group.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "Miami,78;Chicago,62;New York,67;San Francisco,59;Seattle,58;";
      string pattern = @"((\w+(\s\w+)*),(\d+);)+";
      Match match = Regex.Match(input, pattern);
      if (match.Success)
      {
         Console.WriteLine("Current temperatures:");
         for (int ctr = 0; ctr < match.Groups[2].Captures.Count; ctr++)
            Console.WriteLine("{0,-20} {1,3}", match.Groups[2].Captures[ctr].Value,
                              match.Groups[4].Captures[ctr].Value);
      }
   }
}
// The example displays the following output:
//       Current temperatures:
//       Miami                 78
//       Chicago               62
//       New York              67
//       San Francisco         59
//       Seattle               58
Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim input As String = "Miami,78;Chicago,62;New York,67;San Francisco,59;Seattle,58;"
        Dim pattern As String = "((\w+(\s\w+)*),(\d+);)+"
        Dim match As Match = Regex.Match(input, pattern)
        If match.Success Then
            Console.WriteLine("Current temperatures:")
            For ctr As Integer = 0 To match.Groups(2).Captures.Count - 1
                Console.WriteLine("{0,-20} {1,3}", match.Groups(2).Captures(ctr).Value, _
                                  match.Groups(4).Captures(ctr).Value)
            Next
        End If
    End Sub
End Module
' The example displays the following output:
'       Current temperatures:
'       Miami                 78
'       Chicago               62
'       New York              67
'       San Francisco         59
'       Seattle               58

正規表現は、次の表に示すように定義されています。The regular expression is defined as shown in the following table.

パターンPattern 説明Description
\w+ 1 つ以上の単語文字に一致します。Match one or more word characters.
(\s\w+)* 空白文字の後に 1 個以上の単語文字が続くパターンの 0 回以上の出現と一致します。Match zero or more occurrences of a white-space character followed by one or more word characters. このパターンは、複数の単語で構成される都市名と一致します。This pattern matches multi-word city names. これが 3 番目のキャプチャ グループです。This is the third capturing group.
(\w+(\s\w+)*) 1 個以上の単語文字の後に空白文字および 1 個以上の単語文字の 0 回以上の出現が続くパターンと一致します。Match one or more word characters followed by zero or more occurrences of a white-space character and one or more word characters. これが 2 番目のキャプチャ グループです。This is the second capturing group.
, コンマに一致します。Match a comma.
(\d+) 1 桁以上の数字と一致します。Match one or more digits. これが 4 番目のキャプチャ グループです。This is the fourth capturing group.
; セミコロンと一致します。Match a semicolon.
((\w+(\s\w+)*),(\d+);)+ 単語、追加の単語、コンマ、1 桁以上の数字、およびセミコロンが 1 回以上続くパターンと一致します。Match the pattern of a word followed by any additional words followed by a comma, one or more digits, and a semicolon, one or more times. これが最初のキャプチャ グループです。This is the first capturing group.

関連項目See also