Udostępnij za pośrednictwem


Inne konstrukcje w wyrażeniach regularnych

Wyrażenia regularne na platformie .NET obejmują trzy różne konstrukcje języka. Umożliwia włączenie lub wyłączenie określonych opcji dopasowania w środku wzorca wyrażenia regularnego. Pozostałe dwa umożliwiają uwzględnienie komentarzy w wyrażeniu regularnym.

Opcje wbudowane

Można ustawić lub wyłączyć określone opcje dopasowywania wzorców dla części wyrażenia regularnego przy użyciu składni

(?imnsx-imnsx)

Wyświetlisz listę opcji, które chcesz włączyć po znaku zapytania, oraz opcje, które chcesz wyłączyć po znaku minus. W tabeli poniżej opisano wszystkie opcje. Aby uzyskać więcej informacji na temat każdej opcji, zobacz Opcje wyrażeń regularnych.

Opcja Opis
i Dopasowywanie bez uwzględniania wielkości liter.
m Tryb wielowierszowy.
n Jawne przechwytywanie tylko. (Nawiasy nie działają jako przechwytywanie grup).
s Tryb jednowierszowy.
x Ignoruj niewyobrażalne białe znaki i zezwalaj na komentarze w trybie x.

Wszelkie zmiany w opcjach wyrażeń regularnych zdefiniowanych przez konstrukcję (?imnsx-imnsx) pozostają w mocy do końca otaczającej grupy.

Uwaga

Konstrukcja (?imnsx-imnsx:grupowania podexpressionów) zapewnia identyczne funkcje podexpressionu. Aby uzyskać więcej informacji, zobacz Grouping Constructs (Konstrukcje grupowania).

W poniższym przykładzie użyto iopcji , ni x w celu włączenia braku uwzględniania wielkości liter i przechwytywania jawnego oraz ignorowania białych znaków we wzorcu wyrażenia regularnego w środku wyrażenia regularnego.

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'

W przykładzie zdefiniowano dwa wyrażenia regularne. Pierwszy, \b(D\w+)\s(d\w+)\b, pasuje do dwóch kolejnych wyrazów, które zaczynają się wielkimi literami "D" i małymi literami "d". Drugie wyrażenie \b(D\w+)(?ixn) \s (d\w+) \bregularne , używa opcji wbudowanych, aby zmodyfikować ten wzorzec, zgodnie z opisem w poniższej tabeli. Porównanie wyników potwierdza efekt (?ixn) konstrukcji.

Wzorzec opis
\b Rozpoczyna na granicy wyrazu.
(D\w+) Dopasuj stolicę "D", po której następuje co najmniej jeden znak słowa. Jest to pierwsza grupa przechwytywania.
(?ixn) Od tego momentu należy dokonać porównań bez uwzględniania wielkości liter, tworzyć tylko jawne przechwytywane i ignorować białe znaki we wzorcu wyrażenia regularnego.
\s Dopasowuje znak odstępu.
(d\w+) Dopasuj wielkie lub małe litery "d", po którym następuje co najmniej jeden znak słowa. Ta grupa nie jest przechwytywana, ponieważ n włączono opcję (przechwytywanie jawne).
\b Dopasowuje granicę wyrazu.

Komentarz wbudowany

Konstrukcja komentarza (?# ) umożliwia dołączenie komentarza wbudowanego w wyrażeniu regularnym. Aparat wyrażeń regularnych nie używa żadnej części komentarza w dopasowywaniu wzorca, chociaż komentarz jest uwzględniony w ciągu zwracanym przez metodę Regex.ToString . Komentarz kończy się przy pierwszym nawiasie zamykającym.

Poniższy przykład powtarza pierwszy wzorzec wyrażenia regularnego z przykładu w poprzedniej sekcji. Dodaje dwa wbudowane komentarze do wyrażenia regularnego, aby wskazać, czy w porównaniu jest uwzględniana wielkość liter. Wzorzec wyrażenia regularnego , \b((?# case-sensitive comparison)D\w+)\s(?ixn)((?#case-insensitive comparison)d\w+)\bjest definiowany w następujący sposób.

Wzorzec opis
\b Rozpoczyna na granicy wyrazu.
(?# case-sensitive comparison) Komentarz. Nie ma to wpływu na zachowanie dopasowywania wzorców.
(D\w+) Dopasuj stolicę "D", po której następuje co najmniej jeden znak słowa. Jest to pierwsza grupa przechwytywania.
\s Dopasowuje znak odstępu.
(?ixn) Od tego momentu należy dokonać porównań bez uwzględniania wielkości liter, tworzyć tylko jawne przechwytywane i ignorować białe znaki we wzorcu wyrażenia regularnego.
(?#case-insensitive comparison) Komentarz. Nie ma to wpływu na zachowanie dopasowywania wzorców.
(d\w+) Dopasuj wielkie lub małe litery "d", po którym następuje co najmniej jeden znak słowa. Jest to druga grupa przechwytywania.
\b Dopasowuje granicę wyrazu.
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

Komentarz końca wiersza

Znak numeru (#) oznacza komentarz w trybie x, który rozpoczyna się od niewyobrażnego znaku # na końcu wzorca wyrażenia regularnego i kontynuuje do końca wiersza. Aby użyć tej konstrukcji, należy włączyć x opcję (za pośrednictwem opcji wbudowanych) lub podać RegexOptions.IgnorePatternWhitespace wartość do parametru option podczas tworzenia wystąpienia Regex obiektu lub wywoływania metody statycznej Regex .

Poniższy przykład ilustruje konstrukcję komentarza końca wiersza. Określa, czy ciąg jest ciągiem formatu złożonego, który zawiera co najmniej jeden element formatu. W poniższej tabeli opisano konstrukcje we wzorcu wyrażenia regularnego:

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

Wzorzec opis
\{ Dopasuj otwierający nawias klamrowy.
\d+ Dopasowanie do co najmniej jednej cyfry dziesiętnej.
(,-*\d+)* Dopasuj zero lub jedno wystąpienie przecinka, po którym następuje opcjonalny znak minus, po którym następuje co najmniej jedna cyfra dziesiętna.
(\:\w{1,4}?)* Dopasuj zero lub jedno wystąpienie dwukropka, po którym następuje od jednego do czterech, ale jak najmniej znaków odstępu.
\} Dopasuj nawias klamrowy zamykający.
(?x) Włącz opcję ignoruj wzorzec odstępu, aby komentarz końca wiersza został rozpoznany.
# Looks for a composite format item. Komentarz końca wiersza.
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.

Należy pamiętać, że zamiast podawania (?x) konstrukcji w wyrażeniu regularnym komentarz mógł zostać rozpoznany przez wywołanie Regex.IsMatch(String, String, RegexOptions) metody i przekazanie jej RegexOptions.IgnorePatternWhitespace wartości wyliczenia.

Zobacz też