Diverse constructies in reguliere expressies

Artikel
03/05/2024

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.

Optie	Omschrijving
`i`	Hoofdlettergevoelige overeenkomsten.
`m`	Modus met meerdere regels.
`n`	Alleen expliciete opnamen. (Haakjes fungeren niet als het vastleggen van groepen.)
`s`	Modus met één regel.
`x`	Negeer niet-gescaped witruimte en sta opmerkingen in de x-modus toe.

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

Notitie

De (?imnsx-imnsx:groeperingsconstructie voor subexpressie) biedt identieke functionaliteit voor een subexpressie. Zie Groeperingsconstructies voor meer informatie.

In het volgende voorbeeld worden de iopties , nen x opties gebruikt om hoofdlettergevoeligheid en expliciete opnamen in te schakelen en 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 {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'

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.

Patroon	Beschrijving
`\b`	Begin bij een woordgrens.
`(D\w+)`	Komt overeen met een hoofdletter 'D' gevolgd door een of meer woordtekens. Dit is de eerste capture-groep.
`(?ixn)`	Maak vanaf dit punt vergelijkingen hoofdlettergevoelig, maak alleen expliciete opnamen en negeer witruimte in het reguliere expressiepatroon.
`\s`	Overeenkomst met een spatieteken.
`(d\w+)`	Komt overeen met een hoofdletter of kleine letter 'd' gevolgd door een of meer woordtekens. Deze groep wordt niet vastgelegd omdat de `n` optie (expliciet vastleggen) is ingeschakeld.
`\b`	Komt overeen met een woordgrens.

Inline opmerking

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

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.

Patroon	Beschrijving
`\b`	Begin bij een woordgrens.
`(?# case-sensitive comparison)`	Een opmerking. Het heeft geen invloed op patroonkoppelingsgedrag.
`(D\w+)`	Komt overeen met een hoofdletter 'D' gevolgd door een of meer woordtekens. Dit is de eerste opnamegroep.
`\s`	Overeenkomst met een spatieteken.
`(?ixn)`	Maak vanaf dit punt vergelijkingen hoofdlettergevoelig, maak alleen expliciete opnamen en negeer witruimte in het reguliere expressiepatroon.
`(?#case-insensitive comparison)`	Een opmerking. Het heeft geen invloed op patroonkoppelingsgedrag.
`(d\w+)`	Komt overeen met een hoofdletter of kleine letter 'd' gevolgd door een of meer woordtekens. Dit is de tweede capture-groep.
`\b`	Komt overeen met een woordgrens.

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

Opmerking einde van 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 notatietekenreeks is die ten minste één opmaakitem 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.

Patroon	Beschrijving
`\{`	Komt overeen met een accolade openen.
`\d+`	Kom overeen met een of meer decimale cijfers.
`(,-\d+)`	Kom overeen met nul of één exemplaar van een komma, gevolgd door een optioneel minteken, gevolgd door een of meer decimale cijfers.
`(\:\w{1,4}?)*`	Kom overeen met nul of één exemplaar van een dubbele punt, gevolgd door één tot vier, maar zo weinig mogelijk spatietekens.
`\}`	Overeenkomst met een accolade sluiten.
`(?x)`	Schakel de optie voor het negeren van witruimte in, zodat de opmerking aan het einde van de regel wordt herkend.
`# Looks for a composite format item.`	Een opmerking aan het einde van de regel.

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.

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

Diverse constructies in reguliere expressies

Inlineopties

Inline opmerking

Opmerking einde van regel

Zie ook

Feedback

Aanvullende resources