Různé konstrukce v regulárních výrazech

Článek
03/12/2024

Regulární výrazy v .NET obsahují tři různé jazykové konstrukce. Jeden umožňuje povolit nebo zakázat konkrétní odpovídající možnosti uprostřed vzoru regulárního výrazu. Zbývající dva umožňují zahrnout komentáře do regulárního výrazu.

Vložené možnosti

Pomocí syntaxe můžete nastavit nebo zakázat konkrétní možnosti porovnávání vzorů pro část regulárního výrazu.

(?imnsx-imnsx)

Zobrazíte seznam možností, které chcete povolit po otazníku, a možnosti, které chcete zakázat po znaménku minus. Jednotlivé možnosti jsou popsány v následující tabulce. Další informace o jednotlivých možnostech naleznete v tématu Možnosti regulárního výrazu.

Možnost	Popis
`i`	Porovnávání nerozlišující malá a velká písmena.
`m`	Víceřádkový režim.
`n`	Explicitní zachycení. (Závorky nefungují jako zachytávání skupin.)
`s`	Jednořádkový režim.
`x`	Ignorujte neuskutečené prázdné znaky a povolte komentáře v režimu x.

Všechny změny v možnostech regulárního výrazu definované konstruktorem (?imnsx-imnsx) zůstanou platné až do konce uzavřené skupiny.

Poznámka:

Konstruktor (?imnsx-imnsx:seskupení dílčího výrazu) poskytuje identické funkce pro dílčí výraz. Další informace naleznete v tématu Seskupování konstruktorů.

Následující příklad používá i, na x možnosti k povolení rozlišování malých a explicitních zachycení a ignorování prázdných znaků v vzoru regulárního výrazu uprostřed regulárního výrazu.

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'

Příklad definuje dva regulární výrazy. První, \b(D\w+)\s(d\w+)\bodpovídá dvěma po sobě jdoucím slovem, která začínají velkými písmeny "D" a malými písmeny "d". Druhý regulární výraz \b(D\w+)(?ixn) \s (d\w+) \b, používá vložené možnosti k úpravě tohoto vzoru, jak je popsáno v následující tabulce. Porovnání výsledků potvrzuje účinek konstruktoru (?ixn) .

Vzor	Popis
`\b`	Začne na hranici slova.
`(D\w+)`	Porovná velké písmeno "D" následované jedním nebo více znaky slova. Toto je první skupina zachycení.
`(?ixn)`	Od tohoto okamžiku při porovnávání nerozlišujte malá a velká písmena, zachyťte pouze explicitní zachycení a ignorujte prázdné znaky ve vzoru regulárního výrazu.
`\s`	Porovná prázdný znak.
`(d\w+)`	Porovná velká nebo malá písmena "d" následovaná jedním nebo více znaky slova. Tato skupina není zachycena, protože `n` byla povolena možnost (explicitní zachycení).
`\b`	Porovná hranici slova.

Vložený komentář

Konstruktor (?#komentáře) umožňuje zahrnout vložený komentář do regulárního výrazu. Modul regulárních výrazů nepoužívá žádnou část komentáře ve porovnávání vzorů, ačkoli komentář je součástí řetězce, který je vrácen metodou Regex.ToString . Komentář končí první pravou závorkou.

Následující příklad zopakuje první vzor regulárního výrazu z příkladu v předchozí části. Do regulárního výrazu se přidají dva vložené komentáře, které označují, jestli porovnání nerozlišuje malá a velká písmena. Vzor regulárního výrazu \b((?# case-sensitive comparison)D\w+)\s(?ixn)((?#case-insensitive comparison)d\w+)\bje definován následujícím způsobem.

Vzor	Popis
`\b`	Začne na hranici slova.
`(?# case-sensitive comparison)`	Komentář. Nemá vliv na chování porovnávání vzorů.
`(D\w+)`	Porovná velké písmeno "D" následované jedním nebo více znaky slova. Toto je první zachytávající skupina.
`\s`	Porovná prázdný znak.
`(?ixn)`	Od tohoto okamžiku při porovnávání nerozlišujte malá a velká písmena, zachyťte pouze explicitní zachycení a ignorujte prázdné znaky ve vzoru regulárního výrazu.
`(?#case-insensitive comparison)`	Komentář. Nemá vliv na chování porovnávání vzorů.
`(d\w+)`	Porovná velká nebo malá písmena "d" následovaná jedním nebo více znaky slova. Toto je druhá skupina zachycení.
`\b`	Porovná hranici slova.

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

Komentář na konci řádku

Znak čísla (#) označuje komentář v režimu x, který začíná znakem # na konci vzoru regulárního výrazu a pokračuje až do konce řádku. Chcete-li použít tento konstruktor, musíte buď povolit x možnost (prostřednictvím vložených možností), nebo zadat RegexOptions.IgnorePatternWhitespace hodnotu option parametru při vytváření instance objektu Regex nebo volání statické Regex metody.

Následující příklad znázorňuje konstruktor komentáře na konci řádku. Určuje, zda je řetězec složeným formátovacím řetězcem, který obsahuje alespoň jednu položku formátu. Následující tabulka popisuje konstrukce v vzoru regulárního výrazu:

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

Vzor	Popis
`\{`	Porovná levou složenou závorku.
`\d+`	Porovná jednu nebo více desítkových číslic.
`(,-\d+)`	Porovná žádný nebo jeden výskyt čárky následované volitelným znaménkem minus následovaným jednou nebo více desetinnými číslicemi.
`(\:\w{1,4}?)*`	Porovná žádný nebo jeden výskyt dvojtečky a za ním jeden až čtyři, ale co nejméně prázdných znaků.
`\}`	Porovná pravou složenou závorku.
`(?x)`	Povolte možnost ignorovat vzor prázdné znaky, aby se rozpoznal koncový komentář.
`# Looks for a composite format item.`	Koncový komentář.

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.

Všimněte si, že místo poskytnutí konstruktoru (?x) v regulárním výrazu by komentář mohl být také rozpoznán voláním Regex.IsMatch(String, String, RegexOptions) metody a předáním hodnoty výčtu RegexOptions.IgnorePatternWhitespace .

Viz také

Jazyk regulárních výrazů – stručná referenční dokumentace

Různé konstrukce v regulárních výrazech

Vložené možnosti

Vložený komentář

Komentář na konci řádku

Viz také

Váš názor

Další materiály