正規表現でのその他の構成体Miscellaneous Constructs in Regular Expressions

.NET の正規表現には、次の 3 つのその他の言語コンストラクトが含まれます。Regular expressions in .NET include three miscellaneous language constructs. 1 つは、正規表現パターンの途中で特定の一致オプションを有効または無効にすることができます。One lets you enable or disable particular matching options in the middle of a regular expression pattern. 残りの 2 つは、正規表現にコメントを含めることができます。The remaining two let you include comments in a regular expression.

インライン オプションInline Options

この構文を使用して、正規表現の一部の特定のパターン一致オプションを設定または無効にできます。You can set or disable specific pattern matching options for part of a regular expression by using the syntax

(?imnsx-imnsx)

疑問符の後に有効にするオプション、マイナス記号の後に無効にするオプションを指定します。You list the options you want to enable after the question mark, and the options you want to disable after the minus sign. 各オプションの説明を次の表に示します。The following table describes each option. 各オプションの詳細については、「正規表現のオプション」を参照してください。For more information about each option, see Regular Expression Options.

オプションOption 説明Description
i 大文字と小文字を区別しない一致。Case-insensitive matching.
m 複数行モードを指定します。Multiline mode.
n 明示的なキャプチャのみExplicit captures only. (かっこはキャプチャ グループとして機能しません)。(Parentheses do not act as capturing groups.)
s 単一行モード。Single-line mode.
x エスケープされていない空白を無視し、x モード コメントを許可します。Ignore unescaped white space, and allow x-mode comments.

(?imnsx-imnsx) コンストラクトによって定義された正規表現オプションの変更は、囲んでいるグループの末尾まで有効です。Any change in regular expression options defined by the (?imnsx-imnsx) construct remains in effect until the end of the enclosing group.

注意

(?imnsx-imnsx:subexpression) グループ化コンストラクトは、部分式と同じ機能を提供します。The (?imnsx-imnsx:subexpression) grouping construct provides identical functionality for a subexpression. 詳細については、「 グループ化構成体」を参照してください。For more information, see Grouping Constructs.

次の例では inx オプションを使用して、大文字と小文字の区別をせず、明示的なキャプチャを有効にして、正規表現の途中の正規表現パターン内の空白を無視します。The following example uses the i, n, and x options to enable case insensitivity and explicit captures, and to ignore white space in the regular expression pattern in the middle of a regular expression.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern;
      string input = "double dare double Double a Drooling dog The Dreaded Deep";

      pattern = @"\b(D\w+)\s(d\w+)\b";
      // Match pattern using default options.
      foreach (Match match in Regex.Matches(input, pattern))
      {
         Console.WriteLine(match.Value);
         if (match.Groups.Count > 1)
            for (int ctr = 1; ctr < match.Groups.Count; ctr++)
               Console.WriteLine("   Group {0}: {1}", ctr, match.Groups[ctr].Value);
      }
      Console.WriteLine();

      // Change regular expression pattern to include options.
      pattern = @"\b(D\w+)(?ixn) \s (d\w+) \b";
      // Match new pattern with options.
      foreach (Match match in Regex.Matches(input, pattern))
      {
         Console.WriteLine(match.Value);
         if (match.Groups.Count > 1)
            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:
//       Drooling dog
//          Group 1: Drooling
//          Group 2: dog
//
//       Drooling dog
//          Group 1: 'Drooling'
//       Dreaded Deep
//          Group 1: 'Dreaded'
Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String
        Dim input As String = "double dare double Double a Drooling dog The Dreaded Deep"

        pattern = "\b(D\w+)\s(d\w+)\b"
        ' Match pattern using default options.
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine(match.Value)
            If match.Groups.Count > 1 Then
                For ctr As Integer = 1 To match.Groups.Count - 1
                    Console.WriteLine("   Group {0}: {1}", ctr, match.Groups(ctr).Value)
                Next
            End If
        Next
        Console.WriteLine()

        ' Change regular expression pattern to include options.
        pattern = "\b(D\w+)(?ixn) \s (d\w+) \b"
        ' Match new pattern with options. 
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine(match.Value)
            If match.Groups.Count > 1 Then
                For ctr As Integer = 1 To match.Groups.Count - 1
                    Console.WriteLine("   Group {0}: '{1}'", ctr, match.Groups(ctr).Value)
                Next
            End If
        Next
    End Sub
End Module
' The example displays the following output:
'       Drooling dog
'          Group 1: Drooling
'          Group 2: dog
'       
'       Drooling dog
'          Group 1: 'Drooling'
'       Dreaded Deep
'          Group 1: 'Dreaded'

この例では、2 つの正規表現を定義しています。The example defines two regular expressions. 最初の \b(D\w+)\s(d\w+)\b は、大文字の "D" と小文字の "d" で始まる 2 つの連続した単語に一致します。The first, \b(D\w+)\s(d\w+)\b, matches two consecutive words that begin with an uppercase "D" and a lowercase "d". 2 つ目の正規表現 \b(D\w+)(?ixn) \s (d\w+) \b は、次の表に示すように、インライン オプションを使用して、このパターンを変更します。The second regular expression, \b(D\w+)(?ixn) \s (d\w+) \b, uses inline options to modify this pattern, as described in the following table. 結果の比較で、(?ixn) コンストラクトの効果を確認します。A comparison of the results confirms the effect of the (?ixn) construct.

パターンPattern 説明Description
\b ワード境界から開始します。Start at a word boundary.
(D\w+) 大文字 "D" の後に 1 つ以上の単語の文字が続くパターンに一致します。Match a capital "D" followed by one or more word characters. これが最初のキャプチャ グループです。This is the first capture group.
(?ixn) この時点から、大文字と小文字を区別しない比較を行い、明示的なキャプチャのみを行って、正規表現パターン内の空白を無視します。From this point on, make comparisons case-insensitive, make only explicit captures, and ignore white space in the regular expression pattern.
\s 空白文字と一致します。Match a white-space character.
(d\w+) 大文字または小文字 "d" の後に 1 つ以上の単語の文字が続くパターンに一致します。Match an uppercase or lowercase "d" followed by one or more word characters. n (明示的なキャプチャ) オプションが有効になっているため、このグループはキャプチャされません。This group is not captured because the n (explicit capture) option was enabled..
\b ワード境界に一致します。Match a word boundary.

インライン コメントInline Comment

(?# comment) コンストラクトを使用して、正規表現にインライン コメントを含めることができます。The (?# comment) construct lets you include an inline comment in a regular expression. Regex.ToString メソッドによって返される文字列にコメントが含まれますが、正規表現エンジンは、パターン マッチングでコメントのどの部分も使用しません。The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. コメントは、最初の閉じかっこで終了します。The comment ends at the first closing parenthesis.

次の例では、前のセクションの例の最初の正規表現パターンを繰り返しています。The following example repeats the first regular expression pattern from the example in the previous section. 比較で大文字小文字を区別するかどうかを示す 2 つのインライン コメントを正規表現に追加しています。It adds two inline comments to the regular expression to indicate whether the comparison is case-sensitive. 正規表現パターン \b((?# case-sensitive comparison)D\w+)\s(?ixn)((?#case-insensitive comparison)d\w+)\b は、次のように定義されます。The regular expression pattern, \b((?# case-sensitive comparison)D\w+)\s(?ixn)((?#case-insensitive comparison)d\w+)\b, is defined as follows.

パターンPattern 説明Description
\b ワード境界から開始します。Start at a word boundary.
(?# case-sensitive comparison) コメント。A comment. これは、パターンマッチング動作に影響を与えません。It does not affect pattern-matching behavior.
(D\w+) 大文字 "D" の後に 1 つ以上の単語の文字が続くパターンに一致します。Match a capital "D" followed by one or more word characters. これが最初のキャプチャ グループです。This is the first capturing group.
\s 空白文字と一致します。Match a white-space character.
(?ixn) この時点から、大文字と小文字を区別しない比較を行い、明示的なキャプチャのみを行って、正規表現パターン内の空白を無視します。From this point on, make comparisons case-insensitive, make only explicit captures, and ignore white space in the regular expression pattern.
(?#case-insensitive comparison) コメント。A comment. これは、パターンマッチング動作に影響を与えません。It does not affect pattern-matching behavior.
(d\w+) 大文字または小文字 "d" の後に 1 つ以上の単語の文字が続くパターンに一致します。Match an uppercase or lowercase "d" followed by one or more word characters. これが 2 番目のキャプチャ グループです。This is the second capture group.
\b ワード境界に一致します。Match a word boundary.
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b((?# case-sensitive comparison)D\w+)\s(?ixn)((?#case-insensitive comparison)d\w+)\b";
      Regex rgx = new Regex(pattern);
      string input = "double dare double Double a Drooling dog The Dreaded Deep";

      Console.WriteLine("Pattern: " + pattern.ToString());
      // Match pattern using default options.
      foreach (Match match in rgx.Matches(input))
      {
         Console.WriteLine(match.Value);
         if (match.Groups.Count > 1)
         {
            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:
//    Pattern: \b((?# case-sensitive comparison)D\w+)\s(?ixn)((?#case-insensitive comp
//    arison)d\w+)\b
//    Drooling dog
//       Group 1: Drooling
//    Dreaded Deep
//       Group 1: Dreaded
Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b((?# case-sensitive comparison)D\w+)\s(?ixn)((?#case-insensitive comparison)d\w+)\b"
        Dim rgx As New Regex(pattern)
        Dim input As String = "double dare double Double a Drooling dog The Dreaded Deep"

        Console.WriteLine("Pattern: " + pattern.ToString())
        ' Match pattern using default options.
        For Each match As Match In rgx.Matches(input)
            Console.WriteLine(match.Value)
            If match.Groups.Count > 1 Then
                For ctr As Integer = 1 To match.Groups.Count - 1
                    Console.WriteLine("   Group {0}: {1}", ctr, match.Groups(ctr).Value)
                Next
            End If
        Next
    End Sub
End Module
' The example displays the following output:
'    Pattern: \b((?# case-sensitive comparison)D\w+)\s(?ixn)((?#case-insensitive comp
'    arison)d\w+)\b
'    Drooling dog
'       Group 1: Drooling
'    Dreaded Deep
'       Group 1: Dreaded

行末のコメントEnd-of-Line Comment

シャープ記号 (#) は、正規表現パターンの末尾のエスケープ解除された # 文字から始まり、行の末尾まで続く x モード コメントをマークします。A number sign (#)marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. このコンストラクトを使用するには、Regex オブジェクトをインスタンス化したり、静的 Regex メソッドを呼び出したりする際に、x オプションを有効にする (インライン オプションによって) か、または option パラメーターに RegexOptions.IgnorePatternWhitespace 値を指定する必要があります。To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method.

次の例は、行末のコメント コンストラクトを示しています。The following example illustrates the end-of-line comment construct. これは、1 つ以上の書式指定項目を含む複合書式文字列かどうかを判断します。It determines whether a string is a composite format string that includes at least one format item. 次の表に、正規表現パターン内のコンストラクトを説明しています。The following table describes the constructs in the regular expression pattern:

\{\d+(,-*\d+)*(\:\w{1,4}?)*\}(?x) # Looks for a composite format item.

パターンPattern 説明Description
\{ 左中かっこと一致します。Match an opening brace.
\d+ 1 個以上の 10 進数と一致します。Match one or more decimal digits.
(,-*\d+)* 0 個または 1 つのコンマの後にオプションのマイナス記号が続き、その後に 1 つ以上の 10 進数が続くパターンと一致します。Match zero or one occurrence of a comma, followed by an optional minus sign, followed by one or more decimal digits.
(\:\w{1,4}?)* 0 個または 1 つのコロンの後に 1 ~ 4 個の、ただし可能な限り少ない空白文字が続くパターンと一致します。Match zero or one occurrence of a colon, followed by one to four, but as few as possible, white-space characters.
\} 右中かっこと一致します。Match a closing brace.
(?x) 行末のコメントが認識されるように、パターンの空白を無視するオプションを有効にします。Enable the ignore pattern white-space option so that the end-of-line comment will be recognized.
# Looks for a composite format item. 行末のコメント。An end-of-line comment.
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\{\d+(,-*\d+)*(\:\w{1,4}?)*\}(?x) # Looks for a composite format item.";
      string input = "{0,-3:F}";
      Console.WriteLine("'{0}':", input);
      if (Regex.IsMatch(input, pattern))
         Console.WriteLine("   contains a composite format item.");
      else
         Console.WriteLine("   does not contain a composite format item.");
   }
}
// The example displays the following output:
//       '{0,-3:F}':
//          contains a composite format item.
Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\{\d+(,-*\d+)*(\:\w{1,4}?)*\}(?x) # Looks for a composite format item."
        Dim input As String = "{0,-3:F}"
        Console.WriteLine("'{0}':", input)
        If Regex.IsMatch(input, pattern) Then
            Console.WriteLine("   contains a composite format item.")
        Else
            Console.WriteLine("   does not contain a composite format item.")
        End If
    End Sub
End Module
' The example displays the following output:
'       '{0,-3:F}':
'          contains a composite format item.

正規表現で (?x) コンストラクトを指定する代わりに、Regex.IsMatch(String, String, RegexOptions) メソッドを呼び出し、それに RegexOptions.IgnorePatternWhitespace 列挙値を渡して、コメントを認識させることもできることに注意してください。Note that, instead of providing the (?x) construct in the regular expression, the comment could also have been recognized by calling the Regex.IsMatch(String, String, RegexOptions) method and passing it the RegexOptions.IgnorePatternWhitespace enumeration value.

関連項目See also