Freigeben über

Gruppierungskonstrukte

  • Artikel

Gruppierungskonstrukte grenzen die Teilausdrücke eines regulären Ausdrucks ab und zeichnen die Teilzeichenfolgen einer Eingabezeichenfolge auf. Mit Gruppierungskonstrukten können Sie folgende Schritte ausführen:

  • Finden Sie eine Entsprechung für einen Teilausdruck, der in der Eingabezeichenfolge wiederholt wird.

  • Übernehmen Sie einen Quantifizierer für einen Teilausdruck, der über mehrere reguläre Ausdruckssprachelemente verfügt. Weitere Informationen zu Quantifizierern finden Sie unter Quantifizierer.

  • Schließt einen Teilausdruck in die Zeichenfolge ein, die von den Regex.Replace- und Match.Result-Methoden zurückgegeben wird.

  • Rufen Sie einzelne Teilausdrücke aus der Match.Groups-Eigenschaft ab, und verarbeiten Sie sie getrennt vom entsprechenden Text als ganzes.

.NET Framework unterstützt die folgenden Gruppierungskonstrukte regulärer Ausdrücke:

  • Übereinstimmende Teilausdrücke

  • Benannte übereinstimmende Teilausdrücke

  • Ausgleichen von Gruppendefinitionen

  • Nicht erfassende Gruppen

  • Gruppenoptionen

  • Positive Lookaheadassertion mit einer Breite von Null

  • Negative Lookaheadassertion mit einer Breite von Null

  • Positive Lookbehindassertion mit einer Breite von Null

  • Negative Lookbehindassertion mit einer Breite von Null

  • Nicht zurückverfolgende Teilausdrücke

  • Gruppieren von Konstrukten und Objekten für reguläre Ausdrücke

Übereinstimmende Teilausdrücke

Das folgende Gruppierungskonstrukt erfasst einen passenden Teilausdruck:

( subexpression )

wobei Teilausdruck ein beliebiges gültiges Muster eines regulären Ausdrucks ist. Erfassungen, die Klammern verwenden, werden automatisch von links und mit Eins beginnend auf Grundlage der Reihenfolge der öffnenden runden Klammern im regulären Ausdruck aufgezählt. Die erste Erfassung, die mit 0 gekennzeichnet wird, ist der Text, dem das gesamte Muster für den regulären Ausdruck entspricht.

HinweisHinweis

Wenn der RegexOptions-Parameter eines Musters eines regulären Ausdrucks der Übereinstimmungsmethode das RegexOptions.ExplicitCapture-Flag enthält, oder wenn die n-Option für diesen Teilausdruck (siehe weiter unten in diesem Thema Gruppenoptionen) übernommen wird, wird der zueinander passende Teilausdruck nicht erfasst.

Für den Zugriff auf erfasste Gruppen gibt es vier Möglichkeiten:

  • Indem das rückverweisende Konstrukt im regulären Ausdruck verwendet wird. Auf den passenden Teilausdruck wird im gleichen regulären Ausdruck mit der Syntax \Zahl verwiesen, wobei Zahl die Ordinalzahl des erfassten Teilausdrucks ist.

  • Indem das benannte rückverweisende Konstrukt im regulären Ausdruck verwendet wird. Auf den passenden Teilausdruck wird im gleichen regulären Ausdruck mit der Syntax \k<Zahl> verwiesen, wobei Zahl die Ordinalzahl des erfassten Teilausdrucks ist. Der erfasste Teilausdruck verfügt über einen Standardnamen, der mit seiner Ordinalzahl identisch ist. Weitere Informationen finden Sie unter Benannte übereinstimmende Teilausdrücke später in diesem Thema.

  • Mit der $number-Ersatzsequenz in einem Regex.Replace- oder Match.Result-Methodenaufruf, wobei number die Ordinalzahl des erfassten Teilausdrucks ist.

  • Programmgesteuert durch die Verwendung des GroupCollection-Objekts, das von der Match.Groups-Eigenschaft zurückgegeben wird. Der Member auf der Nullposition in der Auflistung stellt die ganze reguläre Ausdrucksübereinstimmung dar. Jeder nachfolgende Member stellt einen zueinander passenden Teilausdruck dar. Weitere Informationen finden Sie im Abschnitt Gruppieren von Konstrukten und Objekten für reguläre Ausdrücke.

Im folgenden Beispiel wird ein regulärer Ausdruck veranschaulicht, der doppelte Wörter im Text identifiziert. Die zwei Erfassungsgruppen des Musters eines regulären Ausdrucks stellen die zwei Instanzen des doppelten Worts dar. Die zweite Instanz wird erfasst, um die Anfangsposition in der Eingabezeichenfolge zu melden.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(\w+)\s(\1)\W"
      Dim input As String = "He said that that was the the correct answer."
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
         Console.WriteLine("Duplicate '{0}' found at positions {1} and {2}.", _
                           match.Groups(1).Value, match.Groups(1).Index, match.Groups(2).Index)
      Next
   End Sub
End Module
' The example displays the following output:
'       Duplicate 'that' found at positions 8 and 13.
'       Duplicate 'the' found at positions 22 and 26.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\w+)\s(\1)";
      string input = "He said that that was the the correct answer.";
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
         Console.WriteLine("Duplicate '{0}' found at positions {1} and {2}.", 
                           match.Groups[1].Value, match.Groups[1].Index, match.Groups[2].Index);
   }
}
// The example displays the following output:
//       Duplicate 'that' found at positions 8 and 13.
//       Duplicate 'the' found at positions 22 and 26.

Das Muster für den reguläre Ausdruck lautet folgendermaßen:

(\w+)\s(\1)\W

Die folgende Tabelle zeigt, wie das Muster eines regulären Ausdrucks interpretiert wird.

Muster

Beschreibungen

(\w+)

Entsprechung für eines oder mehrere Wortzeichen finden. Dies ist die erste Erfassungsgruppe.

\s

Entsprechung für ein Leerraumzeichen finden.

(\1)

Suchen Sie nach einer Entsprechung für die Zeichenfolge in der ersten erfassten Gruppe. Dies ist die zweite Erfassungsgruppe. Im Beispiel wird es einer erfassten Gruppe zugewiesen, damit die Anfangsposition des doppelten Worts von der Match.Index-Eigenschaft abgerufen werden kann.

\W

Finden Sie eine Entsprechung für ein Nichtwortzeichen, einschließlich Leerzeichen und Interpunktion. Dies verhindert, dass das Muster eines regulären Ausdrucks eine Entsprechung für ein Wort findet, das mit dem Wort von der zuerst erfassten Gruppe beginnt.

Benannte übereinstimmende Teilausdrücke

Das folgende Gruppierungskonstrukt erfasst einen passenden Teilausdruck und ermöglicht den Zugriff nach Name oder Zahl:

(?<name>subexpression)

oder:

(?'name' subexpression)

wobei Name ein gültiger Gruppenname und Teilausdruck ein beliebiges gültiges Muster eines regulären Ausdrucks ist. name darf keine Satzzeichen enthalten und nicht mit einer Zahl beginnen.

HinweisHinweis

Wenn der RegexOptions-Parameter eines Musters eines regulären Ausdrucks der Übereinstimmungsmethode das RegexOptions.ExplicitCapture-Flag enthält, oder wenn die n-Option für diesen Teilausdruck (siehe weiter unten in diesem Thema Gruppenoptionen) übernommen wird, ist der einzige Weg zur Erfassung eines Teilausdrucks die explizite Benennung von Erfassungsgruppen.

Sie können wie folgt auf benannte erfasste Gruppen zugreifen:

  • Indem das benannte rückverweisende Konstrukt im regulären Ausdruck verwendet wird. Auf den passenden Teilausdruck wird im gleichen regulären Ausdruck mit der Syntax \k<name> verwiesen, wobei name der Name des erfassten Teilausdrucks ist.

  • Indem das rückverweisende Konstrukt im regulären Ausdruck verwendet wird. Auf den passenden Teilausdruck wird im gleichen regulären Ausdruck mit der Syntax \Zahl verwiesen, wobei Zahl die Ordinalzahl des erfassten Teilausdrucks ist. Benannte zueinander passende Teilausdrücke werden hintereinander von links nach rechts nach zueinander passenden Teilausdrücken nummeriert.

  • Mit der $ {Name}-Ersatzsequenz in einem Regex.Replace-Methodenaufruf oder einem Match.Result-Methodenaufruf, wobei Name der Name des erfassten Teilausdrucks ist.

  • Mit der $number>-Ersatzsequenz in einem Regex.Replace- oder Match.Result-Methodenaufruf, wobei number die Ordinalzahl des erfassten Teilausdrucks ist.

  • Programmgesteuert durch die Verwendung des GroupCollection-Objekts, das von der Match.Groups-Eigenschaft zurückgegeben wird. Der Member auf der Nullposition in der Auflistung stellt die ganze reguläre Ausdrucksübereinstimmung dar. Jeder nachfolgende Member stellt einen zueinander passenden Teilausdruck dar. Benannte erfasste Gruppen werden in der Auflistung nach nummerierten erfassten Gruppen gespeichert.

  • Programmgesteuert, durch das Bereitstellen des Teilausdrucknamens für den Indexer (in C#) des GroupCollection-Objekts oder seine Item-Eigenschaft (in Visual Basic).

Ein einfaches Muster eines regulären Ausdrucks veranschaulicht, wie auf nummerierte (unbenannte) und benannte Gruppen entweder programmgesteuert oder mit der Sprachsyntax für reguläre Ausdrücke verwiesen werden kann. Der reguläre Ausdruck ((?<One>abc)\d+)?(?<Two>xyz)(.*) generiert die folgenden Erfassungsgruppen nach Nummer und Name. Die erste Erfassungsgruppe [Nummer 0] bezieht sich stets auf das gesamte Muster.

Zahl

Name

Muster

0

0 (Standardname)

((?<One>abc)\d+)?(?<Two>xyz)(.*)

1

1 (Standardname)

((?<One>abc)\d+)

2

2 (Standardname)

(.*)

3

One

(?<One>abc)

4

Two

(?<Two>xyz)

Im folgenden Beispiel wird ein regulärer Ausdruck veranschaulicht, der duplizierte Wörter und das Wort, das jedem duplizierten Wort direkt folgt, identifiziert. Das Muster eines regulären Ausdrucks definiert zwei benannte Teilausdrücke: duplicateWord, der das doppelte Wort darstellt; und nextWord, der das Wort darstellt, das auf das doppelte Wort folgt.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(?<duplicateWord>\w+)\s\k<duplicateWord>\W(?<nextWord>\w+)"
      Dim input As String = "He said that that was the the correct answer."
      Console.WriteLine(Regex.Matches(input, pattern, RegexOptions.IgnoreCase).Count)
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
         Console.WriteLine("A duplicate '{0}' at position {1} is followed by '{2}'.", _
                           match.Groups("duplicateWord").Value, match.Groups("duplicateWord").Index, _
                           match.Groups("nextWord").Value)
      Next
   End Sub
End Module
' The example displays the following output:
'    A duplicate 'that' at position 8 is followed by 'was'.
'    A duplicate 'the' at position 22 is followed by 'correct'.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(?<duplicateWord>\w+)\s\k<duplicateWord>\W(?<nextWord>\w+)";
      string input = "He said that that was the the correct answer.";
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
         Console.WriteLine("A duplicate '{0}' at position {1} is followed by '{2}'.", 
                           match.Groups["duplicateWord"].Value, match.Groups["duplicateWord"].Index, 
                           match.Groups["nextWord"].Value);

   }
}
// The example displays the following output:
//       A duplicate 'that' at position 8 is followed by 'was'.
//       A duplicate 'the' at position 22 is followed by 'correct'.

Das Muster für den reguläre Ausdruck lautet folgendermaßen:

(?<duplicateWord>\w+)\s\k<duplicateWord>\W(?<nextWord>\w+)

In der folgenden Tabelle wird gezeigt, wie der reguläre Ausdruck interpretiert wird.

Muster

Beschreibungen

(?<duplicateWord>\w+)

Entsprechung für eines oder mehrere Wortzeichen finden. Geben Sie für die Erfassungsgruppe duplicateWord als Namen an.

\s

Entsprechung für ein Leerraumzeichen finden.

\k<duplicateWord>

Suchen Sie nach einer Entsprechung der Zeichenfolge der erfassten Gruppe mit der Bezeichnung duplicateWord.

\W

Finden Sie eine Entsprechung für ein Nichtwortzeichen, einschließlich Leerzeichen und Interpunktion. Dies verhindert, dass das Muster eines regulären Ausdrucks eine Entsprechung für ein Wort findet, das mit dem Wort von der zuerst erfassten Gruppe beginnt.

(?<nextWord>\w+)

Entsprechung für eines oder mehrere Wortzeichen finden. Geben Sie für die Erfassungsgruppe nextWord als Namen an.

Ausgleichen von Gruppendefinitionen

Eine Ausgleichsgruppendefinition löscht die Definition einer zuvor definierten Gruppe und speichert in der aktuellen Gruppe das Intervall zwischen der zuvor definierten Gruppe und der aktuellen Gruppe. Dieses Gruppierungskonstrukt besitzt das folgende Format:

(?<name1-name2>subexpression)

oder:

(?'name1-name2' subexpression)

wobei Name1 die aktuelle Gruppe (optional) ist, name2 eine zuvor definierte Gruppe und Teilausdruck ein beliebiges gültiges Muster eines regulären Ausdrucks ist. Die ausgleichende Gruppendefinition löscht die Definition von name2 und speichert das Intervall zwischen name2 und name1 in name1. Wenn keine name2-Gruppe definiert ist, wird die Übereinstimmung rückwärts verarbeitet. Da durch Löschen der letzten Definition von name2 die vorherige Definition von name2 angezeigt wird, kann mithilfe dieses Konstrukts der Erfassungsstapel für die Gruppe name2 als Zähler für die Erfassung von geschachtelten Konstrukten, z. B. Anführungszeichen oder öffnende bzw. schließende Klammern, verwendet werden.

Die ausgleichende Gruppendefinition verwendet Name2 als Stapel. Das Anfangszeichen jedes geschachtelten Konstrukts wird in der Gruppe und seiner Group.Captures-Auflistung eingefügt. Wenn das schließende Zeichen zugeordnet wird, wird das entsprechende öffnende Zeichen aus der Gruppe entfernt, und die Captures-Auflistung wird um eins verringert. Nachdem die öffnenden und schließenden Zeichen aller geschachtelter Konstrukte zugewiesen wurden, ist Name1 leer.

HinweisHinweis

Nachdem Sie den regulären Ausdruck im folgenden Beispiel geändert haben, damit er die entsprechenden öffnenden und schließenden Zeichen eines geschachtelten Konstrukts enthält, können Sie diesen zur Behandlung der meisten geschachtelten Konstrukte verwenden, z. B. für mathematische Ausdrücke oder Programmcodezeilen, die mehrere geschachtelte Methodenaufrufe beinhalten.

Das folgende Codebeispiel verwendet eine Ausgleichsgruppendefinition, um in einer Eingabezeichenfolge nach öffnenden und schließenden spitzen Klammern (<>) zu suchen. Im Beispiel werden zwei benannte Gruppen, Open und Close, die wie ein Stapel verwendet werden, um entsprechende Paare von spitzen Klammern zu verfolgen, definiert. Jede eroberte Kleiner als-Zeichenklammer wird in die Erfassungsauflistung der Gruppe Open geschoben, und jede eroberte Größer als-Zeichenklammer wird in die Erfassungsauflistung der Gruppe Close geschoben. Die ausgleichende Gruppendefinition stellt sicher, dass es eine entsprechende Größer als-Zeichenklammer für jede Kleiner als-Zeichenklammer gibt. Trifft dies nicht zu, wird das abschließende Teilmuster, (?(Open)(?!)), nur ausgewertet, wenn die Open-Gruppe nicht leer ist (und wenn alle geschachtelten Konstrukte nicht geschlossen wurden). Wenn das abschließende Teilmuster ausgewertet wird, schlägt die Übereinstimmung fehl, da die Eingabezeichenfolge keine Vorkommen der Teilzeichenfolge ?! enthalten sollte.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main() 
        Dim pattern As String = "^[^<>]*" & _
                                "(" + "((?'Open'<)[^<>]*)+" & _
                                "((?'Close-Open'>)[^<>]*)+" + ")*" & _
                                "(?(Open)(?!))$"
        Dim input As String = "<abc><mno<xyz>>"
        Dim rgx AS New Regex(pattern)'
        Dim m As Match = Regex.Match(input, pattern)
        If m.Success Then
            Console.WriteLine("Input: ""{0}"" " & vbCrLf & "Match: ""{1}""", _
                               input, m)
            Dim grpCtr As Integer = 0
            For Each grp As Group In m.Groups
               Console.WriteLine("   Group {0}: {1}", grpCtr, grp.Value)
               grpCtr += 1
               Dim capCtr As Integer = 0
               For Each cap As Capture In grp.Captures            
                  Console.WriteLine("      Capture {0}: {1}", capCtr, cap.Value)
                  capCtr += 1
               Next
            Next
        Else
            Console.WriteLine("Match failed.")
        End If
    End Sub
End Module  
' The example displays the following output:
'       Input: "<abc><mno<xyz>>"
'       Match: "<abc><mno<xyz>>"
'          Group 0: <abc><mno<xyz>>
'             Capture 0: <abc><mno<xyz>>
'          Group 1: <mno<xyz>>
'             Capture 0: <abc>
'             Capture 1: <mno<xyz>>
'          Group 2: <xyz
'             Capture 0: <abc
'             Capture 1: <mno
'             Capture 2: <xyz
'          Group 3: >
'             Capture 0: >
'             Capture 1: >
'             Capture 2: >
'          Group 4:
'          Group 5: mno<xyz>
'             Capture 0: abc
'             Capture 1: xyz
'             Capture 2: mno<xyz>

using System;
using System.Text.RegularExpressions;

class Example
{
   public static void Main() 
   {
      string pattern = "^[^<>]*" +
                       "(" + 
                       "((?'Open'<)[^<>]*)+" +
                       "((?'Close-Open'>)[^<>]*)+" +
                       ")*" +
                       "(?(Open)(?!))$";
      string input = "<abc><mno<xyz>>";

      Match m = Regex.Match(input, pattern);
      if (m.Success == true)
      {
         Console.WriteLine("Input: \"{0}\" \nMatch: \"{1}\"", input, m);
         int grpCtr = 0;
         foreach (Group grp in m.Groups)
         {
            Console.WriteLine("   Group {0}: {1}", grpCtr, grp.Value);
            grpCtr++;
            int capCtr = 0;
            foreach (Capture cap in grp.Captures)
            {            
                Console.WriteLine("      Capture {0}: {1}", capCtr, cap.Value);
                capCtr++;
            }
          }
      }
      else
      {
         Console.WriteLine("Match failed.");
      }   
    }
}
// The example displays the following output:
//    Input: "<abc><mno<xyz>>"
//    Match: "<abc><mno<xyz>>"
//       Group 0: <abc><mno<xyz>>
//          Capture 0: <abc><mno<xyz>>
//       Group 1: <mno<xyz>>
//          Capture 0: <abc>
//          Capture 1: <mno<xyz>>
//       Group 2: <xyz
//          Capture 0: <abc
//          Capture 1: <mno
//          Capture 2: <xyz
//       Group 3: >
//          Capture 0: >
//          Capture 1: >
//          Capture 2: >
//       Group 4:
//       Group 5: mno<xyz>
//          Capture 0: abc
//          Capture 1: xyz
//          Capture 2: mno<xyz>

Das Muster des regulären Ausdrucks lautet:

^[^<>]*(((?'Open'<)[^<>]*)+((?'Close-Open'>)[^<>]*)+)*(?(Open)(?!))$

Der reguläre Ausdruck wird wie folgt interpretiert:

Muster

Beschreibungen

^

Starten Sie am Beginn der Zeichenfolge.

[^<>]*

Finden Sie eine Entsprechung für null oder mehr Zeichen, die keine linken oder rechten spitzen Klammern sind.

(?'Open'<)

Suchen Sie eine Übereinstimmung für ein kleiner als-Zeichen, und weisen Sie es einer Gruppe mit dem Namen Open zu.

[^<>]*

Finden Sie eine Entsprechung für null oder mehr Zeichen, die keine linken oder rechten spitzen Klammern sind.

((?'Open'<)[^<>]*) +

Finden Sie eine Entsprechung für ein oder mehr Vorkommen einer linken spitzen Klammer, gefolgt von null oder mehr Zeichen, die keine linken oder rechten spitzen Klammern sind. Dies ist die zweite Erfassungsgruppe.

(?'Close-Open'>)

Finden Sie eine Entsprechung für eine öffnende spitze Klammer, weisen Sie die Teilzeichenfolge zwischen der Open-Gruppe und der aktuellen Gruppe der Close-Gruppe zu, und löschen Sie die Definition der Open-Gruppe.

[^<>]*

Finden Sie eine Entsprechung für null oder mehr Vorkommen eines beliebigen Zeichens, das weder eine linke noch eine rechte spitze Klammern ist.

((?'Close-Open'>)[^<>]*)+

Finden Sie eine Entsprechung für ein oder mehr Vorkommen einer rechten spitzen Klammer, gefolgt von einem beliebigen Zeichen, das weder eine linke noch eine rechte spitze Klammern ist. Wenn Sie die öffnende spitze Klammer zuordnen, weisen Sie die Teilzeichenfolge zwischen der Open-Gruppe und der aktuellen Gruppe der Close-Gruppe zu, und löschen Sie die Definition der Open-Gruppe. Dies ist die dritte Erfassungsgruppe.

(((?'Open'<)[^<>]*)+((?'Close-Open'>)[^<>]*)+)*

Finden Sie eine Entsprechung für null oder mehr Vorkommen des folgenden Musters: ein oder mehr Vorkommen einer linken spitzen Klammer, gefolgt von null oder mehr Zeichen, die keine spitzen Klammern sind, gefolgt von einem oder mehr Vorkommen einer rechten spitzen Klammer, gefolgt von null oder mehr Vorkommen von nicht-spitzen Klammern. Wenn Sie die öffnende spitze Klammer zuordnen, löschen Sie die Definition der Open-Gruppe, und weisen Sie die Teilzeichenfolge zwischen der Open-Gruppe und der aktuellen Gruppe der Close-Gruppe zu. Dies ist die erste Erfassungsgruppe.

(?(Open)(?!))

Wenn die Open-Gruppe vorhanden ist, ordnen Sie ein Fragezeichen und ein Ausrufezeichen entsprechend zu. Wenn die Open-Gruppe definiert ist, tritt ein Fehler bei der Übereinstimmung auf, die spitzen Klammern sind also nicht ausgeglichen.

$

Entsprechung für das Ende der Eingabezeichenfolge finden.

Der abschließende Teilausdruck, (?(Open)(?!)), gibt an, ob die Schachtelungskonstrukte in der Eingabezeichenfolge ausgeglichen verteilt sind (z. B. ob zu jeder Kleiner als-Zeichenklammer eine entsprechende Größer als-Zeichenklammer zugeordnet wird). Es verwendet bedingte Übereinstimmung auf Grundlage einer gültigen erfassten Gruppe; weitere Informationen finden Sie unter Alternierungskonstrukte. Wenn die Open-Gruppe definiert ist, versucht das Modul für reguläre Ausdrücke, eine Entsprechung für den (?!)-Teilausdruck in der Eingabezeichenfolge zu finden. Die Gruppe Open sollte nur definiert werden, wenn Schachtelungskonstrukte nicht ausgeglichen sind. Daher sollte das Muster, für das in der Eingabezeichenfolge eine Entsprechung vorliegen soll, ein Muster sein, das nicht in der Eingabezeichenfolge auftreten kann, da sonst keine Übereinstimmung vorliegt.

Bei diesem Beispiel wertet das Modul des regulären Ausdrucks die Eingabezeichenfolge "<abc><mno<xyz>>" wie in der folgenden Tabelle angezeigt aus:

Schritt

Muster

Ergebnis

1

^

Beginnt den Vergleich am Anfang der Eingabezeichenfolge

2

[^<>]*

Sucht vor der öffnenden spitzen Klammer nach Zeichen, die keine spitzen Klammern sind; findet keine Übereinstimmungen.

3

(((?'Open'<)

Findet eine Entsprechung für die Kleiner als-Zeichenklammer in "< abc >" und weist sie der Open-Gruppe zu.

4

[^<>]*

Entspricht "abc".

5

)+

"<abc" ist der Wert der zweiten erfassten Gruppe.

Das nächste Zeichen in der Eingabezeichenfolge ist keine Kleiner als-Zeichenklammer, deshalb führt das Modul für reguläre Ausdrücke nicht zum (?'Open'<)[^<>]*)-Teilmuster zurück.

6

((?'Close-Open'>)

Findet eine Entsprechung für die Größer als-Zeichenklammer in "<abc>", weist "abc" (die Teilzeichenfolge zwischen der Open-Gruppe und der Größer als-Zeichenklammer) der Close-Gruppe zu und löscht den aktuellen Wert ("<") der Open-Gruppe, der dann leer bleibt.

7

[^<>]*

Sucht nach der schließenden spitzen Klammer nach Zeichen, die keine spitzen Klammern sind; findet keine Übereinstimmungen.

8

)+

Der Wert der dritten erfassten Gruppe ist ">".

Das nächste Zeichen in der Eingabezeichenfolge ist keine schließende spitze Klammer, weshalb das Modul für reguläre Ausdrücke keine Schleife zurück zum ((?'Close-Open'>)[^<>]*)-Teilmuster ausführt.

9

)*

Der Wert der ersten erfassten Gruppe ist "<abc>".

Das nächste Zeichen in der Eingabezeichenfolge ist keine öffnende spitze Klammer, weshalb das Modul für reguläre Ausdrücke eine Schleife zurück zum (((?'Open'<)-Teilmuster ausführt.

10

(((?'Open'<)

Findet eine Entsprechung für die Kleiner als-Zeichenklammer in "<mno>" und weist sie der Open-Gruppe zu. Die Group.Captures-Auflistung verfügt jetzt über einen einzelnen Wert "<".

11

[^<>]*

Entspricht "mno".

12

)+

"<mno" ist der Wert der zweiten erfassten Gruppe.

Das nächste Zeichen in der Eingabezeichenfolge ist eine öffnende spitze Klammer, weshalb das Modul für reguläre Ausdrücke eine Schleife zurück zum (?'Open'<)[^<>]*)-Teilmuster ausführt.

13

(((?'Open'<)

Findet eine Entsprechung für die Kleiner als-Zeichenklammer in "<xyz>" und weist sie der Open-Gruppe zu. Die Group.Captures-Auflistung der Open-Gruppe schließt jetzt zwei Erfassung ein: die Kleiner als-Zeichenklammer von "<mno>" und die Kleiner als-Zeichenklammer von "<xyz>".

14

[^<>]*

Entspricht "xyz".

15

)+

"<xyz" ist der Wert der zweiten erfassten Gruppe.

Das nächste Zeichen in der Eingabezeichenfolge ist keine Kleiner als-Zeichenklammer, deshalb führt das Modul für reguläre Ausdrücke nicht zum (?'Open'<)[^<>]*)-Teilmuster zurück.

16

((?'Close-Open'>)

Findet eine Übereinstimmung für die öffnende spitze Klammer in "<xyz>". " "xyz" weist die Teilzeichenfolge zwischen der Open-Gruppe und der öffnenden spitzen Klammer der Close-Gruppe zu und löscht den aktuellen Wert der Open-Gruppe. Der Wert der vorherigen Erfassung (die Kleiner als-Zeichenklammer in" < mno >") wird zum aktuellen Wert der Gruppe Open. Die Captures-Auflistung der Open-Gruppe schließt jetzt eine einzelne Erfassung ein, die Kleiner als-Zeichenklammer von "<xyz>".

17

[^<>]*

Sucht nach Zeichen, die keine spitzen Klammern sind; findet keine Übereinstimmungen.

18

)+

Der Wert der dritten erfassten Gruppe ist ">".

Das nächste Zeichen in der Eingabezeichenfolge ist eine schließende spitze Klammer, weshalb das Modul für reguläre Ausdrücke eine Schleife zurück zum ((?'Close-Open'>)[^<>]*)-Teilmuster ausführt.

19

((?'Close-Open'>)

Findet eine Entsprechung für die abschließende Größer als-Zeichenklammer in "xyz>> ", weist "mno zu < xyz >" (die Teilzeichenfolge zwischen der Open-Gruppe und der Größer als-Zeichenklammer) in der Close-Gruppe und löscht den aktuellen Wert der Open-Gruppe. Die Gruppe Open ist jetzt leer.

20

[^<>]*

Sucht nach Zeichen, die keine spitzen Klammern sind; findet keine Übereinstimmungen.

21

)+

Der Wert der dritten erfassten Gruppe ist ">".

Das nächste Zeichen in der Eingabezeichenfolge ist keine schließende spitze Klammer, weshalb das Modul für reguläre Ausdrücke keine Schleife zurück zum ((?'Close-Open'>)[^<>]*)-Teilmuster ausführt.

22

)*

Der Wert der ersten erfassten Gruppe ist "<mno<xyz>>".

Das nächste Zeichen in der Eingabezeichenfolge ist keine Kleiner als-Zeichenklammer, deshalb führt das Modul für reguläre Ausdrücke nicht zum (((?'Open'<)-Teilmuster zurück.

23

(?(Open)(?!))

Die Gruppe Open wird nicht definiert, sodass keine Übereinstimmung gesucht wird.

24

$

Vergleicht das Ende der Eingabezeichenfolge.

Nicht erfassende Gruppen

Das folgende Gruppierungskonstrukt erfasst nicht die Teilzeichenfolge, die zu einem Teilausdruck passt:

(?:subexpression)

wobei Teilausdruck ein beliebiges gültiges Muster eines regulären Ausdrucks ist. Das nicht erfassende Gruppenkonstrukt wird in der Regel verwendet, wenn ein Quantifizierer für eine Gruppe übernommen wird, aber die von der Gruppe erfassten Teilzeichenfolgen nicht von Interesse sind.

HinweisHinweis

Wenn ein regulärer Ausdruck geschachtelte Gruppierungskonstrukte einschließt, gilt ein äußeres nicht erfassendes Gruppenkonstrukt nicht für die inneren geschachtelten Gruppenkonstrukte.

Im folgenden Beispiel wird ein regulärer Ausdruck, der nicht erfassende Gruppen einschließt, veranschaulicht. Beachten Sie, dass die Ausgabe keine erfassten Gruppen einschließt.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(?:\b(?:\w+)\W*)+\."
      Dim input As String = "This is a short sentence."
      Dim match As Match = Regex.Match(input, pattern)
      Console.WriteLine("Match: {0}", match.Value)
      For ctr As Integer = 1 To match.Groups.Count - 1
         Console.WriteLine("   Group {0}: {1}", ctr, match.Groups(ctr).Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       Match: This is a short sentence.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(?:\b(?:\w+)\W*)+\.";
      string input = "This is a short sentence.";
      Match match = Regex.Match(input, pattern);
      Console.WriteLine("Match: {0}", match.Value);
      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:
//       Match: This is a short sentence.

Der reguläre Ausdruck (?:\b(?:\w+)\W*)+\. stimmt mit einem Satz überein, der durch einen Punkt beendet wird. Da sich der reguläre Ausdruck auf Sätze konzentriert und nicht auf einzelne Wörter, werden Gruppierungskonstrukte ausschließlich als Quantifizierer verwendet. Das Muster des regulären Ausdrucks wird wie in der folgenden Tabelle gezeigt interpretiert.

Muster

Beschreibungen

\b

Der Vergleich beginnt an einer Wortgrenze.

(?:\w+)

Entsprechung für eines oder mehrere Wortzeichen finden. Weisen Sie einer erfassten Gruppe den entsprechenden Text nicht zu.

\W*

Suchen Sie nach einer Übereinstimmung mit null oder mehr Nicht-Wortzeichen.

(?:\b(?:\w+)\W*)+

Suchen Sie nach einer Übereinstimmung für das Muster aus einem oder mehreren Wortzeichen, beginnend auf einer Wortgrenze und gefolgt entweder von Null oder mehreren nicht-Wort-Leerzeichen (ein oder zwei Mal). Weisen Sie einer erfassten Gruppe den entsprechenden Text nicht zu.

\.

Entsprechung für einen Punkt finden.

Gruppenoptionen

Das folgende Gruppierungskonstrukt wendet die angegebenen Optionen in einem Teilausdruck an oder deaktiviert sie:

(?imnsx-imnsx: subexpression )

wobei Teilausdruck ein beliebiges gültiges Muster eines regulären Ausdrucks ist. Beispielsweise aktiviert (?i-s:) die Einstellung, dass Groß-/Kleinschreibung nicht beachtet wird, und deaktiviert den Einzeilenmodus. Weitere Informationen zu den angebbaren Inlineoptionen finden Sie unter Optionen für reguläre Ausdrücke.

HinweisHinweis

Sie können Optionen angeben, die für einen vollständigen regulären Ausdruck und nicht für einen Teilausdruck gültig sind. Verwenden Sie dazu einen System.Text.RegularExpressions.Regex-Klassenkonstruktor oder eine statische Methode.Sie können auch Inlineoptionen angeben, die nach einem bestimmten Punkt in einem regulären Ausdruck gelten. Verwenden Sie dazu das (?imnsx-imnsx)-Sprachkonstrukt.

Das Konstrukt für die Gruppenoptionen ist keine Erfassungsgruppe. Das heißt, obwohl ein beliebiger Teil einer Zeichenfolge, die von Teilausdruck erfasst wird, in der Übereinstimmung enthalten ist, ist sie nicht in einer erfassten Gruppe enthalten bzw. wird verwendet, um das GroupCollection-Objekt aufzufüllen.

Beispiel: Der reguläre Ausdruck \b(?ix: d \w+)\s verwendet Inlineoptionen in einem Gruppierungskonstrukt, um die Groß-/Kleinschreibung nicht beachtende Übereinstimmung zu aktivieren und Musterleerstellen beim Identifizieren aller Wörter zu ignorieren, die mit dem Buchstaben "d" beginnen. Der reguläre Ausdruck wird entsprechend der Darstellung in der folgenden Tabelle definiert:

Muster

Beschreibungen

\b

Der Vergleich beginnt an einer Wortgrenze.

(?ix: d \w+)

In diesem Muster wird Übereinstimmung ohne Berücksichtigung von Groß- und Kleinschreibung verwendet, und Leerzeichen werden ignoriert (entspricht dem Buchstaben "d" gefolgt von mindestens einem Wortzeichen).

\s

Entsprechung für ein Leerraumzeichen finden.

 
Dim pattern As String = "\b(?ix: d \w+)\s"
Dim input As String = "Dogs are decidedly good pets."

For Each match As Match In Regex.Matches(input, pattern)
   Console.WriteLine("'{0}' found at index {1}.", match.Value, match.Index)
Next
' The example displays the following output:
'    'Dogs ' found at index 0.
'    'decidedly ' found at index 9.      

string pattern = @"\b(?ix: d \w+)\s";
string input = "Dogs are decidedly good pets.";

foreach (Match match in Regex.Matches(input, pattern))
   Console.WriteLine("'{0}// found at index {1}.", match.Value, match.Index);
// The example displays the following output:
//    'Dogs // found at index 0.
//    'decidedly // found at index 9.

Positive Lookaheadassertion mit einer Breite von Null

Das folgende Gruppierungskonstrukt definiert eine positive Lookaheadassertion mit einer Breite von 0 (null):

(?= subexpression )

wobei Teilausdruck jedes Muster eines regulären Ausdrucks ist. Damit eine Übereinstimmung erfolgreich ist, muss die Eingabezeichenfolge mit dem regulären Ausdrucksmuster im Teilausdruck übereinstimmen, obwohl der übereinstimmende Teilausdruck nicht im Übereinstimmungsergebnis enthalten ist. Eine positive Lookaheadassertion mit einer Breite von Null verfolgt nicht zurück.

In der Regel befindet sich eine positive Lookaheadassertion mit einer Breite von 0 (null) am Ende eines Musters eines regulären Ausdrucks. Es definiert eine Teilzeichenfolge, die am Ende einer Zeichenfolge gefunden werden muss, damit eine Übereinstimmung vorliegt, sollte aber nicht in der Übereinstimmung enthalten sein. Es ist auch zum Verhindern einer übermäßigen Rückverfolgung nützlich. Sie können eine Lookaheadassertion mit einer Breite von Null verwenden, um sicherzustellen, dass eine bestimmte Erfassungsgruppe mit Text beginnt, der einer Teilmenge des Musters entspricht, das für diese Erfassungsgruppe definiert ist. Wenn z. B. eine Erfassungsgruppe aufeinander folgenden Wortzeichen entspricht, können Sie mit einer positiven Lookaheadassertion mit einer Breite von Null anfordern, dass das erste Zeichen ein alphabetischer Großbuchstabe ist.

Im folgenden Beispiel wird mithilfe einer positiven Lookaheadassertion mit einer Breite von 0 (null) eine Entsprechung für das Wort gesucht, das dem Verb "is" in der Eingabezeichenfolge vorausgeht.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\w+(?=\sis\b)"
      Dim inputs() As String = { "The dog is a Malamute.", _
                                 "The island has beautiful birds.", _
                                 "The pitch missed home plate.", _
                                 "Sunday is a weekend day." }

      For Each input As String In inputs
         Dim match As Match = Regex.Match(input, pattern)
         If match.Success Then
            Console.WriteLine("'{0}' precedes 'is'.", match.Value)
         Else
            Console.WriteLine("'{0}' does not match the pattern.", input) 
         End If     
      Next
   End Sub
End Module
' The example displays the following output:
'       'dog' precedes 'is'.
'       'The island has beautiful birds.' does not match the pattern.
'       'The pitch missed home plate.' does not match the pattern.
'       'Sunday' precedes 'is'.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+(?=\sis\b)";
      string[] inputs = { "The dog is a Malamute.", 
                          "The island has beautiful birds.", 
                          "The pitch missed home plate.", 
                          "Sunday is a weekend day." };

      foreach (string input in inputs)
      {
         Match match = Regex.Match(input, pattern);
         if (match.Success)
            Console.WriteLine("'{0}' precedes 'is'.", match.Value);
         else
            Console.WriteLine("'{0}' does not match the pattern.", input); 
      }
   }
}
// The example displays the following output:
//    'dog' precedes 'is'.
//    'The island has beautiful birds.' does not match the pattern.
//    'The pitch missed home plate.' does not match the pattern.
//    'Sunday' precedes 'is'.

Der reguläre Ausdruck \b\w+(?=\sis\b) wird entsprechend der Darstellung in der folgenden Tabelle interpretiert.

Muster

Beschreibungen

\b

Der Vergleich beginnt an einer Wortgrenze.

\w+

Entsprechung für eines oder mehrere Wortzeichen finden.

(?=\sis\b)

Bestimmen Sie, ob den Wortzeichen ein Leerstellenzeichen und die Zeichenfolge "is" folgt, die auf einer Wortgrenze endet. Trifft dies zu, ist die Übereinstimmung erfolgreich.

Negative Lookaheadassertion mit einer Breite von Null

Das folgende Gruppierungskonstrukt definiert eine negative Lookaheadassertion mit einer Breite von 0 (null):

(?! subexpression )

wobei Teilausdruck jedes Muster eines regulären Ausdrucks ist. Damit die Übereinstimmung erfolgreich ist, darf die Eingabezeichenfolge nicht mit dem regulären Ausdrucksmuster im Teilausdruck übereinstimmen, obwohl die übereinstimmende Zeichenfolge nicht im Übereinstimmungsergebnis enthalten ist.

Eine negative Lookaheadassertion mit einer Breite von 0 (null) wird in der Regel entweder am Anfang oder dem Ende eines regulären Ausdrucks verwendet. Am Anfang eines regulären Ausdrucks kann ein bestimmtes Muster definiert werden, das nicht zugewiesen werden soll, wenn der Anfang des regulären Ausdrucks ein ähnliches aber allgemeineres Muster zur Übereinstimmung definiert. In diesem Fall wird dies häufig verwendet, um das Zurückverfolgen einzuschränken. Am Ende eines regulären Ausdrucks kann ein Teilausdruck definiert werden, der am Ende einer Übereinstimmung nicht auftreten kann.

Im folgenden Beispiel wird ein regulärer Ausdruck definiert, der am Anfang des regulären Ausdrucks eine Lookaheadassertion mit einer Breite von 0 (null) verwendet, um eine Entsprechung für Wörter zu finden, die nicht mit "un" beginnen.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b(?!un)\w+\b"
      Dim input As String = "unite one unethical ethics use untie ultimate"
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
         Console.WriteLine(match.Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       one
'       ethics
'       use
'       ultimate

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(?!un)\w+\b";
      string input = "unite one unethical ethics use untie ultimate";
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       one
//       ethics
//       use
//       ultimate

Der reguläre Ausdruck \b(?!un)\w+\b wird entsprechend der Darstellung in der folgenden Tabelle interpretiert.

Muster

Beschreibungen

\b

Der Vergleich beginnt an einer Wortgrenze.

(?!un)

Bestimmen Sie, ob die nächsten zwei Zeichen "un" sind. Trifft dies nicht zu, ist eine Übereinstimmung möglich.

\w+

Entsprechung für eines oder mehrere Wortzeichen finden.

\b

Der Vergleich endet an einer Wortgrenze.

Im folgenden Beispiel wird ein regulärer Ausdruck definiert, der am Ende des regulären Ausdrucks eine Lookaheadassertion mit einer Breite von 0 (null) verwendet, um eine Entsprechung für Wörter zu finden, die nicht mit einem Interpunktionszeichen enden.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\w+\b(?!\p{P})"
      Dim input As String = "Disconnected, disjointed thoughts in a sentence fragment."
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
      Next   
   End Sub
End Module
' The example displays the following output:
'       disjointed
'       thoughts
'       in
'       a
'       sentence

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+\b(?!\p{P})";
      string input = "Disconnected, disjointed thoughts in a sentence fragment.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       disjointed
//       thoughts
//       in
//       a
//       sentence

Der reguläre Ausdruck \b\w+\b(?!\p{P}) wird entsprechend der Darstellung in der folgenden Tabelle interpretiert.

Muster

Beschreibungen

\b

Der Vergleich beginnt an einer Wortgrenze.

\w+

Entsprechung für eines oder mehrere Wortzeichen finden.

\b

Der Vergleich endet an einer Wortgrenze.

\p{P})

Wenn das nächste Zeichen kein Interpunktionszeichen (z. B. ein Punkt oder ein Komma) ist, ist die Übereinstimmung erfolgreich.

Positive Lookbehindassertion mit einer Breite von Null

Das folgende Gruppierungskonstrukt definiert eine positive Lookbehindassertion mit einer Breite von 0 (null):

(?<= subexpression )

wobei Teilausdruck jedes Muster eines regulären Ausdrucks ist. Damit eine Übereinstimmung erfolgreich ist, darf der Teilausdruck nicht in der Eingabezeichenfolge links von der aktuellen Position auftreten, obwohl subexpression nicht im Übereinstimmungsergebnis enthalten ist. Eine positive Lookbehindassertion mit einer Breite von Null verfolgt nicht zurück.

Positive Lookbehind-Assertionen mit einer Breite von 0 (null) werden in der Regel entweder am Anfang oder am Ende von regulären Ausdrücken verwendet. Das Muster, das sie definieren, ist eine Vorbedingung für eine Übereinstimmung, obwohl es kein Teil des Übereinstimmungsergebnisses ist.

Im folgenden Beispiel wird z. B. eine Entsprechung für die letzten zwei Ziffern des Jahres für das 21. Jahrhundert (das heißt, es ist erforderlich, dass die Ziffern "20" der entsprechenden Zeichenfolge vorausgehen) gefunden.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "2010 1999 1861 2140 2009"
      Dim pattern As String = "(?<=\b20)\d{2}\b"

      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
      Next      
   End Sub
End Module
' The example displays the following output:
'       10
'       09

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "2010 1999 1861 2140 2009";
      string pattern = @"(?<=\b20)\d{2}\b";

      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       10
//       09

Das Muster für reguläre Ausdrücke (?<=\b20)\d{2}\b wird entsprechend der folgenden Tabelle interpretiert:

Muster

Beschreibungen

\d{2}

Entsprechung für zwei Dezimalstellen finden.

{?<=\b20)

Setzen Sie die Übereinstimmung fort, wenn den zwei Dezimalstellen die Dezimalstellen "20" auf einer Wortgrenze vorangestellt werden.

\b

Der Vergleich endet an einer Wortgrenze.

Positive Lookbehindassertions mit einer Breite von Null werden auch verwendet, um das Zurückverfolgen einzuschränken, wenn das letzte Zeichen oder Zeichen in einer Erfassungsgruppe eine Teilmenge der Zeichen sein muss bzw. müssen, die dem Muster eines regulären Ausdrucks dieser Gruppe entsprechen. Wenn beispielsweise eine Gruppe alle aufeinander folgenden Wortzeichen erfasst, können Sie mit einer positiven Lookaheadassertion mit einer Breite von Null anfordern, dass das letzte Zeichen alphabetisch ist.

Negative Lookbehindassertion mit einer Breite von Null

Das folgende Gruppierungskonstrukt definiert eine negative Lookbehindassertion mit einer Breite von 0 (null):

(?<! subexpression )

wobei Teilausdruck jedes Muster eines regulären Ausdrucks ist. Damit eine Übereinstimmung erfolgreich ist, darf der Teilausdruck nicht in der Eingabezeichenfolge links von der aktuellen Position auftreten. Jede Teilzeichenfolge, die nicht mit subexpression übereinstimmt, ist nicht im Übereinstimmungsergebnis enthalten.

Negative Lookbehind-Assertionen mit einer Breite von 0 (null) werden in der Regel entweder am Anfang oder am Ende von regulären Ausdrücken verwendet. Das Muster, das sie definieren, schließt eine Übereinstimmung in der darauf folgenden Zeichenfolge aus. Sie werden auch verwendet, um die Rückverfolgung einzuschränken, wenn die letzten Zeichen in einer erfassten Gruppe keine Zeichen sein dürfen, die dem Muster eines regulären Ausdrucks dieser Gruppe entsprechen. Wenn beispielsweise eine Gruppe alle aufeinander folgenden Wortzeichen erfasst, können Sie mit einer positiven Lookaheadassertion mit einer Breite von Null anfordern, dass das letzte Zeichen kein Unterstrich (_) ist.

Im folgenden Beispiel wird eine Entsprechung für das Datum eines beliebigen Wochentags gesucht, der nicht Wochenende (das heißt weder Samstag noch Sonntag) ist.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim dates() As String = { "Monday February 1, 2010", _
                                "Wednesday February 3, 2010", _
                                "Saturday February 6, 2010", _
                                "Sunday February 7, 2010", _
                                "Monday, February 8, 2010" }
      Dim pattern As String = "(?<!(Saturday|Sunday) )\b\w+ \d{1,2}, \d{4}\b"

      For Each dateValue As String In dates
         Dim match As Match = Regex.Match(dateValue, pattern)
         If match.Success Then
            Console.WriteLine(match.Value)
         End If   
      Next      
   End Sub
End Module
' The example displays the following output:
'       February 1, 2010
'       February 3, 2010
'       February 8, 2010

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] dates = { "Monday February 1, 2010", 
                         "Wednesday February 3, 2010", 
                         "Saturday February 6, 2010", 
                         "Sunday February 7, 2010", 
                         "Monday, February 8, 2010" };
      string pattern = @"(?<!(Saturday|Sunday) )\b\w+ \d{1,2}, \d{4}\b";

      foreach (string dateValue in dates)
      {
         Match match = Regex.Match(dateValue, pattern);
         if (match.Success)
            Console.WriteLine(match.Value);
      }      
   }
}
// The example displays the following output:
//       February 1, 2010
//       February 3, 2010
//       February 8, 2010

Das Muster für reguläre Ausdrücke (?<!(Saturday|Sunday) )\b\w+ \d{1,2}, \d{4}\b wird entsprechend der folgenden Tabelle interpretiert:

Muster

Beschreibungen

\b

Der Vergleich beginnt an einer Wortgrenze.

\w+

Suchen Sie nach einer Übereinstimmung mit einem oder mehreren Wortzeichen gefolgt von einem Leerzeichen.

\d{1,2},

Finden Sie eine Entsprechung für entweder eine oder zwei Dezimalstellen, gefolgt von einem Leerstellenzeichen und einem Komma.

\d{4}\b

Finden Sie eine Entsprechung für vier Dezimalstellen, und beenden Sie die Übereinstimmung an einer Wortgrenze.

(?<!(Saturday|Sunday) )

Wenn der Übereinstimmung etwas anderes als die Zeichenfolgen "Samstag" oder "Sonntag" (gefolgt von einem Leerzeichen) vorangestellt wird, ist die Übereinstimmung erfolgreich.

Nicht zurückverfolgende Teilausdrücke

Das folgende Gruppierungskonstrukt stellt einen nicht zurückverfolgenden Teilausdruck (auch bekannt als "gieriger" Teilausdruck) dar:

(?> subexpression )

wobei Teilausdruck jedes Muster eines regulären Ausdrucks ist.

Wenn ein regulärer Ausdruck ein optionales oder alternatives zusammenpassendes Muster einschließt, und eine Übereinstimmung nicht erfolgreich ist, kann sich das Modul für reguläre Ausdrücke in mehrere Richtungen verzweigen, um eine Entsprechung zwischen einer Eingabezeichenfolge und einem Muster zu finden. Wenn eine Übereinstimmung nach der ersten Verzweigung nicht gefunden wird, kann das Modul für reguläre Ausdrücke den Punkt der ersten Übereinstimmung sichern bzw. den Punkt zurückverfolgen und die Übereinstimmung mithilfe der zweiten Verzweigung durchführen. Dieser Prozess kann fortgesetzt werden, bis alle Verzweigungen versucht wurden.

Das (?>-Teilausdruck)-Sprachkonstrukt deaktiviert Rückverfolgung. Das Modul für reguläre Ausdrücke stimmt mit so vielen Zeichen in der Eingabezeichenfolge überein wie möglich. Wenn keine weitere Übereinstimmung möglich ist, findet Rückverfolgung statt, um alternative Musterübereinstimmungen zu verwenden. (Das heißt, der Teilausdruck sucht nur Entsprechungen für Zeichenfolgen, zu denen der Teilausdruck allein passen würde. Er versucht nicht, eine Entsprechung für eine Zeichenfolge auf Grundlage des Teilausdrucks und beliebige folgende Teilausdrücke zu finden.)

Diese Option wird empfohlen, wenn Sie wissen, dass Rückverfolgung erfolgreich nicht ist. Verhindert unnötige Suchläufe des Moduls und verbessert die Leistung.

Im folgenden Beispiel wird veranschaulicht, wie ein nicht zurückverfolgender Teilausdruck die Ergebnisse einer Musterübereinstimmung ändert. Der rückverfolgende reguläre Ausdruck findet erfolgreich eine Entsprechung für eine Reihe von Zeichen, die von einem weiteren Vorkommen des gleichen Zeichens auf einer Wortgrenze gefolgt wird. Der reguläre Ausdruck ohne Rückverfolgung macht dies nicht.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim inputs() As String = { "cccd.", "aaad", "aaaa" }
      Dim back As String = "(\w)\1+.\b"
      Dim noback As String = "(?>(\w)\1+).\b"

      For Each input As String In inputs
         Dim match1 As Match = Regex.Match(input, back)
         Dim match2 As Match = Regex.Match(input, noback)
         Console.WriteLine("{0}: ", input)

         Console.Write("   Backtracking : ")
         If match1.Success Then
            Console.WriteLine(match1.Value)
         Else
            Console.WriteLine("No match")
         End If

         Console.Write("   Nonbacktracking: ")
         If match2.Success Then
            Console.WriteLine(match2.Value)
         Else
            Console.WriteLine("No match")
         End If
      Next
   End Sub
End Module
' The example displays the following output:
'    cccd.:
'       Backtracking : cccd
'       Nonbacktracking: cccd
'    aaad:
'       Backtracking : aaad
'       Nonbacktracking: aaad
'    aaaa:
'       Backtracking : aaaa
'       Nonbacktracking: No match

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] inputs = { "cccd.", "aaad", "aaaa" };
      string back = @"(\w)\1+.\b";
      string noback = @"(?>(\w)\1+).\b";

      foreach (string input in inputs)
      {
         Match match1 = Regex.Match(input, back);
         Match match2 = Regex.Match(input, noback);
         Console.WriteLine("{0}: ", input);

         Console.Write("   Backtracking : ");
         if (match1.Success)
            Console.WriteLine(match1.Value);
         else
            Console.WriteLine("No match");

         Console.Write("   Nonbacktracking: ");
         if (match2.Success)
            Console.WriteLine(match2.Value);
         else
            Console.WriteLine("No match");
      }
   }
}
// The example displays the following output:
//    cccd.:
//       Backtracking : cccd
//       Nonbacktracking: cccd
//    aaad:
//       Backtracking : aaad
//       Nonbacktracking: aaad
//    aaaa:
//       Backtracking : aaaa
//       Nonbacktracking: No match

Der nicht zurückverfolgende reguläre Ausdruck (?>(\w)\1+).\b wird entsprechend der folgenden Tabelle definiert:

Muster

Beschreibungen

(\w)

Entspricht einem einzelnen Wortzeichen und weist es der ersten Erfassungsgruppe zu.

\1+

Finden Sie mindestens einmal eine Entsprechung für den Wert der zuerst aufgezeichneten Teilzeichenfolge.

.

Finden Sie eine Entsprechung für ein beliebiges Zeichen.

\b

Beendet den Vergleich an einer Wortgrenze.

(?>(\w)\1+)

Finden Sie eine Entsprechung für ein oder mehrere Vorkommen eines duplizierten Wortzeichens, aber machen Sie keine Rückverfolgung, um für das letzte Zeichen auf einer Wortgrenze eine Entsprechung zu finden.

Gruppieren von Konstrukten und Objekten für reguläre Ausdrücke

Teilzeichenfolgen, die von einer regulären Ausdruckserfassungsgruppe übereingestimmt werden, werden durch System.Text.RegularExpressions.Group-Objekte dargestellt, die aus dem System.Text.RegularExpressions.GroupCollection-Objekt abgerufen werden können, das von der Match.Groups-Eigenschaft zurückgegeben wird. Das GroupCollection-Objekt wird folgendermaßen aufgefüllt:

  • Das erste Group-Objekt in der Auflistung (das Objekt bei Index 0) stellt die gesamte Übereinstimmung dar.

  • Der nächste Satz von Group-Objekten stellt unbenannte (nummerierte) Erfassungsgruppen dar. Sie werden in der Reihenfolge angezeigt, in der sie im regulären Ausdruck definiert sind (von links nach rechts). Die Indexwerte dieser Gruppen reichen von 1 bis zur Anzahl unbenannter Erfassungsgruppen in der Auflistung. (Der Index einer bestimmten Gruppe entspricht seinem nummerierten Rückverweis. Weitere Informationen zu Rückverweisen finden Sie unter Rückverweiskonstrukte.)

  • Der endgültige Satz von Group-Objekten stellt benannte Erfassungsgruppen dar. Sie werden in der Reihenfolge angezeigt, in der sie im regulären Ausdruck definiert sind (von links nach rechts). Der Indexwert der zuerst benannten Erfassungsgruppe ist um eins größer als der Index der letzten unbenannten Erfassungsgruppe. Wenn es keine unbenannten Erfassungsgruppen im regulären Ausdruck gibt, ist der Indexwert der zuerst benannten Erfassungsgruppe 0 (null).

Wenn Sie einen Quantifizierer auf eine Erfassungsgruppe anwenden, reflektieren die entsprechenden Capture.Value-, Capture.Index- und Capture.Length-Eigenschaften des Group-Objekts die letzte Teilzeichenfolge, die von einer Erfassungsgruppe erfasst wird. Sie können einen vollständigen Satz von Teilzeichenfolgen abrufen, die von Gruppen erfasst werden, die Quantifizierer vom CaptureCollection-Objekt besitzen, das von der Group.Captures-Eigenschaft zurückgegeben wird.

Im folgenden Beispiel wird die Beziehung zwischen den Group- und Capture-Objekten veranschaulicht.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(\b(\w+)\W+)+"
      Dim input As String = "This is a short sentence."
      Dim match As Match = Regex.Match(input, pattern)
      Console.WriteLine("Match: {0}", match.Value)
      For ctr As Integer = 1 To match.Groups.Count - 1
         Console.WriteLine("   Group {0}: {1}", ctr, match.Groups(ctr).Value)
         Dim capCtr As Integer = 0
         For Each capture As Capture In match.Groups(ctr).Captures
            Console.WriteLine("      Capture {0}: {1}", capCtr, capture.Value)
            capCtr += 1
         Next
      Next
   End Sub
End Module
' The example displays the following output:
'       Match: This is a short sentence.
'          Group 1: sentence.
'             Capture 0: This
'             Capture 1: is
'             Capture 2: a
'             Capture 3: short
'             Capture 4: sentence.
'          Group 2: sentence
'             Capture 0: This
'             Capture 1: is
'             Capture 2: a
'             Capture 3: short
'             Capture 4: sentence

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\b(\w+)\W+)+";
      string input = "This is a short sentence.";
      Match match = Regex.Match(input, pattern);
      Console.WriteLine("Match: {0}", match.Value);
      for (int ctr = 1; ctr < match.Groups.Count; ctr++)
      {
         Console.WriteLine("   Group {0}: {1}", ctr, match.Groups[ctr].Value);
         int capCtr = 0;
         foreach (Capture capture in match.Groups[ctr].Captures)
         {
            Console.WriteLine("      Capture {0}: {1}", capCtr, capture.Value);
            capCtr++;
         }
      }
   }
}
// The example displays the following output:
//       Match: This is a short sentence.
//          Group 1: sentence.
//             Capture 0: This
//             Capture 1: is
//             Capture 2: a
//             Capture 3: short
//             Capture 4: sentence.
//          Group 2: sentence
//             Capture 0: This
//             Capture 1: is
//             Capture 2: a
//             Capture 3: short
//             Capture 4: sentence

Das Muster eines regulären Ausdrucks \b(\w+)\W+)+ extrahiert einzelne Wörter aus einer Zeichenfolge. Es ist in der folgenden Tabelle definiert.

Muster

Beschreibungen

\b

Der Vergleich beginnt an einer Wortgrenze.

(\w+)

Entsprechung für eines oder mehrere Wortzeichen finden. Zusammen bilden diese Zeichen ein Wort. Dies ist die zweite Erfassungsgruppe.

\W+

Entsprechung für mindestens ein Nicht-Wortzeichen finden.

(\w+)\W+)+

Suchen Sie nach einer Übereinstimmung für das Muster aus einem oder mehreren Wortzeichen, gefolgt entweder von einem oder mehreren nicht-Wort-Leerzeichen (ein oder zwei Mal). Dies ist die erste Erfassungsgruppe.

Die erste Erfassungsgruppe stimmt mit jedem Wort des Satzes überein. Die zweite Erfassungsgruppe vergleicht jedes Wort zusammen mit der Interpunktion und den Leerstellen, die auf das Wort folgen. Das Group-Objekt, dessen Index 2 ist, stellt Informationen zu dem Text bereit, der mit der zweiten Erfassungsgruppe übereinstimmt. Der vollständige Satz von Wörtern, die von der Erfassungsgruppe erfasst wurden, ist vom CaptureCollection-Objekt verfügbar, das von der Group.Captures-Eigenschaft zurückgegeben wurde.

Siehe auch

Konzepte

Sprachelemente für reguläre Ausdrücke

Backtracking