Freigeben über


Verschiedene Konstrukte

Reguläre Ausdrücke in .NET Framework schließen drei verschiedene Sprachkonstrukte ein. Sie können bestimmte Vergleichsoptionen in der Mitte eines Musters für einen regulären Ausdruck aktivieren oder deaktivieren. Die vebleibenden zwei Elemente ermöglichen das Hinzufügen von Kommentaren in einem regulären Ausdruck.

Inlineoptionen

Mithilfe der Syntax können bestimmte Mustervergleichsoptionen für einen Teil eines regulären Ausdrucks festgelegt oder deaktiviert werden.

(?imnsx-imnsx)

Sie führen die zu aktivierenden Optionen nach dem Fragezeichen und die zu deaktivierenden Optionen nach dem Minuszeichen auf. In der folgenden Tabelle werden die einzelnen Optionen beschrieben. Weitere Informationen zu den einzelnen Optionen finden Sie unter Optionen für reguläre Ausdrücke.

Option

Beschreibungen

i

Übereinstimmung ohne Berücksichtigung der Groß-/Kleinschreibung.

m

Mehrzeilenmodus.

n

Nur explizite Erfassungen. (Klammern fungieren nicht als Erfassungsgruppen.)

s

Einzeilenmodus

x

Leerstellen ohne Escapezeichen ignorieren und x-Modus-Kommentare zulassen.

Irgendeine Änderung in regulären Ausdrucksoptionen, die vom (?imnsx-imnsx)-Konstrukt definiert wurde, bleibt bis zum Ende der einschließenden Gruppe gültig.

HinweisHinweis

Das (?imnsx-imnsx:Teilausdruck)-Gruppierungskonstrukt bietet identische Funktionen für einen Teilausdruck.Weitere Informationen finden Sie unter Gruppierungskonstrukte.

Im folgenden Beispiel werden mit den Optionen i, n und x die Nichtbeachtung von Groß- und Kleinschreibung und explizite Erfassungen aktiviert. Zudem werden Leerzeichen im Muster des regulären Ausdrucks in der Mitte eines regulären Ausdrucks ignoriert.

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

Im Beispiel werden zwei reguläre Ausdrücke definiert. Das erste Element, \b(D\w+)\s(d\w+)\b, entspricht zwei aufeinander folgenden Wörtern, die mit einem großgeschriebenen "D" und einem kleingeschriebenen "d" beginnen. Der zweite reguläre Ausdruck, \b(D\w+)(?ixn) \s (d\w+) \b, verwendet Inlineoptionen, um dieses Muster zu ändern (siehe Beschreibung in der folgenden Tabelle). Ein Vergleich der Ergebnisse bestätigt den Effekt des (?ixn)-Konstrukts.

Muster

Beschreibungen

\b

An einer Wortgrenze beginnen.

(D\w+)

Entspricht einem großen "D" gefolgt von mindestens einem Wortzeichen. Dies ist die erste Erfassungsgruppe.

(?ixn)

Führen Sie von diesem Punkt an keine Vergleiche mit Beachtung von Groß-/Kleinschreibung durch, führen Sie nur explizite Erfassungen aus, und ignorieren Sie Leerstellen im Muster eines regulären Ausdrucks.

\s

Entsprechung für ein Leerraumzeichen finden.

(d\w+)

Entspricht einem in Groß- oder Kleinbuchstaben geschriebenen "d" gefolgt von mindestens einem Wortzeichen. Diese Gruppe wird nicht erfasst, da die n (explizite Erfassung)-Option aktiviert wurde.

\b

Entsprechung für eine Wortgrenze finden.

Inlinekommentar

Das (?# Kommentar)-Konstrukt ermöglicht die Einbeziehung eines Inlinekommentars in einen regulären Ausdruck. Das Modul für reguläre Ausdrücke verwendet keinen beliebigen Teil des Kommentars im Mustervergleich, obwohl der Kommentar in der Zeichenfolge enthalten ist, die von der Regex.ToString-Methode zurückgegeben wird. Der Kommentar endet bei der ersten schließenden Klammer.

Im folgenden Beispiel wird das erste Muster eines regulären Ausdrucks aus dem Beispiel im vorherigen Abschnitt wiederholt. Es fügt dem regulären Ausdruck zwei Inlinekommentare hinzu, um anzugeben, ob beim Vergleich die Groß-/Kleinschreibung beachtet wird. Das Muster eines regulären Ausdrucks (\b((?# case-sensitive comparison)D\w+)\s((?#case-insensitive comparison)d\w+)\b) wird folgendermaßen definiert:

Muster

Beschreibungen

\b

An einer Wortgrenze beginnen.

(?# case-sensitive comparison)

Ein Kommentar. Dies hat keine Auswirkungen auf das Mustervergleichsverhalten.

(D\w+)

Entspricht einem großen "D" gefolgt von mindestens einem Wortzeichen. Dies ist die erste Erfassungsgruppe.

\s

Entsprechung für ein Leerraumzeichen finden.

(?ixn)

Führen Sie von diesem Punkt an keine Vergleiche mit Beachtung von Groß-/Kleinschreibung durch, führen Sie nur explizite Erfassungen aus, und ignorieren Sie Leerstellen im Muster eines regulären Ausdrucks.

(?#case-insensitive comparison)

Ein Kommentar. Dies hat keine Auswirkungen auf das Mustervergleichsverhalten.

(d\w+)

Entspricht einem in Groß- oder Kleinbuchstaben geschriebenen "d" gefolgt von mindestens einem Wortzeichen. Dies ist die zweite Erfassungsgruppe.

\b

Entsprechung für eine Wortgrenze finden.

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

Kommentar am Zeilenende

Ein Nummernzeichen (#) markiert einen x-Modus-Kommentar, der beim nicht entfernten #-Zeichen am Ende des Musters eines regulären Ausdrucks beginnt, und fährt bis zum Ende der Zeile fort. Um dieses Konstrukt zu verwenden, müssen Sie entweder die x-Option (durch Inlineoptionen) aktivieren oder den RegexOptions.IgnorePatternWhitespace-Wert für den option-Parameter angeben, wenn Sie das Regex-Objekt instanziieren oder eine statische Regex-Methode aufrufen.

Das folgende Beispiel veranschaulicht das Konstrukt für Zeilenendkommentare: Es wird bestimmt, ob eine Zeichenfolge eine zusammengesetzte Formatzeichenfolge ist, die mindestens ein Formatelement einschließt. In der folgenden Tabelle werden die Konstrukte im Muster für reguläre Ausdrücke beschrieben.

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

Muster

Beschreibungen

\{

Entspricht einer öffnenden geschweiften Klammer.

\d+

Entsprechung für mindestens eine Dezimalstelle finden.

(,-*\d+)*

Entspricht null oder einem Vorkommen eines Kommas gefolgt von einem optionalen Minuszeichen und mindestens einer Dezimalstelle.

(\:\w{1,4}?)*

Entspricht null oder einem Vorkommen eines Doppelpunkts gefolgt von einem bis vier (doch möglichst wenigen) Leerzeichen.

(?#case insensitive comparison)

Ein Inlinekommentar. Dies hat keine Auswirkungen auf das Mustervergleichsverhalten.

\}

Entspricht einer schließenden geschweiften Klammer.

(?x)

Aktivieren Sie die Option zum Ignorieren von Musterleerstellen, damit der Kommentar am Zeilenende erkannt wird.

# Looks for a composite format item.

Ein Kommentar am Zeilenende.

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

Anstatt das (?x)-Konstrukt im regulären Ausdruck bereitzustellen, kann der Kommentar auch durch Aufrufen der Regex.IsMatch(String, String, RegexOptions)-Methode und die Übergabe des RegexOptions.IgnorePatternWhitespace-Enumerationswerts an die Methode erkannt werden.

Siehe auch

Konzepte

Sprachelemente für reguläre Ausdrücke