Inne konstrukcje w wyrażeniach regularnych

Artykuł
03/12/2024

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ż

Język wyrażeń regularnych — podręczny wykaz

Udostępnij za pośrednictwem

Inne konstrukcje w wyrażeniach regularnych

Opcje wbudowane

Komentarz wbudowany

Komentarz końca wiersza

Zobacz też

Opinia

Dodatkowe zasoby