正規表現での文字クラス

文字クラスは、いずれかが入力文字列に含まれると一致と見なされる文字のセットを定義します。 .NET の正規表現言語では、次の文字クラスがサポートされます。

• 文字グループの肯定。 入力文字列内の文字が指定した文字のセットのいずれかと一致する必要があります。 詳細については、「文字グループの肯定」を参照してください。

• 文字グループの否定。 入力文字列内の文字が指定した文字のセットのいずれかと一致しない必要があります。 詳細については、「文字グループの否定」を参照してください。

• 任意の文字。 正規表現の . (ドットまたはピリオド) 文字は、\n を除く任意の文字と一致するワイルドカード文字です。 詳細については、「任意の文字」を参照してください。

• Unicode 一般カテゴリまたは名前付きブロック。 入力文字列内の文字が一致と見なされるには、その文字が特定の Unicode カテゴリのメンバーであるか、または Unicode 文字の連続した範囲内に含まれる必要があります。 詳細については、「Unicode カテゴリまたは Unicode ブロック」を参照してください。

• Unicode 一般カテゴリまたは名前付きブロックの否定。 入力文字列内の文字が一致と見なされるには、その文字が特定の Unicode カテゴリのメンバーでないか、または Unicode 文字の連続した範囲内に含まれない必要があります。 詳細については、「Unicode カテゴリまたは Unicode ブロックの否定」を参照してください。

• 単語に使用される文字。 入力文字列内の文字が、単語内の文字に適した Unicode カテゴリのいずれかに属することができます。 詳細については、「単語に使用される文字」を参照してください。

• 単語に使用されない文字。 入力文字列内の文字が、単語に使用される文字ではない Unicode カテゴリのいずれかに属することができます。 詳細については、「単語に使用されない文字」を参照してください。

• 空白文字。 入力文字列内の文字が、Unicode 区切り記号および各種制御文字のいずれかです。 詳細については、「空白文字」を参照してください。

• 空白以外の文字。 入力文字列内の文字が、空白文字以外の文字のいずれかです。 詳細については、「空白以外の文字」を参照してください。

• 10 進数。 入力文字列内の文字が、Unicode 10 進数に分類される各種文字のいずれかです。 詳細については、「10 進数字」を参照してください。

• 10 進数字以外の文字。 入力文字列内の文字が、Unicode 10 進数以外の文字のいずれかです。 詳細については、「10 進数字」を参照してください。

.NET は、文字クラスの減算式をサポートしています。これにより、ある文字クラスから別の文字クラスを除外した結果を文字のセットとして定義できます。 詳細については、「文字クラス減算」を参照してください。

文字グループの肯定では、いずれかが入力文字列に含まれると一致と見なされる文字の一覧を指定します。 この文字の一覧は、個別に指定されることも範囲として指定されることも、その両方であることもあります。

個別の文字の一覧を指定する構文は次のとおりです。

[*character_group*]

ここで、character_group は、入力文字列に含まれるなら一致と見なされる個別の文字の一覧です。 character_group は、リテラル文字、エスケープ文字、または文字クラスを 1 つ以上組み合わせて構成されます。

文字の範囲を指定する構文は次のとおりです。

[firstCharacter-lastCharacter]

ここで、firstCharacter は範囲の最初の文字で、lastCharacter は範囲の最後の文字です。 文字範囲は連続する一連の文字で、範囲の最初の文字、ハイフン (-)、および範囲の最後の文字を指定することで定義されます。 2 つの文字の Unicode コード ポイントが隣接している場合、それらの文字は連続しています。 firstCharacter は、より低いコード ポイントを持つ文字にする必要があります。lastCharacter はより高いコード ポイントを持つ文字にする必要があります。

ハイフンを文字グループの非周辺的なメンバーとして含めるには、それをエスケープします。 たとえば、文字 a と - から /までの文字の文字グループを作成するには、正しい構文は [a\--/] です。

文字クラスの肯定を含む一般的な正規表現パターンをいくつか次の表に示します。

次の例では、"a" および "e" という文字を含む文字グループの肯定を定義し、入力文字列内で "grey" または "gray" という語の後に別の語が続くと一致と見なされるようにします。

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"gr[ae]y\s\S+?[\s\p{P}]";
      string input = "The gray wolf jumped over the grey wall.";
      MatchCollection matches = Regex.Matches(input, pattern);
      foreach (Match match in matches)
         Console.WriteLine($"'{match.Value}'");
   }
}
// The example displays the following output:
//       'gray wolf '
//       'grey wall.'

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "gr[ae]y\s\S+?[\s\p{P}]"
        Dim input As String = "The gray wolf jumped over the grey wall."
        Dim matches As MatchCollection = Regex.Matches(input, pattern)
        For Each match As Match In matches
            Console.WriteLine($"'{match.Value}'")
        Next
    End Sub
End Module
' The example displays the following output:
'       'gray wolf '
'       'grey wall.'

正規表現パターン gr[ae]y\s\S+?[\s|\p{P}] は、次のように定義されます。

次の例は、大文字で始まる語と一致します。 部分式 [A-Z] を使用して、A から Z の範囲の大文字を表します。

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b[A-Z]\w*\b";
      string input = "A city Albany Zulu maritime Marseilles";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       A
//       Albany
//       Zulu
//       Marseilles

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b[A-Z]\w*\b"
        Dim input As String = "A city Albany Zulu maritime Marseilles"
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine(match.Value)
        Next
    End Sub
End Module

正規表現 \b[A-Z]\w*\b は、次の表に示すように定義されています。

文字グループの否定では、入力文字列に含まれなければ一致と見なされる文字の一覧を指定します。 この文字の一覧は、個別に指定されることも範囲として指定されることも、その両方であることもあります。

個別の文字の一覧を指定する構文は次のとおりです。

[*^character_group*]

ここで、character_group は、入力文字列に含まれない場合に一致と見なされる個別の文字の一覧です。 character_group は、リテラル文字、エスケープ文字、または文字クラスを 1 つ以上組み合わせて構成されます。

文字の範囲を指定する構文は次のとおりです。

[^*firstCharacter*-*lastCharacter*]

ここで、firstCharacter は範囲の最初の文字で、lastCharacter は範囲の最後の文字です。 文字範囲は連続する一連の文字で、範囲の最初の文字、ハイフン (-)、および範囲の最後の文字を指定することで定義されます。 2 つの文字の Unicode コード ポイントが隣接している場合、それらの文字は連続しています。 firstCharacter は、より低いコード ポイントを持つ文字にする必要があります。lastCharacter はより高いコード ポイントを持つ文字にする必要があります。

複数の文字範囲を連結することもできます。 たとえば、"0" ～ "9" の範囲の 10 進数、"a" ～ "f" の範囲の小文字、および "A" ～ "F" の範囲の大文字を指定するには、[0-9a-fA-F] を使用します。

文字グループの否定における先頭のキャレット文字 (^) は、文字グループが文字グループの肯定ではなく文字グループの否定であることを示し、省略できません。

文字グループの否定を含む一般的な正規表現パターンをいくつか次の表に示します。

次の例は、"th" という文字で始まってその後に "o" が続かない語と一致します。

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\bth[^o]\w+\b";
      string input = "thought thing though them through thus thorough this";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       thing
//       them
//       through
//       thus
//       this

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\bth[^o]\w+\b"
        Dim input As String = "thought thing though them through thus " + _
                              "thorough this"
        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:
'       thing
'       them
'       through
'       thus
'       this

正規表現 \bth[^o]\w+\b は、次の表に示すように定義されています。

ピリオド文字 (.) は、\n (改行文字) を除く任意の文字と一致しますが、次の 2 つの制限があります。

• 正規表現パターンが RegexOptions.Singleline オプションで修飾されている場合、または . 文字クラスを含むパターンの一部が s オプションで修飾されている場合は、. は任意の文字と一致します。 詳細については、「 正規表現のオプション」を参照してください。

  . 文字クラスの既定の動作と RegexOptions.Singleline オプションが指定されている場合の動作の違いの例を次に示します。 正規表現 ^.+ は文字列の先頭から開始し、すべての文字と一致します。 既定では、照合は 1 行目の末尾で終了します。正規表現パターンは復帰文字 \r と一致しますが、\n とは一致しません。 RegexOptions.Singleline オプションは入力文字列全体を単一行として解釈するので、\n を含む入力文字列内のすべての文字と一致します。

  C# コピー

  using System;
  using System.Text.RegularExpressions;
  
  public class Example
  {
     public static void Main()
     {
        string pattern = "^.+";
        string input = "This is one line and" + Environment.NewLine + "this is the second.";
        foreach (Match match in Regex.Matches(input, pattern))
           Console.WriteLine(Regex.Escape(match.Value));
  
        Console.WriteLine();
        foreach (Match match in Regex.Matches(input, pattern, RegexOptions.Singleline))
           Console.WriteLine(Regex.Escape(match.Value));
     }
  }
  // The example displays the following output:
  //       This\ is\ one\ line\ and\r
  //
  //       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.
  

• 文字グループの肯定または文字グループの否定に含まれているピリオドは、文字クラスではなくリテラルのピリオド文字として扱われます。 詳細については、このトピックで前述した「文字グループの肯定」および「文字グループの否定」を参照してください。 ピリオド文字 (.) を文字クラスとしても文字グループの肯定のメンバーとしても含む正規表現を定義する例を次に示します。 正規表現 \b.*[.?!;:](\s|\z) はワード境界から開始し、ピリオドを含む 5 つの句読点のいずれかが検出されるまで任意の文字と一致し、空白文字または文字列の末尾と一致します。

  C# コピー

  using System;
  using System.Text.RegularExpressions;
  
  public class Example
  {
     public static void Main()
     {
        string pattern = @"\b.*[.?!;:](\s|\z)";
        string input = "this. what: is? go, thing.";
        foreach (Match match in Regex.Matches(input, pattern))
           Console.WriteLine(match.Value);
     }
  }
  // The example displays the following output:
  //       this. what: is? go, thing.
  

Unicode 規格では、各文字に一般カテゴリが割り当てられています。 たとえば、特定の文字は、英大文字 (Lu カテゴリで表されます)、10 進数 (Nd カテゴリ)、数学記号 (Sm カテゴリ)、または段落区切り記号 (Zl カテゴリ) に分類できます。 また、Unicode 規格の特定の文字セットは、特定の範囲またはブロックの連続したコード ポイントに対応します。 たとえば、基本的なラテン語文字セットは \u0000 ～ \u007F で、アラビア語文字セットは \u0600 ～ \u06FF です。

正規表現の構成要素

\p{ name }

Unicode 一般カテゴリまたは名前付きブロックに属する任意の文字と一致します。ここで、name はカテゴリの省略形または名前付きブロックの名前です。 カテゴリの省略形の一覧については、このトピックで後述する「サポートされている Unicode 一般カテゴリ」を参照してください。 名前付きブロックの一覧については、このトピックで後述する「サポートされている名前付きブロック」を参照してください。

\p{name} 構成要素を使用して Unicode 一般カテゴリ (この場合は Pd (Punctuation, Dash: 句読点、ダッシュ) カテゴリ) と名前付きブロック (IsGreek 名前付きブロックおよび IsBasicLatin 名前付きブロック) の両方を照合する例を次に示します。

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+";
      string input = "Κατα Μαθθαίον - The Gospel of Matthew";

      Console.WriteLine(Regex.IsMatch(input, pattern));        // Displays True.
   }
}

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+"
        Dim input As String = "Κατα Μαθθαίον - The Gospel of Matthew"

        Console.WriteLine(Regex.IsMatch(input, pattern))         ' Displays True.
    End Sub
End Module

正規表現 \b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+ は、次の表に示すように定義されています。

Unicode 規格では、各文字に一般カテゴリが割り当てられています。 たとえば、特定の文字は、英大文字 (Lu カテゴリで表されます)、10 進数 (Nd カテゴリ)、数学記号 (Sm カテゴリ)、または段落区切り記号 (Zl カテゴリ) に分類できます。 また、Unicode 規格の特定の文字セットは、特定の範囲またはブロックの連続したコード ポイントに対応します。 たとえば、基本的なラテン語文字セットは \u0000 ～ \u007F で、アラビア語文字セットは \u0600 ～ \u06FF です。

正規表現の構成要素

\P{ name }

Unicode 一般カテゴリにも名前付きブロックにも属さない任意の文字と一致します。ここで、name はカテゴリの省略形または名前付きブロックの名前です。 カテゴリの省略形の一覧については、このトピックで後述する「サポートされている Unicode 一般カテゴリ」を参照してください。 名前付きブロックの一覧については、このトピックで後述する「サポートされている名前付きブロック」を参照してください。

\P{name} 構成要素を使用して通貨記号 (この場合は Sc (Symbol, Currency: 記号、通貨) カテゴリ) を数値文字列から削除する例を次に示します。

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\P{Sc})+";

      string[] values = { "$164,091.78", "£1,073,142.68", "73¢", "€120" };
      foreach (string value in values)
         Console.WriteLine(Regex.Match(value, pattern).Value);
   }
}
// The example displays the following output:
//       164,091.78
//       1,073,142.68
//       73
//       120

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "(\P{Sc})+"

        Dim values() As String = {"$164,091.78", "£1,073,142.68", "73¢", "€120"}
        For Each value As String In values
            Console.WriteLine(Regex.Match(value, pattern).Value)
        Next
    End Sub
End Module
' The example displays the following output:
'       164,091.78
'       1,073,142.68
'       73
'       120

正規表現パターン (\P{Sc})+ は、通貨記号以外の 1 つ以上の文字と一致し、実質的に結果文字列から通貨記号を削除します。

\w は、単語に使用される任意の文字と一致します。 単語に使用される文字は、次の表に示す Unicode カテゴリのメンバーです。

ECMAScript 準拠の動作が指定された場合、\w は [a-zA-Z_0-9] と同じになります。 ECMAScript 正規表現の詳細については、「正規表現のオプション」の「ECMAScript 一致の動作」のセクションを参照してください。

\w 言語要素を使用して単語内の重複する文字を照合する例を次に示します。 この例では、次のように解釈できる正規表現パターン (\w)\1 を定義しています。

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\w)\1";
      string[] words = { "trellis", "seer", "latter", "summer",
                         "hoarse", "lesser", "aardvark", "stunned" };
      foreach (string word in words)
      {
         Match match = Regex.Match(word, pattern);
         if (match.Success)
            Console.WriteLine($"'{match.Value}' found in '{word}' at position {match.Index}.");
         else
            Console.WriteLine($"No double characters in '{word}'.");
      }
   }
}
// The example displays the following output:
//       'll' found in 'trellis' at position 3.
//       'ee' found in 'seer' at position 1.
//       'tt' found in 'latter' at position 2.
//       'mm' found in 'summer' at position 2.
//       No double characters in 'hoarse'.
//       'ss' found in 'lesser' at position 2.
//       'aa' found in 'aardvark' at position 0.
//       'nn' found in 'stunned' at position 3.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "(\w)\1"
        Dim words() As String = {"trellis", "seer", "latter", "summer", _
                                  "hoarse", "lesser", "aardvark", "stunned"}
        For Each word As String In words
            Dim match As Match = Regex.Match(word, pattern)
            If match.Success Then
                Console.WriteLine("'{0}' found in '{1}' at position {2}.", _
                                  match.Value, word, match.Index)
            Else
                Console.WriteLine("No double characters in '{0}'.", word)
            End If
        Next
    End Sub
End Module
' The example displays the following output:
'       'll' found in 'trellis' at position 3.
'       'ee' found in 'seer' at position 1.
'       'tt' found in 'latter' at position 2.
'       'mm' found in 'summer' at position 2.
'       No double characters in 'hoarse'.
'       'ss' found in 'lesser' at position 2.
'       'aa' found in 'aardvark' at position 0.
'       'nn' found in 'stunned' at position 3.

\W は、単語に使用される文字以外の任意の文字と一致します。 \W 言語要素は、次の文字クラスと同じ結果をもたらします。

[^\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}]

つまり、次の表に示す Unicode カテゴリの文字を除く任意の文字と一致します。

ECMAScript 準拠の動作が指定された場合、\W は [^a-zA-Z_0-9] と同じになります。 ECMAScript 正規表現の詳細については、「正規表現のオプション」の「ECMAScript 一致の動作」のセクションを参照してください。

\W 文字クラスの例を次に示します。 この例では、単語の後に 1 つまたは 2 つの単語に使用されない文字 (空白や句読点など) が続く場合に一致する正規表現パターン \b(\w+)(\W){1,2} を定義しています。 この正規表現の解釈を次の表に示します。

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\w+)(\W){1,2}";
      string input = "The old, grey mare slowly walked across the narrow, green pasture.";
      foreach (Match match in Regex.Matches(input, pattern))
      {
         Console.WriteLine(match.Value);
         Console.Write("   Non-word character(s):");
         CaptureCollection captures = match.Groups[2].Captures;
         for (int ctr = 0; ctr < captures.Count; ctr++)
             Console.Write(@"'{0}' (\u{1}){2}", captures[ctr].Value,
                           Convert.ToUInt16(captures[ctr].Value[0]).ToString("X4"),
                           ctr < captures.Count - 1 ? ", " : "");
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//       The
//          Non-word character(s):' ' (\u0020)
//       old,
//          Non-word character(s):',' (\u002C), ' ' (\u0020)
//       grey
//          Non-word character(s):' ' (\u0020)
//       mare
//          Non-word character(s):' ' (\u0020)
//       slowly
//          Non-word character(s):' ' (\u0020)
//       walked
//          Non-word character(s):' ' (\u0020)
//       across
//          Non-word character(s):' ' (\u0020)
//       the
//          Non-word character(s):' ' (\u0020)
//       narrow,
//          Non-word character(s):',' (\u002C), ' ' (\u0020)
//       green
//          Non-word character(s):' ' (\u0020)
//       pasture.
//          Non-word character(s):'.' (\u002E)

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b(\w+)(\W){1,2}"
        Dim input As String = "The old, grey mare slowly walked across the narrow, green pasture."
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine(match.Value)
            Console.Write("   Non-word character(s):")
            Dim captures As CaptureCollection = match.Groups(2).Captures
            For ctr As Integer = 0 To captures.Count - 1
                Console.Write("'{0}' (\u{1}){2}", captures(ctr).Value, _
                              Convert.ToUInt16(captures(ctr).Value.Chars(0)).ToString("X4"), _
                              If(ctr < captures.Count - 1, ", ", ""))
            Next
            Console.WriteLine()
        Next
    End Sub
End Module
' The example displays the following output:
'       The
'          Non-word character(s):' ' (\u0020)
'       old,
'          Non-word character(s):',' (\u002C), ' ' (\u0020)
'       grey
'          Non-word character(s):' ' (\u0020)
'       mare
'          Non-word character(s):' ' (\u0020)
'       slowly
'          Non-word character(s):' ' (\u0020)
'       walked
'          Non-word character(s):' ' (\u0020)
'       across
'          Non-word character(s):' ' (\u0020)
'       the
'          Non-word character(s):' ' (\u0020)
'       narrow,
'          Non-word character(s):',' (\u002C), ' ' (\u0020)
'       green
'          Non-word character(s):' ' (\u0020)
'       pasture.
'          Non-word character(s):'.' (\u002E)

2 番目のキャプチャ グループの Group オブジェクトには、キャプチャされた単語に使用されない文字が 1 つだけ含まれるので、この例では、CaptureCollection プロパティによって返される Group.Captures オブジェクトから、キャプチャされたすべての単語に使用されない文字を取得します。

\s は任意の空白文字と一致します。 次の表に示すエスケープ シーケンスおよび Unicode カテゴリと同じ結果をもたらします。

ECMAScript 準拠の動作が指定された場合、\s は [ \f\n\r\t\v] と同じになります。 ECMAScript 正規表現の詳細については、「正規表現のオプション」の「ECMAScript 一致の動作」のセクションを参照してください。

\s 文字クラスの例を次に示します。 この例では、"s" または "es" で終わる単語の後に空白文字または入力文字列の末尾が続く場合に一致する正規表現パターン \b\w+(e)?s(\s|$) を定義しています。 この正規表現の解釈を次の表に示します。

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+(e)?s(\s|$)";
      string input = "matches stores stops leave leaves";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       matches
//       stores
//       stops
//       leaves

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b\w+(e)?s(\s|$)"
        Dim input As String = "matches stores stops leave leaves"
        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:
'       matches
'       stores
'       stops
'       leaves

\S は、空白文字以外の任意の文字と一致します。 [^\f\n\r\t\v\x85\p{Z}] 正規表現パターン、または空白文字と一致する \s に相当する正規表現パターンの逆と同じ結果をもたらします。 詳細については、「空白文字: \s」を参照してください。

ECMAScript 準拠の動作が指定された場合、\S は [^ \f\n\r\t\v] と同じになります。 ECMAScript 正規表現の詳細については、「正規表現のオプション」の「ECMAScript 一致の動作」のセクションを参照してください。

\S 言語要素の例を次に示します。 正規表現パターン \b(\S+)\s? は、空白文字で区切られた文字列と一致します。 一致部分の GroupCollection オブジェクトの 2 番目の要素に一致する文字列が含まれます。 この正規表現の解釈を次の表に示します。

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\S+)\s?";
      string input = "This is the first sentence of the first paragraph. " +
                            "This is the second sentence.\n" +
                            "This is the only sentence of the second paragraph.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Groups[1]);
   }
}
// The example displays the following output:
//    This
//    is
//    the
//    first
//    sentence
//    of
//    the
//    first
//    paragraph.
//    This
//    is
//    the
//    second
//    sentence.
//    This
//    is
//    the
//    only
//    sentence
//    of
//    the
//    second
//    paragraph.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b(\S+)\s?"
        Dim input As String = "This is the first sentence of the first paragraph. " + _
                              "This is the second sentence." + vbCrLf + _
                              "This is the only sentence of the second paragraph."
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine(match.Groups(1))
        Next
    End Sub
End Module
' The example displays the following output:
'    This
'    is
'    the
'    first
'    sentence
'    of
'    the
'    first
'    paragraph.
'    This
'    is
'    the
'    second
'    sentence.
'    This
'    is
'    the
'    only
'    sentence
'    of
'    the
'    second
'    paragraph.

\d は、10 進数字と一致します。 標準の 10 進数 0 ～ 9 およびその他の各種文字セットの 10 進数を含む \p{Nd} 正規表現パターンと同じ結果をもたらします。

ECMAScript 準拠の動作が指定された場合、\d は [0-9] と同じになります。 ECMAScript 正規表現の詳細については、「正規表現のオプション」の「ECMAScript 一致の動作」のセクションを参照してください。

\d 言語要素の例を次に示します。 この例では、入力文字列が米国およびカナダの有効な電話番号を表すかどうかをテストします。 正規表現パターン ^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$ は、次の表に示すように定義されています。

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$";
      string[] inputs = { "111 111-1111", "222-2222", "222 333-444",
                          "(212) 111-1111", "111-AB1-1111",
                          "212-111-1111", "01 999-9999" };

      foreach (string input in inputs)
      {
         if (Regex.IsMatch(input, pattern))
            Console.WriteLine(input + ": matched");
         else
            Console.WriteLine(input + ": match failed");
      }
   }
}
// The example displays the following output:
//       111 111-1111: matched
//       222-2222: matched
//       222 333-444: match failed
//       (212) 111-1111: matched
//       111-AB1-1111: match failed
//       212-111-1111: matched
//       01 999-9999: match failed

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$"
        Dim inputs() As String = {"111 111-1111", "222-2222", "222 333-444", _
                                   "(212) 111-1111", "111-AB1-1111", _
                                   "212-111-1111", "01 999-9999"}

        For Each input As String In inputs
            If Regex.IsMatch(input, pattern) Then
                Console.WriteLine(input + ": matched")
            Else
                Console.WriteLine(input + ": match failed")
            End If
        Next
    End Sub
End Module
' The example displays the following output:
'       111 111-1111: matched
'       222-2222: matched
'       222 333-444: match failed
'       (212) 111-1111: matched
'       111-AB1-1111: match failed
'       212-111-1111: matched
'       01 999-9999: match failed

\D は、数字以外の文字と一致します。 \P{Nd} 正規表現パターンと同じ結果をもたらします。

ECMAScript 準拠の動作が指定された場合、\D は [^0-9] と同じになります。 ECMAScript 正規表現の詳細については、「正規表現のオプション」の「ECMAScript 一致の動作」のセクションを参照してください。

\D 言語要素の例を次に示します。 部品番号などの文字列が 10 進数および 10 進数以外の文字を適切に組み合わせて構成されているかどうかをテストします。 正規表現パターン ^\D\d{1,5}\D*$ は、次の表に示すように定義されています。

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"^\D\d{1,5}\D*$";
      string[] inputs = { "A1039C", "AA0001", "C18A", "Y938518" };

      foreach (string input in inputs)
      {
         if (Regex.IsMatch(input, pattern))
            Console.WriteLine(input + ": matched");
         else
            Console.WriteLine(input + ": match failed");
      }
   }
}
// The example displays the following output:
//       A1039C: matched
//       AA0001: match failed
//       C18A: matched
//       Y938518: match failed

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "^\D\d{1,5}\D*$"
        Dim inputs() As String = {"A1039C", "AA0001", "C18A", "Y938518"}

        For Each input As String In inputs
            If Regex.IsMatch(input, pattern) Then
                Console.WriteLine(input + ": matched")
            Else
                Console.WriteLine(input + ": match failed")
            End If
        Next
    End Sub
End Module
' The example displays the following output:

Unicode は、次の表に示されている一般カテゴリを定義しています。 詳細については、「Unicode Character Database (Unicode 文字データベース)」内の「UCD File Format (UCD ファイル形式)」および「General Category Values (一般カテゴリの値)」の各サブトピックを参照してください (セクション 5.7.1、表 12)。

特定の文字の Unicode カテゴリを確認するには、その文字を GetUnicodeCategory メソッドに渡します。 GetUnicodeCategory メソッドを使用して、選択したラテン文字を含む配列の各要素のカテゴリを確認する例を次に示します。

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      char[] chars = { 'a', 'X', '8', ',', ' ', '\u0009', '!' };

      foreach (char ch in chars)
         Console.WriteLine($"'{Regex.Escape(ch.ToString())}': {Char.GetUnicodeCategory(ch)}");
   }
}
// The example displays the following output:
//       'a': LowercaseLetter
//       'X': UppercaseLetter
//       '8': DecimalDigitNumber
//       ',': OtherPunctuation
//       '\ ': SpaceSeparator
//       '\t': Control
//       '!': OtherPunctuation

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim chars() As Char = {"a"c, "X"c, "8"c, ","c, " "c, ChrW(9), "!"c}

        For Each ch As Char In chars
            Console.WriteLine("'{0}': {1}", Regex.Escape(ch.ToString()), _
                              Char.GetUnicodeCategory(ch))
        Next
    End Sub
End Module
' The example displays the following output:
'       'a': LowercaseLetter
'       'X': UppercaseLetter
'       '8': DecimalDigitNumber
'       ',': OtherPunctuation
'       '\ ': SpaceSeparator
'       '\t': Control
'       '!': OtherPunctuation

.NET には、次の表に示す名前付きブロックが用意されています。 サポートされている一連の名前付きブロックは、Unicode 4.0 および Perl 5.6 に基づいています。 名前付きブロックを使用する正規表現については、「Unicode カテゴリまたは Unicode ブロック: \p{}」セクションを参照してください。

文字クラスは、文字のセットを定義します。 文字クラス減算によって、ある文字クラスから別の文字クラスの文字を除外した文字セットが生成されます。

文字クラス減算式の形式は次のとおりです。

[ base_group -[ excluded_group ]]

角かっこ ([]) とハイフン (-) は省略できません。 base_group は、文字グループの肯定または文字グループの否定です。 excluded_group は、別の文字グループの肯定または文字グループの否定、あるいは別の文字クラス減算式です (つまり文字クラス減算式は入れ子にすることができます)。

たとえば、"a" ～ "z" の文字範囲で構成される基本グループがあるとします。 "m" を除外した基本グループで構成される文字のセットを定義するには、[a-z-[m]] を使用します。 "d"、"j" および "p" の文字を除外した基本グループで構成される文字のセットを定義するには、[a-z-[djp]] を使用します。 "m" ～ "p" の文字範囲を除外した基本グループで構成される文字のセットを定義するには、[a-z-[m-p]] を使用します。

入れ子になった文字クラス減算式 [a-z-[d-w-[m-o]]] について考えてみます。 この式は、最も内部の文字範囲から順に外側へと評価されます。 まず、"m" ～ "o" の文字範囲が "d" ～ "w" の文字範囲から減算されて、"d" ～ "l" および "p" ～ "w" の文字セットが生成されます。 さらにこのセットが "a" ～ "z" の文字範囲から減算されて、[abcmnoxyz] という文字セットが生成されます。

文字クラス減算では、任意の文字クラスを使用できます。 \u0000 ～ \uFFFF の Unicode 文字から空白文字 (\s)、句読点一般カテゴリの文字 (\p{P})、IsGreek 名前付きブロック内の文字 (\p{IsGreek})、および Unicode NEXT LINE 制御文字 (\x85) を除いた文字のセットを定義するには、[\u0000-\uFFFF-[\s\p{P}\p{IsGreek}\x85]] を使用します。

有効な結果を生成する文字クラス減算式の文字クラスを選択します。 どの文字にも一致しない空の文字セットを生成する式、または元の基本グループと同じになる式は避けてください。 たとえば、[\p{IsBasicLatin}-[\x00-\x7F]] という式は、IsBasicLatin 一般カテゴリから IsBasicLatin 文字範囲のすべての文字を減算して空のセットを生成します。 同様に、[a-z-[0-9]] という式は元の基本グループと同じセットを生成します。 これは、"a" ～ "z" の文字範囲である基本グループに、"0" ～ "9" という 10 進数字の文字範囲から成る除外対象グループ内の文字が含まれないためです。

入力文字列内の 0 および奇数と一致する正規表現 ^[0-9-[2468]]+$ を定義する例を次に示します。 この正規表現の解釈を次の表に示します。

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] inputs = { "123", "13579753", "3557798", "335599901" };
      string pattern = @"^[0-9-[2468]]+$";

      foreach (string input in inputs)
      {
         Match match = Regex.Match(input, pattern);
         if (match.Success)
            Console.WriteLine(match.Value);
      }
   }
}
// The example displays the following output:
//       13579753
//       335599901

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim inputs() As String = {"123", "13579753", "3557798", "335599901"}
        Dim pattern As String = "^[0-9-[2468]]+$"

        For Each input As String In inputs
            Dim match As Match = Regex.Match(input, pattern)
            If match.Success Then Console.WriteLine(match.Value)
        Next
    End Sub
End Module
' The example displays the following output:
'       13579753
'       335599901

• GetUnicodeCategory
• 正規表現言語 - クイック リファレンス
• 正規表現のオプション