Das Objektmodell für reguläre Ausdrücke
In diesem Thema wird das Objektmodell beschrieben, das beim Arbeiten mit regulären .NET-Ausdrücken verwendet wird. Es enthält die folgenden Abschnitte:
The Regular Expression Engine (Die Engine für reguläre Ausdrücke)
The MatchCollection and Match Objects (Die MatchCollection- und Match-Objekte)
Die Engine für reguläre Ausdrücke
Die Engine für reguläre Ausdrücke in .NET wird durch die Regex-Klasse dargestellt. Die Engine für reguläre Ausdrücke ist für das Analysieren und Kompilieren eines regulären Ausdrucks sowie für das Ausführen von Vorgängen zuständig, die dem Muster eines regulären Ausdrucks mit einer Eingabezeichenfolge entsprechen. Die Engine ist die zentrale Komponente im .NET-Objektmodell für reguläre Ausdrücke.
Die Engine für reguläre Ausdrücke kann auf zwei verschiedene Arten verwendet werden:
Durch Aufrufen der statischen Methoden der Regex-Klasse. Die Methodenparameter schließen die Eingabezeichenfolge und das Muster eines regulären Ausdrucks ein. Die Engine für reguläre Ausdrücke führt eine Zwischenspeicherung der regulären Ausdrücke aus, die in statischen Methodenaufrufen verwendet werden. Daher zeigen wiederholte Aufrufe von statischen regulären Ausdrucksmethoden, für die der gleiche reguläre Ausdruck verwendet wird, eine relativ gute Leistung.
Durch Instanziieren eines Regex-Objekts und durch Übergeben eines regulären Ausdrucks an den Klassenkonstruktor. In diesem Fall ist das Regex-Objekt unveränderlich (schreibgeschützt) und stellt eine Engine für reguläre Ausdrücke dar, das eng an einen einzelnen regulären Ausdruck gekoppelt ist. Da von Regex-Instanzen verwendete reguläre Ausdrücke nicht zwischengespeichert werden, sollte ein Regex-Objekt nicht mehrmals mit dem gleichen regulären Ausdruck instanziiert werden.
Sie können die Methoden der Regex-Klasse aufrufen, um die folgenden Vorgänge auszuführen:
Bestimmen, ob eine Zeichenfolge mit einem Muster eines regulären Ausdrucks übereinstimmt.
Extrahieren einer einzelnen Übereinstimmung oder der ersten Übereinstimmung.
Extrahieren aller Übereinstimmungen.
Ersetzen einer übereinstimmenden Teilzeichenfolge.
Teilen einer einzelnen Zeichenfolge in ein Zeichenfolgenarray.
Diese Vorgänge werden in den folgenden Abschnitten beschrieben.
Vergleich eines Muster eines regulären Ausdrucks
Von der Regex.IsMatch-Methode wird true zurückgegeben, falls die Zeichenfolge mit dem Muster übereinstimmt, bzw. false, wenn dies nicht der Fall ist. Die IsMatch-Methode wird häufig dazu verwendet, um Zeichenfolgeneingaben zu überprüfen. Durch den folgende Code wird z. B. sichergestellt, dass eine Zeichenfolge mit einer gültigen Sozialunterstützungsnummer in den USA übereinstimmt.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string[] values = { "111-22-3333", "111-2-3333"};
string pattern = @"^\d{3}-\d{2}-\d{4}$";
foreach (string value in values) {
if (Regex.IsMatch(value, pattern))
Console.WriteLine("{0} is a valid SSN.", value);
else
Console.WriteLine("{0}: Invalid", value);
}
}
}
// The example displays the following output:
// 111-22-3333 is a valid SSN.
// 111-2-3333: Invalid
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim values() As String = {"111-22-3333", "111-2-3333"}
Dim pattern As String = "^\d{3}-\d{2}-\d{4}$"
For Each value As String In values
If Regex.IsMatch(value, pattern) Then
Console.WriteLine("{0} is a valid SSN.", value)
Else
Console.WriteLine("{0}: Invalid", value)
End If
Next
End Sub
End Module
' The example displays the following output:
' 111-22-3333 is a valid SSN.
' 111-2-3333: Invalid
Das Muster für reguläre Ausdrücke ^\d{3}-\d{2}-\d{4}$ wird entsprechend der folgenden Tabelle interpretiert:
| Muster | Beschreibung |
|---|---|
^ |
Entsprechung für den Anfang der Eingabezeichenfolge finden. |
\d{3} |
Entsprechung für drei Dezimalstellen finden. |
- |
Entsprechung für einen Bindestrich finden. |
\d{2} |
Entsprechung für zwei Dezimalstellen finden. |
- |
Entsprechung für einen Bindestrich finden. |
\d{4} |
Entsprechung für vier Dezimalstellen finden. |
$ |
Entsprechung für das Ende der Eingabezeichenfolge finden. |
Extrahieren einer einzelnen Übereinstimmung oder der ersten Übereinstimmung
Von der Regex.Match-Methode wird ein Match-Objekt zurückgegeben, das Informationen zur ersten Teilzeichenfolge enthält, die mit einem Muster eines regulären Ausdrucks übereinstimmt. Wenn die Match.Success-Eigenschaft true zurückgibt und angibt, dass eine Übereinstimmung gefunden wurde, können Sie Informationen zu nachfolgenden Übereinstimmungen abrufen, indem Sie die Match.NextMatch-Methode aufrufen. Diese Methodenaufrufe können fortgesetzt werden, bis die Match.Success-Eigenschaft false zurückgibt. Im folgenden Code wird zum Beispiel mithilfe der Regex.Match(String, String)-Methode das erste Vorkommen eines doppelt vorhandenen Worts in einer Zeichenfolge gesucht. Anschließend wird die Match.NextMatch-Methode aufgerufen, um zusätzliche Vorkommen zu suchen. Im Beispiel wird die Match.Success-Eigenschaft nach jedem Methodenaufruf überprüft, um zu bestimmen, ob die aktuelle Übereinstimmung erfolgreich war, und ob ein Aufruf der Match.NextMatch-Methode folgen soll.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "This is a a farm that that raises dairy cattle.";
string pattern = @"\b(\w+)\W+(\1)\b";
Match match = Regex.Match(input, pattern);
while (match.Success)
{
Console.WriteLine("Duplicate '{0}' found at position {1}.",
match.Groups[1].Value, match.Groups[2].Index);
match = match.NextMatch();
}
}
}
// The example displays the following output:
// Duplicate 'a' found at position 10.
// Duplicate 'that' found at position 22.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "This is a a farm that that raises dairy cattle."
Dim pattern As String = "\b(\w+)\W+(\1)\b"
Dim match As Match = Regex.Match(input, pattern)
Do While match.Success
Console.WriteLine("Duplicate '{0}' found at position {1}.", _
match.Groups(1).Value, match.Groups(2).Index)
match = match.NextMatch()
Loop
End Sub
End Module
' The example displays the following output:
' Duplicate 'a' found at position 10.
' Duplicate 'that' found at position 22.
Das Muster für reguläre Ausdrücke \b(\w+)\W+(\1)\b wird entsprechend der folgenden Tabelle interpretiert:
| Muster | Beschreibung |
|---|---|
\b |
Beginnt den Vergleich an einer Wortgrenze. |
(\w+) |
Übereinstimmung mit mindestens einem Wortzeichen. Dies ist die erste Erfassungsgruppe. |
\W+ |
Entsprechung für mindestens ein Nicht-Wortzeichen finden. |
(\1) |
Entsprechung für die erste erfasste Zeichenfolge finden. Dies ist die zweite Erfassungsgruppe. |
\b |
Beendet den Vergleich an einer Wortgrenze. |
Extrahieren aller Übereinstimmungen
Von der Regex.Matches-Methode wird ein MatchCollection-Objekt zurückgegeben, das Informationen zu allen Übereinstimmungen enthält, die von der Engine für reguläre Ausdrücke in der Eingabezeichenfolge gefunden wurden. Zum Beispiel kann das vorherige Beispiel neu geschrieben werden, um die Matches-Methode anstelle der Match-Methode und der NextMatch-Methode aufzurufen.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "This is a a farm that that raises dairy cattle.";
string pattern = @"\b(\w+)\W+(\1)\b";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine("Duplicate '{0}' found at position {1}.",
match.Groups[1].Value, match.Groups[2].Index);
}
}
// The example displays the following output:
// Duplicate 'a' found at position 10.
// Duplicate 'that' found at position 22.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "This is a a farm that that raises dairy cattle."
Dim pattern As String = "\b(\w+)\W+(\1)\b"
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine("Duplicate '{0}' found at position {1}.", _
match.Groups(1).Value, match.Groups(2).Index)
Next
End Sub
End Module
' The example displays the following output:
' Duplicate 'a' found at position 10.
' Duplicate 'that' found at position 22.
Ersetzen einer übereinstimmenden Teilzeichenfolge
Die Regex.Replace-Methode ersetzt jede Teilzeichenfolge, die mit dem Muster eines regulären Ausdrucks mit einer angegebenen Zeichenfolge oder einem Muster eines regulären Ausdrucks übereinstimmt, und gibt die gesamte Eingabezeichenfolge mit Ersetzungen zurück. Beispielsweise fügt der folgende Code ein US-Währungssymbol vor einer Dezimalzahl in einer Zeichenfolge hinzu.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\b\d+\.\d{2}\b";
string replacement = "$$$&";
string input = "Total Cost: 103.64";
Console.WriteLine(Regex.Replace(input, pattern, replacement));
}
}
// The example displays the following output:
// Total Cost: $103.64
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\b\d+\.\d{2}\b"
Dim replacement As String = "$$$&"
Dim input As String = "Total Cost: 103.64"
Console.WriteLine(Regex.Replace(input, pattern, replacement))
End Sub
End Module
' The example displays the following output:
' Total Cost: $103.64
Das Muster für reguläre Ausdrücke \b\d+\.\d{2}\b wird entsprechend der folgenden Tabelle interpretiert:
| Muster | Beschreibung |
|---|---|
\b |
Der Vergleich beginnt an einer Wortgrenze. |
\d+ |
Entsprechung für mindestens eine Dezimalstelle finden. |
\. |
Entsprechung für einen Punkt finden. |
\d{2} |
Entsprechung für zwei Dezimalstellen finden. |
\b |
Der Vergleich endet an einer Wortgrenze. |
Das Ersetzungsmuster $$$& wird gemäß der Darstellung in der folgenden Tabelle interpretiert.
| Muster | Ersetzungszeichenfolge |
|---|---|
$$ |
Das Dollarzeichen ($). |
$& |
Die gesamte abgeglichene Teilzeichenfolge. |
Aufteilen einer einzelnen Zeichenfolge in ein Zeichenfolgenarray
Mit der Regex.Split-Methode wird die Eingabezeichenfolge an den Stellen aufgeteilt, die durch eine Übereinstimmung bei einem regulären Ausdruck definiert wurde. Im folgenden Code werden z. B. die Elemente in ein Zeichenfolgenarray in einer nummerierten Liste eingefügt.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "1. Eggs 2. Bread 3. Milk 4. Coffee 5. Tea";
string pattern = @"\b\d{1,2}\.\s";
foreach (string item in Regex.Split(input, pattern))
{
if (! String.IsNullOrEmpty(item))
Console.WriteLine(item);
}
}
}
// The example displays the following output:
// Eggs
// Bread
// Milk
// Coffee
// Tea
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "1. Eggs 2. Bread 3. Milk 4. Coffee 5. Tea"
Dim pattern As String = "\b\d{1,2}\.\s"
For Each item As String In Regex.Split(input, pattern)
If Not String.IsNullOrEmpty(item) Then
Console.WriteLine(item)
End If
Next
End Sub
End Module
' The example displays the following output:
' Eggs
' Bread
' Milk
' Coffee
' Tea
Das Muster für reguläre Ausdrücke \b\d{1,2}\.\s wird entsprechend der folgenden Tabelle interpretiert:
| Muster | Beschreibung |
|---|---|
\b |
Der Vergleich beginnt an einer Wortgrenze. |
\d{1,2} |
Entsprechung für eine oder zwei Dezimalstellen finden. |
\. |
Entsprechung für einen Punkt finden. |
\s |
Entsprechung für ein Leerraumzeichen finden. |
Die MatchCollection- und Match-Objekte
Regex-Methoden geben zwei Objekte zurück, die Teil des Objektmodells für einen regulären Ausdruck sind: das MatchCollection-Objekt und das Match-Objekt.
Die Match-Auflistung
Die Regex.Matches-Methode gibt ein MatchCollection-Objekt zurück, das Match-Objekte enthält, die alle Übereinstimmungen darstellen, die die Engine für reguläre Ausdrücke gefunden hat, und zwar in der Reihenfolge, in der sie in der Eingabezeichenfolge auftreten. Wenn keine Übereinstimmungen vorhanden sind, gibt die Methode ein MatchCollection-Objekt ohne Member zurück. Die MatchCollection.Item[]-Eigenschaft ermöglicht den Zugriff auf einzelne Member der Auflistung nach Index, von null bis eins weniger als es dem Wert der MatchCollection.Count-Eigenschaft entspricht. Item[] ist der Indexer (in C#) und die Standardeigenschaft der Auflistung (in Visual Basic).
Der Aufruf der Regex.Matches-Methode füllt standardmäßig das MatchCollection-Objekt mithilfe verzögerter Auswertung auf. Zugriff auf Eigenschaften, die eine vollständig aufgefüllte Auflistung erfordern, z. B. die MatchCollection.Count-Eigenschaft und die MatchCollection.Item[]-Eigenschaft, führt möglicherweise zu Leistungseinbußen. Daher wird empfohlen, dass Sie auf die Auflistung mit dem IEnumerator-Objekt zugreifen, das von der MatchCollection.GetEnumerator-Methode zurückgegeben wird. Einzelne Sprachen stellen Konstrukte bereit, z.B. For Each in Visual Basic und foreach in C#, die die IEnumerator-Schnittstelle der Auflistung umschließen.
Im folgenden Beispiel wird mithilfe der Regex.Matches(String)-Methode ein MatchCollection-Objekt mit sämtlichen Übereinstimmungen aufgefüllt, die in einer Eingabezeichenfolge gefunden wurden. Im Beispiel wird die Auflistung aufgeführt, die Übereinstimmungen werden in ein Zeichenfolgenarray kopiert, und die Zeichenpositionen werden in einem ganzzahligen Array erfasst.
using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
MatchCollection matches;
List<string> results = new List<string>();
List<int> matchposition = new List<int>();
// Create a new Regex object and define the regular expression.
Regex r = new Regex("abc");
// Use the Matches method to find all matches in the input string.
matches = r.Matches("123abc4abcd");
// Enumerate the collection to retrieve all matches and positions.
foreach (Match match in matches)
{
// Add the match string to the string array.
results.Add(match.Value);
// Record the character position where the match was found.
matchposition.Add(match.Index);
}
// List the results.
for (int ctr = 0; ctr < results.Count; ctr++)
Console.WriteLine("'{0}' found at position {1}.",
results[ctr], matchposition[ctr]);
}
}
// The example displays the following output:
// 'abc' found at position 3.
// 'abc' found at position 7.
Imports System.Collections.Generic
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim matches As MatchCollection
Dim results As New List(Of String)
Dim matchposition As New List(Of Integer)
' Create a new Regex object and define the regular expression.
Dim r As New Regex("abc")
' Use the Matches method to find all matches in the input string.
matches = r.Matches("123abc4abcd")
' Enumerate the collection to retrieve all matches and positions.
For Each match As Match In matches
' Add the match string to the string array.
results.Add(match.Value)
' Record the character position where the match was found.
matchposition.Add(match.Index)
Next
' List the results.
For ctr As Integer = 0 To results.Count - 1
Console.WriteLine("'{0}' found at position {1}.", _
results(ctr), matchposition(ctr))
Next
End Sub
End Module
' The example displays the following output:
' 'abc' found at position 3.
' 'abc' found at position 7.
Die Übereinstimmung
Die Match-Klasse stellt das Ergebnis einer einzelnen regulären Ausdrucksübereinstimmung dar. Es gibt zwei Möglichkeiten für den Zugriff auf Match-Objekte:
Sie können von dem MatchCollection-Objekt abgerufen werden, das von der Regex.Matches-Methode zurückgegeben wird. Um einzelne Match-Objekte abzurufen, durchlaufen Sie die Auflistung mit einem
foreach-Konstrukt (in C#) oder einemFor Each...Next-Konstrukt (in Visual Basic), oder rufen Sie mithilfe der MatchCollection.Item[]-Eigenschaft ein bestimmtes Match-Objekt Objekt nach Index oder Name ab. Sie können auch einzelne Match-Objekte aus der Auflistung abrufen, indem Sie die Auflistung nach dem Index durchlaufen, von 0 (null) bis eins weniger, als es der Anzahl der Objekte in der Auflistung entspricht. Bei dieser Methode wird jedoch keine verzögerte Auswertung genutzt, da dabei auf die MatchCollection.Count-Eigenschaft zugegriffen wird.Im folgenden Beispiel werden einzelne Match-Objekte aus einem MatchCollection-Objekt abgerufen, indem die Auflistung mit einem
foreach- oderFor Each...Next-Konstrukt durchlaufen wird. Der reguläre Ausdruck stimmt mit der Zeichenfolge "abc" in der Eingabezeichenfolge überein.using System; using System.Text.RegularExpressions; public class Example { public static void Main() { string pattern = "abc"; string input = "abc123abc456abc789"; foreach (Match match in Regex.Matches(input, pattern)) Console.WriteLine("{0} found at position {1}.", match.Value, match.Index); } } // The example displays the following output: // abc found at position 0. // abc found at position 6. // abc found at position 12.Imports System.Text.RegularExpressions Module Example Public Sub Main() Dim pattern As String = "abc" Dim input As String = "abc123abc456abc789" For Each match As Match In Regex.Matches(input, pattern) Console.WriteLine("{0} found at position {1}.", _ match.Value, match.Index) Next End Sub End Module ' The example displays the following output: ' abc found at position 0. ' abc found at position 6. ' abc found at position 12.Durch Aufrufen der Regex.Match-Methode, die ein Match-Objekt zurückgibt, das die erste Übereinstimmung in einer Zeichenfolge oder einem Teil einer Zeichenfolge darstellt. Sie können bestimmen, ob die Übereinstimmung gefunden wurde, indem der Wert der
Match.Success-Eigenschaft abgerufen wird. Um Match-Objekte abzurufen, die nachfolgende Übereinstimmungen darstellen, rufen Sie die Match.NextMatch-Methode wiederholt auf, bis dieSuccess-Eigenschaft des zurückgegebenen Match-Objektsfalseist.Im folgenden Beispiel werden die Regex.Match(String, String)-Methode und die Match.NextMatch-Methode verwendet, um die Zeichenfolge "abc" in der Eingabezeichenfolge abzugleichen.
using System; using System.Text.RegularExpressions; public class Example { public static void Main() { string pattern = "abc"; string input = "abc123abc456abc789"; Match match = Regex.Match(input, pattern); while (match.Success) { Console.WriteLine("{0} found at position {1}.", match.Value, match.Index); match = match.NextMatch(); } } } // The example displays the following output: // abc found at position 0. // abc found at position 6. // abc found at position 12.Imports System.Text.RegularExpressions Module Example Public Sub Main() Dim pattern As String = "abc" Dim input As String = "abc123abc456abc789" Dim match As Match = Regex.Match(input, pattern) Do While match.Success Console.WriteLine("{0} found at position {1}.", _ match.Value, match.Index) match = match.NextMatch() Loop End Sub End Module ' The example displays the following output: ' abc found at position 0. ' abc found at position 6. ' abc found at position 12.
Zwei Eigenschaften der Match-Klasse geben Auflistungsobjekte zurück:
Die Match.Groups-Eigenschaft gibt ein GroupCollection-Objekt zurück, das Informationen zu den Teilzeichenfolgen enthält, die mit Erfassungsgruppen im Muster eines regulären Ausdrucks übereinstimmen.
Die
Match.Captures-Eigenschaft gibt ein CaptureCollection-Objekt mit eingeschränkter Verwendung zurück. Die Auflistung wird nicht für ein Match-Objekt aufgefüllt, dessenSuccess-Eigenschaftfalseist. Andernfalls enthält es ein einzelnes Capture-Objekt, das über die gleichen Informationen wie das Match-Objekt verfügt.
Weitere Informationen zu diesen Objekten finden Sie in den Abschnitten Die Gruppensammlung und Die Erfassungssammlung im weiteren Verlauf dieses Themas.
Zwei zusätzliche Eigenschaften der Match-Klasse stellen Informationen zur Übereinstimmung bereit. Die Match.Value-Eigenschaft gibt die Teilzeichenfolge in der Eingabezeichenfolge zurück, die mit dem Muster eines regulären Ausdrucks übereinstimmt. Die Match.Index-Eigenschaft gibt die nullbasierte Anfangsposition der entsprechenden Zeichenfolge in der Eingabezeichenfolge zurück.
Die Match-Klasse besitzt ebenfalls zwei Methoden zum Mustervergleich:
Die Match.NextMatch-Methode sucht die Übereinstimmung nach der Übereinstimmung, die durch das aktuelle Match-Objekt dargestellt wird, und gibt ein Match-Objekt zurück, das diese Übereinstimmung darstellt.
Die Match.Result-Methode führt einen angegebenen Ersetzungsvorgang in der entsprechenden Zeichenfolge aus und gibt das Ergebnis zurück.
Im folgenden Beispiel werden mit der Match.Result-Methode jeder Zahl, die zwei Bruchzahlen enthält, ein $-Symbol und ein Leerzeichen vorangestellt.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\b\d+(,\d{3})*\.\d{2}\b";
string input = "16.32\n194.03\n1,903,672.08";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine(match.Result("$$ $&"));
}
}
// The example displays the following output:
// $ 16.32
// $ 194.03
// $ 1,903,672.08
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\b\d+(,\d{3})*\.\d{2}\b"
Dim input As String = "16.32" + vbCrLf + "194.03" + vbCrLf + "1,903,672.08"
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine(match.Result("$$ $&"))
Next
End Sub
End Module
' The example displays the following output:
' $ 16.32
' $ 194.03
' $ 1,903,672.08
Das Muster für reguläre Ausdrücke \b\d+(,\d{3})*\.\d{2}\b wird entsprechend der folgenden Tabelle definiert:
| Muster | Beschreibung |
|---|---|
\b |
Der Vergleich beginnt an einer Wortgrenze. |
\d+ |
Entsprechung für mindestens eine Dezimalstelle finden. |
(,\d{3})* |
Entsprechung für null oder mehr Vorkommen eines Kommas finden, auf das Dezimalstellen folgen. |
\. |
Entsprechung für das Dezimaltrennzeichenzeichen finden. |
\d{2} |
Entsprechung für zwei Dezimalstellen finden. |
\b |
Der Vergleich endet an einer Wortgrenze. |
Der Ersatzmuster-$$ $& gibt an, dass die übereinstimmende Teilzeichenfolge durch ein Dollarzeichensymbol ($) (das $$-Muster), ein Leerzeichen und den Wert der Übereinstimmung (das $&-Muster) ersetzt werden soll.
Die Gruppenauflistung
Die Match.Groups-Eigenschaft gibt ein GroupCollection-Objekt zurück, das Group-Objekte enthält, die erfasste Gruppen in einer einzelnen Übereinstimmung darstellen. Das erste Group-Objekt in der Auflistung (an Index 0) stellt die gesamte Übereinstimmung dar. Jedes Objekt, das folgt, stellt die Ergebnisse einer einzelnen Erfassungsgruppe dar.
Sie können einzelne Group-Objekte in der Auflistung mit der GroupCollection.Item[]-Eigenschaft abrufen. Sie können unbenannte Gruppen durch ihre Ordnungsposition in der Auflistung abrufen und benannte Gruppen entweder nach dem Namen oder nach der Ordnungsposition abrufen. Unbenannte Erfassungen werden zuerst in der Auflistung angezeigt und werden von links nach rechts in der Reihenfolge indiziert, in der sie im Muster eines regulären Ausdrucks angezeigt werden. Benannte Erfassungen werden nach unbenannten Erfassungen von links nach rechts in der Reihenfolge indiziert, in der sie im Muster eines regulären Ausdrucks angezeigt werden. Um festzustellen, welche nummerierten Gruppen in der Auflistung verfügbar sind, die für eine bestimmte Methode für Übereinstimmungen mit regulären Ausdrücken zurückgegeben wird, können Sie die Instanzenmethode Regex.GetGroupNumbers aufrufen. Um festzustellen, welche benannten Gruppen in der Auflistung verfügbar sind, können Sie die Instanzenmethode Regex.GetGroupNames aufrufen. Beide Methoden sind besonders nützlich in Allzweckroutinen, die die von beliebigen regulären Ausdrücken gefundenen Übereinstimmungen analysieren.
Die GroupCollection.Item[]-Eigenschaft ist der Indexer der Auflistung in C# und der Standardeigenschaft des Auflistungsobjekts in Visual Basic. Dies bedeutet, dass auf diese einzelnen Group-Objekte wie folgt nach Index (oder nach Name bei benannten Gruppen) zugegriffen werden kann:
Group group = match.Groups[ctr];
Dim group As Group = match.Groups(ctr)
Im folgenden Beispiel wird ein regulärer Ausdruck definiert, der Gruppierungskonstrukte verwendet, um Monat, Tag und Jahr eines Datums zu erfassen.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\b(\w+)\s(\d{1,2}),\s(\d{4})\b";
string input = "Born: July 28, 1989";
Match match = Regex.Match(input, pattern);
if (match.Success)
for (int ctr = 0; ctr < match.Groups.Count; ctr++)
Console.WriteLine("Group {0}: {1}", ctr, match.Groups[ctr].Value);
}
}
// The example displays the following output:
// Group 0: July 28, 1989
// Group 1: July
// Group 2: 28
// Group 3: 1989
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\b(\w+)\s(\d{1,2}),\s(\d{4})\b"
Dim input As String = "Born: July 28, 1989"
Dim match As Match = Regex.Match(input, pattern)
If match.Success Then
For ctr As Integer = 0 To match.Groups.Count - 1
Console.WriteLine("Group {0}: {1}", ctr, match.Groups(ctr).Value)
Next
End If
End Sub
End Module
' The example displays the following output:
' Group 0: July 28, 1989
' Group 1: July
' Group 2: 28
' Group 3: 1989
Das Muster für reguläre Ausdrücke \b(\w+)\s(\d{1,2}),\s(\d{4})\b wird entsprechend der folgenden Tabelle definiert:
| Muster | Beschreibung |
|---|---|
\b |
Der Vergleich beginnt an einer Wortgrenze. |
(\w+) |
Übereinstimmung mit mindestens einem Wortzeichen. Dies ist die erste Erfassungsgruppe. |
\s |
Entsprechung für ein Leerraumzeichen finden. |
(\d{1,2}) |
Entsprechung für eine oder zwei Dezimalstellen finden. Dies ist die zweite Erfassungsgruppe. |
, |
Entsprechung für ein Komma finden. |
\s |
Entsprechung für ein Leerraumzeichen finden. |
(\d{4}) |
Entsprechung für vier Dezimalstellen finden. Dies ist die dritte Erfassungsgruppe. |
\b |
Beendet den Vergleich an einer Wortgrenze. |
Die erfasste Gruppe
Die Group-Klasse stellt das von einer einzelnen Erfassungsgruppe erfassten Ergebnis dar. Gruppenobjekte, die die Erfassungsgruppen darstellen, die in einem regulären Ausdruck definiert werden, werden von der Item[]-Eigenschaft des GroupCollection-Objekts zurückgegeben, das von der Match.Groups-Eigenschaft zurückgegeben wurde. Die Item[]-Eigenschaft ist der Indexer (in C#) und die Standardeigenschaft (in Visual Basic) Group-Klasse. Sie können auch einzelne Member abrufen, indem Sie die Auflistung mit dem foreach- oder dem For Each-Konstrukt durchlaufen. Ein Beispiel finden Sie im vorherigen Abschnitt.
Im folgenden Beispiel werden verschachtelte Gruppierungskonstrukte verwendet, um Teilzeichenfolgen in Gruppen aufzuzeichnen. Das Muster eines regulären Ausdrucks (a(b))c stimmt mit der Zeichenfolge "abc" überein. Es weist die Teilzeichenfolgen "ab" der ersten Erfassungsgruppe und die Teilzeichenfolge "b" der zweiten Erfassungsgruppe zu.
var matchposition = new List<int>();
var results = new List<string>();
// Define substrings abc, ab, b.
var r = new Regex("(a(b))c");
Match m = r.Match("abdabc");
for (int i = 0; m.Groups[i].Value != ""; i++)
{
// Add groups to string array.
results.Add(m.Groups[i].Value);
// Record character position.
matchposition.Add(m.Groups[i].Index);
}
// Display the capture groups.
for (int ctr = 0; ctr < results.Count; ctr++)
Console.WriteLine("{0} at position {1}",
results[ctr], matchposition[ctr]);
// The example displays the following output:
// abc at position 3
// ab at position 3
// b at position 4
Dim matchposition As New List(Of Integer)
Dim results As New List(Of String)
' Define substrings abc, ab, b.
Dim r As New Regex("(a(b))c")
Dim m As Match = r.Match("abdabc")
Dim i As Integer = 0
While Not (m.Groups(i).Value = "")
' Add groups to string array.
results.Add(m.Groups(i).Value)
' Record character position.
matchposition.Add(m.Groups(i).Index)
i += 1
End While
' Display the capture groups.
For ctr As Integer = 0 to results.Count - 1
Console.WriteLine("{0} at position {1}", _
results(ctr), matchposition(ctr))
Next
' The example displays the following output:
' abc at position 3
' ab at position 3
' b at position 4
Im folgenden Codebeispiel werden benannte Gruppierungskonstrukte verwendet, um Teilzeichenfolgen in einer Zeichenfolge zu erfassen, die Daten im Format "DATENNAME:WERT" enthält. Durch den regulären Ausdruck werden diese am Doppelpunkt (:) getrennt.
var r = new Regex(@"^(?<name>\w+):(?<value>\w+)");
Match m = r.Match("Section1:119900");
Console.WriteLine(m.Groups["name"].Value);
Console.WriteLine(m.Groups["value"].Value);
// The example displays the following output:
// Section1
// 119900
Dim r As New Regex("^(?<name>\w+):(?<value>\w+)")
Dim m As Match = r.Match("Section1:119900")
Console.WriteLine(m.Groups("name").Value)
Console.WriteLine(m.Groups("value").Value)
' The example displays the following output:
' Section1
' 119900
Das Muster für reguläre Ausdrücke ^(?<name>\w+):(?<value>\w+) wird entsprechend der folgenden Tabelle definiert:
| Muster | Beschreibung |
|---|---|
^ |
Beginnt den Vergleich am Anfang der Eingabezeichenfolge. |
(?<name>\w+) |
Übereinstimmung mit mindestens einem Wortzeichen. Der Name dieser Erfassungsgruppe ist name. |
: |
Entsprechung für einen Doppelpunkt finden. |
(?<value>\w+) |
Übereinstimmung mit mindestens einem Wortzeichen. Der Name dieser Erfassungsgruppe ist value. |
Die Eigenschaften der Group-Klasse enthalten Informationen zur erfassten Gruppe: Die Group.Value-Eigenschaft enthält die erfasste Teilzeichenfolge, die Group.Index-Eigenschaft gibt die Anfangsposition der erfassten Gruppe im Eingabetext an, die Group.Length-Eigenschaft enthält die Länge des erfassten Texts, und die Group.Success-Eigenschaft gibt an, ob eine Teilzeichenfolge dem Muster entsprach, das durch die Erfassungsgruppe definiert wurde.
Durch Anwenden von Quantifizierern auf eine Gruppe (weitere Informationen finden Sie unter Quantifizierer) wird die Beziehung einer Erfassung pro Erfassungsgruppe in zweierlei Hinsicht geändert:
Wenn der
*-Quantifizierer oder der*?-Quantifizierer (der null oder mehr Übereinstimmungen angibt) für eine Gruppe übernommen wird, verfügt eine Erfassungsgruppe möglicherweise über keine Übereinstimmung in der Eingabezeichenfolge. Wenn kein erfasster Text vorhanden ist, werden die Eigenschaften des Group-Objekts entsprechend der Darstellung in der folgenden Tabelle festgelegt.Gruppeneigenschaft Wert SuccessfalseValueString.Empty Length0 Dies wird im folgenden Beispiel veranschaulicht. Im Muster eines regulären Ausdrucks
aaa(bbb)*ccckann es für die erste Erfassungsgruppe (die Teilzeichenfolge "bbb") null oder mehrere Übereinstimmungen geben. Da die Eingabezeichenfolge "aaaccc" dem Muster entspricht, weist die Erfassungsgruppe keine Übereinstimmung auf.using System; using System.Text.RegularExpressions; public class Example { public static void Main() { string pattern = "aaa(bbb)*ccc"; string input = "aaaccc"; Match match = Regex.Match(input, pattern); Console.WriteLine("Match value: {0}", match.Value); if (match.Groups[1].Success) Console.WriteLine("Group 1 value: {0}", match.Groups[1].Value); else Console.WriteLine("The first capturing group has no match."); } } // The example displays the following output: // Match value: aaaccc // The first capturing group has no match.Imports System.Text.RegularExpressions Module Example Public Sub Main() Dim pattern As String = "aaa(bbb)*ccc" Dim input As String = "aaaccc" Dim match As Match = Regex.Match(input, pattern) Console.WriteLine("Match value: {0}", match.Value) If match.Groups(1).Success Then Console.WriteLine("Group 1 value: {0}", match.Groups(1).Value) Else Console.WriteLine("The first capturing group has no match.") End If End Sub End Module ' The example displays the following output: ' Match value: aaaccc ' The first capturing group has no match.Quantifizierer können mit mehreren Vorkommen eines Musters übereinstimmen, das durch eine Erfassungsgruppe definiert wird. In diesem Fall enthalten die
Value-Eigenschaft und dieLength-Eigenschaft eines Group-Objekts nur Informationen zur letzten erfassten Teilzeichenfolge. Der folgende reguläre Ausdruck entspricht z. B. einem einzelnen Satz, der mit einem Punkt endet. Es werden zwei Gruppierungskonstrukte verwendet: Mit dem ersten Konstrukt werden einzelne Wörter mit einem Leerstellenzeichen erfasst und mit dem zweiten einzelne Wörter. Wie die Ausgabe des Beispiels zeigt, erfasst die zweite Erfassungsgruppe nur das letzte Wort, obwohl mit dem regulären Ausdruck ein vollständiger Satz erfasst wird.using System; using System.Text.RegularExpressions; public class Example { public static void Main() { string pattern = @"\b((\w+)\s?)+\."; string input = "This is a sentence. This is another sentence."; Match match = Regex.Match(input, pattern); if (match.Success) { Console.WriteLine("Match: " + match.Value); Console.WriteLine("Group 2: " + match.Groups[2].Value); } } } // The example displays the following output: // Match: This is a sentence. // Group 2: sentenceImports System.Text.RegularExpressions Module Example Public Sub Main() Dim pattern As String = "\b((\w+)\s?)+\." Dim input As String = "This is a sentence. This is another sentence." Dim match As Match = Regex.Match(input, pattern) If match.Success Then Console.WriteLine("Match: " + match.Value) Console.WriteLine("Group 2: " + match.Groups(2).Value) End If End Sub End Module ' The example displays the following output: ' Match: This is a sentence. ' Group 2: sentence
Die Erfassungsauflistung
Das Group-Objekt enthält nur Informationen zur letzten Erfassung. Allerdings sind alle Erfassungen, die von einer Erfassungsgruppe gemacht wurden, nach wie vor über das CaptureCollection-Objekt verfügbar, das von der Group.Captures-Eigenschaft zurückgegeben wird. Jeder Member der Auflistung ist ein Capture-Objekt, das eine von dieser Erfassungsgruppe gemachte Erfassung darstellt, und zwar in der Reihenfolge, in der sie erfasst wurden (und daher in der Reihenfolge, in der die erfassten Zeichenfolgen von links nach rechts in der Eingabezeichenfolge abgeglichen wurden). Einzelne Capture-Objekte können auf zwei unterschiedliche Arten aus der Auflistung abgerufen werden:
Durch das Durchlaufen der Sammlung mit einem Konstrukt wie
foreach(in C#) oderFor Each(in Visual Basic).Mit der CaptureCollection.Item[]-Eigenschaft, um ein bestimmtes Objekt nach Index abzurufen. Die Item[]-Eigenschaft ist die Standardeigenschaft des CaptureCollection-Objekts (in Visual Basic) oder Indexer (in C#).
Wenn ein Quantifizierer nicht für eine Erfassungsgruppe übernommen wird, enthält das CaptureCollection-Objekt ein einzelnes Capture-Objekt, das von geringem Interesse ist, da es Informationen zur gleichen Übereinstimmung wie das Group-Objekt enthält. Wenn ein Quantifizierer für eine Erfassungsgruppe übernommen wird, enthält das CaptureCollection-Objekt alle von der Erfassungsgruppe gemachten Erfassungen, und der letzte Member der Auflistung stellt die gleiche Erfassung wie das Group-Objekt dar.
Wenn Sie zum Beispiel das Muster ((a(b))c)+ eines regulären Ausdrucks verwenden (wobei der +-Quantifizierer mindestens eine Übereinstimmung angibt), um Übereinstimmungen von der Zeichenfolge "abcabcabc" zu erfassen, enthält das CaptureCollection-Objekt für jedes Group-Objekt drei Member.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = "((a(b))c)+";
string input = "abcabcabc";
Match match = Regex.Match(input, pattern);
if (match.Success)
{
Console.WriteLine("Match: '{0}' at position {1}",
match.Value, match.Index);
GroupCollection groups = match.Groups;
for (int ctr = 0; ctr < groups.Count; ctr++) {
Console.WriteLine(" Group {0}: '{1}' at position {2}",
ctr, groups[ctr].Value, groups[ctr].Index);
CaptureCollection captures = groups[ctr].Captures;
for (int ctr2 = 0; ctr2 < captures.Count; ctr2++) {
Console.WriteLine(" Capture {0}: '{1}' at position {2}",
ctr2, captures[ctr2].Value, captures[ctr2].Index);
}
}
}
}
}
// The example displays the following output:
// Match: 'abcabcabc' at position 0
// Group 0: 'abcabcabc' at position 0
// Capture 0: 'abcabcabc' at position 0
// Group 1: 'abc' at position 6
// Capture 0: 'abc' at position 0
// Capture 1: 'abc' at position 3
// Capture 2: 'abc' at position 6
// Group 2: 'ab' at position 6
// Capture 0: 'ab' at position 0
// Capture 1: 'ab' at position 3
// Capture 2: 'ab' at position 6
// Group 3: 'b' at position 7
// Capture 0: 'b' at position 1
// Capture 1: 'b' at position 4
// Capture 2: 'b' at position 7
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "((a(b))c)+"
Dim input As STring = "abcabcabc"
Dim match As Match = Regex.Match(input, pattern)
If match.Success Then
Console.WriteLine("Match: '{0}' at position {1}", _
match.Value, match.Index)
Dim groups As GroupCollection = match.Groups
For ctr As Integer = 0 To groups.Count - 1
Console.WriteLine(" Group {0}: '{1}' at position {2}", _
ctr, groups(ctr).Value, groups(ctr).Index)
Dim captures As CaptureCollection = groups(ctr).Captures
For ctr2 As Integer = 0 To captures.Count - 1
Console.WriteLine(" Capture {0}: '{1}' at position {2}", _
ctr2, captures(ctr2).Value, captures(ctr2).Index)
Next
Next
End If
End Sub
End Module
' The example displays the following output:
' Match: 'abcabcabc' at position 0
' Group 0: 'abcabcabc' at position 0
' Capture 0: 'abcabcabc' at position 0
' Group 1: 'abc' at position 6
' Capture 0: 'abc' at position 0
' Capture 1: 'abc' at position 3
' Capture 2: 'abc' at position 6
' Group 2: 'ab' at position 6
' Capture 0: 'ab' at position 0
' Capture 1: 'ab' at position 3
' Capture 2: 'ab' at position 6
' Group 3: 'b' at position 7
' Capture 0: 'b' at position 1
' Capture 1: 'b' at position 4
' Capture 2: 'b' at position 7
Im folgenden Beispiel wird der reguläre Ausdruck (Abc)+ verwendet, um mindestens eine aufeinanderfolgende Ausführung der Zeichenfolge "Abc" in der Zeichenfolge "XYZAbcAbcAbcXYZAbcAb" zu suchen. Das Beispiel veranschaulicht die Verwendung der Group.Captures-Eigenschaft, um mehrere Gruppen erfasster Teilzeichenfolgen zurückzugeben.
int counter;
Match m;
CaptureCollection cc;
GroupCollection gc;
// Look for groupings of "Abc".
var r = new Regex("(Abc)+");
// Define the string to search.
m = r.Match("XYZAbcAbcAbcXYZAbcAb");
gc = m.Groups;
// Display the number of groups.
Console.WriteLine("Captured groups = " + gc.Count.ToString());
// Loop through each group.
for (int i = 0; i < gc.Count; i++)
{
cc = gc[i].Captures;
counter = cc.Count;
// Display the number of captures in this group.
Console.WriteLine("Captures count = " + counter.ToString());
// Loop through each capture in the group.
for (int ii = 0; ii < counter; ii++)
{
// Display the capture and its position.
Console.WriteLine(cc[ii] + " Starts at character " +
cc[ii].Index);
}
}
// The example displays the following output:
// Captured groups = 2
// Captures count = 1
// AbcAbcAbc Starts at character 3
// Captures count = 3
// Abc Starts at character 3
// Abc Starts at character 6
// Abc Starts at character 9
Dim counter As Integer
Dim m As Match
Dim cc As CaptureCollection
Dim gc As GroupCollection
' Look for groupings of "Abc".
Dim r As New Regex("(Abc)+")
' Define the string to search.
m = r.Match("XYZAbcAbcAbcXYZAbcAb")
gc = m.Groups
' Display the number of groups.
Console.WriteLine("Captured groups = " & gc.Count.ToString())
' Loop through each group.
Dim i, ii As Integer
For i = 0 To gc.Count - 1
cc = gc(i).Captures
counter = cc.Count
' Display the number of captures in this group.
Console.WriteLine("Captures count = " & counter.ToString())
' Loop through each capture in the group.
For ii = 0 To counter - 1
' Display the capture and its position.
Console.WriteLine(cc(ii).ToString() _
& " Starts at character " & cc(ii).Index.ToString())
Next ii
Next i
' The example displays the following output:
' Captured groups = 2
' Captures count = 1
' AbcAbcAbc Starts at character 3
' Captures count = 3
' Abc Starts at character 3
' Abc Starts at character 6
' Abc Starts at character 9
Die einzelne Erfassung
Die Capture-Klasse enthält die Ergebnisse einer einzelnen Teilausdrucksuche. Die Capture.Value-Eigenschaft enthält den übereinstimmenden Text, und die Capture.Index-Eigenschaft gibt die nullbasierte Position in der Eingabezeichenfolge an, bei der die übereinstimmende Teilzeichenfolge beginnt.
Im folgenden Beispiel wird eine Eingabezeichenfolge hinsichtlich der Temperatur ausgewählter Orte analysiert. Ein Komma (",") wird verwendet, um einen Ort und seine Temperatur zu trennen. Ein Semikolon ("";) dient zum Trennen der Daten zu einzelnen Orten. Die gesamte Eingabezeichenfolge stellt eine einzelne Übereinstimmung dar. Im Muster ((\w+(\s\w+)*),(\d+);)+ eines regulären Ausdrucks, mit dem die Zeichenfolge analysiert wird, wird der Ortsname der zweiten Erfassungsgruppe und die Temperatur der vierten Erfassungsgruppe zugewiesen.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "Miami,78;Chicago,62;New York,67;San Francisco,59;Seattle,58;";
string pattern = @"((\w+(\s\w+)*),(\d+);)+";
Match match = Regex.Match(input, pattern);
if (match.Success)
{
Console.WriteLine("Current temperatures:");
for (int ctr = 0; ctr < match.Groups[2].Captures.Count; ctr++)
Console.WriteLine("{0,-20} {1,3}", match.Groups[2].Captures[ctr].Value,
match.Groups[4].Captures[ctr].Value);
}
}
}
// The example displays the following output:
// Current temperatures:
// Miami 78
// Chicago 62
// New York 67
// San Francisco 59
// Seattle 58
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "Miami,78;Chicago,62;New York,67;San Francisco,59;Seattle,58;"
Dim pattern As String = "((\w+(\s\w+)*),(\d+);)+"
Dim match As Match = Regex.Match(input, pattern)
If match.Success Then
Console.WriteLine("Current temperatures:")
For ctr As Integer = 0 To match.Groups(2).Captures.Count - 1
Console.WriteLine("{0,-20} {1,3}", match.Groups(2).Captures(ctr).Value, _
match.Groups(4).Captures(ctr).Value)
Next
End If
End Sub
End Module
' The example displays the following output:
' Current temperatures:
' Miami 78
' Chicago 62
' New York 67
' San Francisco 59
' Seattle 58
Der reguläre Ausdruck wird entsprechend der Darstellung in der folgenden Tabelle definiert:
| Muster | Beschreibung |
|---|---|
\w+ |
Übereinstimmung mit mindestens einem Wortzeichen. |
(\s\w+)* |
Entsprechung für null oder mehr Vorkommen eines Leerstellenzeichens finden, auf das mindestens ein Wortzeichen folgt. Dieses Muster entspricht Ortsnamen, die aus mehreren Wörtern bestehen. Dies ist die dritte Erfassungsgruppe. |
(\w+(\s\w+)*) |
Entsprechung für mindestens ein Wortzeichen finden, auf das null oder mehr Vorkommen eines Leerstellenzeichens folgen und mindestens ein Wortzeichen. Dies ist die zweite Erfassungsgruppe. |
, |
Entsprechung für ein Komma finden. |
(\d+) |
Entsprechung für mindestens eine Stelle finden. Dies ist die vierte Erfassungsgruppe. |
; |
Entsprechung für ein Semikolon finden. |
((\w+(\s\w+)*),(\d+);)+ |
Entsprechung für das Muster eines Worts finden, auf das alle weiteren Wörter folgen, auf die ein Komma, mindestens eine Ziffer und ein Semikolon folgen (mindestens einmal). Dies ist die erste Erfassungsgruppe. |
Siehe auch
Feedback
Bald verfügbar: Im Laufe des Jahres 2024 werden wir GitHub-Issues stufenweise als Feedbackmechanismus für Inhalte abbauen und durch ein neues Feedbacksystem ersetzen. Weitere Informationen finden Sie unter https://aka.ms/ContentUserFeedback.
Feedback senden und anzeigen für