Verschillende constructies in reguliere expressies

Reguliere expressies in .NET bevatten drie verschillende taalconstructies. U kunt bepaalde overeenkomende opties in- of uitschakelen in het midden van een normaal expressiepatroon. Met de overige twee kunt u opmerkingen opnemen in een reguliere expressie.

Inlineopties

U kunt specifieke opties voor patroonkoppeling instellen of uitschakelen voor een deel van een reguliere expressie met behulp van de syntaxis

(?imnsx-imnsx)

U geeft de opties weer die u wilt inschakelen na het vraagteken en de opties die u wilt uitschakelen na het minteken. In de volgende tabel wordt elke optie beschreven. Zie Opties voor reguliere expressies voor meer informatie over elke optie.

Elke wijziging in reguliere expressieopties die zijn gedefinieerd door de (?imnsx-imnsx)-constructie blijft van kracht tot het einde van de omsluitende groep.

In het volgende voorbeeld worden de opties i, n en x gebruikt om hoofdletterongevoeligheid en expliciete opnamen in te schakelen, en om witruimte in het reguliere-expressiepatroon in het midden van een reguliere expressie te negeren.

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 {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 {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'

In het voorbeeld worden twee reguliere expressies gedefinieerd. De eerste, \b(D\w+)\s(d\w+)\bkomt overeen met twee opeenvolgende woorden die beginnen met een hoofdletter 'D' en een kleine letter 'd'. De tweede reguliere expressie, \b(D\w+)(?ixn) \s (d\w+) \bgebruikt inlineopties om dit patroon te wijzigen, zoals beschreven in de volgende tabel. Een vergelijking van de resultaten bevestigt het effect van de (?ixn) constructie.

Inline opmerking

Met de (?#opmerkingsconstructie) kunt u een inline-opmerking opnemen in een reguliere expressie. De engine voor reguliere expressies gebruikt geen enkel deel van de opmerking bij patroonkoppeling, hoewel de opmerking is opgenomen in de tekenreeks die door de Regex.ToString-methode wordt geretourneerd. De opmerking eindigt bij de eerste sluitende haakje.

In het volgende voorbeeld wordt het eerste reguliere expressiepatroon uit het voorbeeld in de vorige sectie herhaald. Er worden twee inline opmerkingen toegevoegd aan de reguliere expressie om aan te geven of de vergelijking hoofdlettergevoelig is. Het reguliere expressiepatroon, \b((?# case-sensitive comparison)D\w+)\s(?ixn)((?#case-insensitive comparison)d\w+)\bwordt als volgt gedefinieerd.

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 {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

Commentaar op het einde van de regel

Een getalteken (#) markeert een opmerking in de x-modus, die begint bij het teken unescaped # aan het einde van het reguliere expressiepatroon en doorgaat tot het einde van de regel. Als u deze constructie wilt gebruiken, moet u de x optie (via inlineopties) inschakelen of de RegexOptions.IgnorePatternWhitespace waarde aan de option parameter opgeven bij het instantiëren van het Regex object of het aanroepen van een statische Regex methode.

In het volgende voorbeeld ziet u de opmerkingsconstructie aan het einde van de regel. Hiermee wordt bepaald of een tekenreeks een samengestelde opmaaktekenreeks is die ten minste één formatteringselement bevat. In de volgende tabel worden de constructies in het reguliere expressiepatroon beschreven:

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

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($"'{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.

In plaats van de (?x) constructie in de reguliere expressie op te geven, kan de opmerking ook worden herkend door de Regex.IsMatch(String, String, RegexOptions) methode aan te roepen en deze door te geven aan de RegexOptions.IgnorePatternWhitespace opsommingswaarde.

Zie ook

• Reguliere expressietaal - Snelzoekgids