Het objectmodel van de reguliere expressie
In dit onderwerp wordt het objectmodel beschreven dat wordt gebruikt voor het werken met reguliere .NET-expressies. Deze bevat de volgende secties:
De engine voor reguliere expressies
De engine voor reguliere expressies in .NET wordt vertegenwoordigd door de Regex klasse. De engine voor reguliere expressies is verantwoordelijk voor het parseren en compileren van een reguliere expressie, en voor het uitvoeren van bewerkingen die overeenkomen met het reguliere expressiepatroon met een invoertekenreeks. De engine is het centrale onderdeel in het .NET-objectmodel voor reguliere expressies.
U kunt de engine voor reguliere expressies op twee manieren gebruiken:
Door de statische methoden van de Regex klasse aan te roepen. De methodeparameters bevatten de invoertekenreeks en het reguliere expressiepatroon. De engine voor reguliere expressies slaat reguliere expressies op die worden gebruikt in statische methodeaanroepen. Herhaalde aanroepen naar statische reguliere expressiemethoden die gebruikmaken van dezelfde reguliere expressie bieden relatief goede prestaties.
Door een Regex object te instantiëren door een reguliere expressie door te geven aan de klasseconstructor. In dit geval is het Regex object onveranderbaar (alleen-lezen) en vertegenwoordigt het een reguliere expressie-engine die nauw is gekoppeld aan één reguliere expressie. Omdat reguliere expressies die door Regex exemplaren worden gebruikt, niet in de cache worden opgeslagen, moet u een Regex object niet meerdere keren instantiëren met dezelfde reguliere expressie.
U kunt de methoden van de Regex klasse aanroepen om de volgende bewerkingen uit te voeren:
Bepaal of een tekenreeks overeenkomt met een normaal expressiepatroon.
Pak één overeenkomst of de eerste overeenkomst uit.
Pak alle overeenkomsten uit.
Vervang een overeenkomende subtekenreeks.
Splits één tekenreeks in een matrix met tekenreeksen.
Deze bewerkingen worden beschreven in de volgende secties.
Overeenkomend met een patroon voor reguliere expressies
De Regex.IsMatch methode retourneert true als de tekenreeks overeenkomt met het patroon of false als deze niet overeenkomt. De IsMatch methode wordt vaak gebruikt om tekenreeksinvoer te valideren. De volgende code zorgt er bijvoorbeeld voor dat een tekenreeks overeenkomt met een geldig burgerservicenummer in de Verenigde Staten.
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
Het patroon voor reguliere expressies ^\d{3}-\d{2}-\d{4}$ wordt geïnterpreteerd zoals wordt weergegeven in de volgende tabel.
| Patroon | Beschrijving |
|---|---|
^ |
Komt overeen met het begin van de invoertekenreeks. |
\d{3} |
Kom overeen met drie decimalen. |
- |
Koppel een afbreekstreepje. |
\d{2} |
Kom overeen met twee decimalen. |
- |
Koppel een afbreekstreepje. |
\d{4} |
Kom overeen met vier decimalen. |
$ |
Komt overeen met het einde van de invoertekenreeks. |
Eén overeenkomst of de eerste overeenkomst extraheren
De Regex.Match methode retourneert een Match object dat informatie bevat over de eerste subtekenreeks die overeenkomt met een normaal expressiepatroon. Als de Match.Success eigenschap retourneert true, waarmee wordt aangegeven dat er een overeenkomst is gevonden, kunt u informatie over volgende overeenkomsten ophalen door de methode aan te Match.NextMatch roepen. Deze methode-aanroepen kunnen doorgaan totdat de Match.Success eigenschap wordt geretourneerd false. De volgende code gebruikt bijvoorbeeld de Regex.Match(String, String) methode om het eerste exemplaar van een gedupliceerd woord in een tekenreeks te vinden. Vervolgens wordt de Match.NextMatch methode aangeroepen om extra exemplaren te vinden. In het voorbeeld wordt de Match.Success eigenschap na elke methodeaanroep onderzocht om te bepalen of de huidige overeenkomst is geslaagd en of een aanroep naar de Match.NextMatch methode moet worden gevolgd.
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.
Het patroon voor reguliere expressies \b(\w+)\W+(\1)\b wordt geïnterpreteerd zoals wordt weergegeven in de volgende tabel.
| Patroon | Beschrijving |
|---|---|
\b |
Begin de overeenkomst op een woordgrens. |
(\w+) |
Komt overeen met een of meer woordtekens. Dit is de eerste opnamegroep. |
\W+ |
Komt overeen met een of meer niet-woordtekens. |
(\1) |
Komt overeen met de eerste vastgelegde tekenreeks. Dit is de tweede vastleggende groep. |
\b |
Beëindig de overeenkomst op een woordgrens. |
Alle overeenkomsten extraheren
De Regex.Matches methode retourneert een MatchCollection object dat informatie bevat over alle overeenkomsten die de reguliere expressie-engine in de invoertekenreeks heeft gevonden. Het vorige voorbeeld kan bijvoorbeeld opnieuw worden geschreven om de Matches methode aan te roepen in plaats van de Match en NextMatch methoden.
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.
Een overeenkomende subtekenreeks vervangen
De Regex.Replace methode vervangt elke subtekenreeks die overeenkomt met het reguliere expressiepatroon met een opgegeven tekenreeks of een normaal expressiepatroon en retourneert de volledige invoertekenreeks door vervangingen. Met de volgende code wordt bijvoorbeeld een valutasymbool in de Vs voor een decimaal getal in een tekenreeks toegevoegd.
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
Het patroon voor reguliere expressies \b\d+\.\d{2}\b wordt geïnterpreteerd zoals wordt weergegeven in de volgende tabel.
| Patroon | Beschrijving |
|---|---|
\b |
Begin de overeenkomst bij een woordgrens. |
\d+ |
Kom overeen met een of meer decimale cijfers. |
\. |
Overeenkomst met een punt. |
\d{2} |
Kom overeen met twee decimalen. |
\b |
Beëindig de overeenkomst op een woordgrens. |
Het vervangingspatroon $$$& wordt geïnterpreteerd zoals wordt weergegeven in de volgende tabel.
| Patroon | Vervangende tekenreeks |
|---|---|
$$ |
Het dollarteken ($). |
$& |
De volledige overeenkomende subtekenreeks. |
Een enkele tekenreeks splitsen in een matrix met tekenreeksen
De Regex.Split methode splitst de invoertekenreeks op de posities die zijn gedefinieerd door een reguliere expressieovereenkomst. Met de volgende code worden de items in een genummerde lijst bijvoorbeeld in een tekenreeksmatrix geplaatst.
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
Het patroon voor reguliere expressies \b\d{1,2}\.\s wordt geïnterpreteerd zoals wordt weergegeven in de volgende tabel.
| Patroon | Beschrijving |
|---|---|
\b |
Begin de overeenkomst bij een woordgrens. |
\d{1,2} |
Kom overeen met een of twee decimale cijfers. |
\. |
Overeenkomst met een punt. |
\s |
Overeenkomst met een spatieteken. |
De objecten MatchCollection en Match
Regex-methoden retourneren twee objecten die deel uitmaken van het reguliere expressieobjectmodel: het MatchCollection object en het Match object.
De overeenkomstverzameling
De Regex.Matches methode retourneert een MatchCollection object dat objecten bevat Match die alle overeenkomsten vertegenwoordigen die door de engine voor reguliere expressies zijn gevonden, in de volgorde waarin ze voorkomen in de invoertekenreeks. Als er geen overeenkomsten zijn, retourneert de methode een MatchCollection object zonder leden. Met MatchCollection.Item[] de eigenschap kunt u afzonderlijke leden van de verzameling per index openen, van nul tot één kleiner dan de waarde van de MatchCollection.Count eigenschap. Item[] is de indexeerfunctie van de verzameling (in C#) en de standaardeigenschap (in Visual Basic).
De aanroep van de Regex.Matches methode maakt standaard gebruik van luie evaluatie om het MatchCollection object te vullen. Toegang tot eigenschappen waarvoor een volledig gevulde verzameling, zoals de MatchCollection.Count en MatchCollection.Item[] eigenschappen, nodig is, kan een prestatiestraf zijn. Als gevolg hiervan raden we u aan om toegang te krijgen tot de verzameling met behulp van het IEnumerator object dat wordt geretourneerd door de MatchCollection.GetEnumerator methode. Afzonderlijke talen bieden constructies, zoals For Each in Visual Basic en foreach in C#, die de interface van IEnumerator de verzameling verpakken.
In het volgende voorbeeld wordt de Regex.Matches(String) methode gebruikt om een MatchCollection object te vullen met alle overeenkomsten in een invoertekenreeks. Het voorbeeld bevat een opsomming van de verzameling, kopieert de overeenkomsten naar een tekenreeksmatrix en registreert de tekenposities in een matrix met gehele getallen.
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.
De overeenkomst
De Match klasse vertegenwoordigt het resultaat van één reguliere expressieovereenkomst. U kunt objecten op twee manieren openen Match :
Door ze op te halen uit het MatchCollection object dat door de Regex.Matches methode wordt geretourneerd. Als u afzonderlijke Match objecten wilt ophalen, kunt u de verzameling herhalen met behulp van een
foreachconstructie (in C#) ofFor Each...Next(in Visual Basic) of de MatchCollection.Item[] eigenschap gebruiken om een specifiek Match object op te halen op basis van index of op naam. U kunt ook afzonderlijke Match objecten uit de verzameling ophalen door de verzameling te herhalen op index, van nul tot één minder dan het aantal objecten in de verzameling. Deze methode maakt echter geen gebruik van luie evaluatie, omdat deze toegang heeft tot de MatchCollection.Count eigenschap.In het volgende voorbeeld worden afzonderlijke Match objecten opgehaald uit een MatchCollection object door de verzameling te herhalen met behulp van de
foreachofFor Each...Next-constructie. De reguliere expressie komt gewoon overeen met de tekenreeks 'abc' in de invoertekenreeks.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.Door de Regex.Match methode aan te roepen, die een Match object retourneert dat de eerste overeenkomst in een tekenreeks of een deel van een tekenreeks vertegenwoordigt. U kunt bepalen of de overeenkomst is gevonden door de waarde van de
Match.Successeigenschap op te halen. Als u objecten wilt ophalen Match die de volgende overeenkomsten vertegenwoordigen, roept u de Match.NextMatch methode herhaaldelijk aan totdat deSuccesseigenschap van het geretourneerde Match object isfalse.In het volgende voorbeeld worden de Regex.Match(String, String) en Match.NextMatch methoden gebruikt om de tekenreeks 'abc' in de invoertekenreeks te vinden.
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.
Twee eigenschappen van de Match klasse retourneren verzamelingsobjecten:
De Match.Groups eigenschap retourneert een GroupCollection object dat informatie bevat over de subtekenreeksen die overeenkomen met het vastleggen van groepen in het reguliere expressiepatroon.
De
Match.Captureseigenschap retourneert een CaptureCollection object dat beperkt wordt gebruikt. De verzameling is niet ingevuld voor een Match object waarvanSuccessde eigenschap isfalse. Anders bevat het één Capture object met dezelfde informatie als het Match object.
Zie de secties Groepverzameling en Capture Collection verderop in dit onderwerp voor meer informatie over deze objecten.
Twee extra eigenschappen van de Match klasse bieden informatie over de overeenkomst. De Match.Value eigenschap retourneert de subtekenreeks in de invoertekenreeks die overeenkomt met het reguliere expressiepatroon. De Match.Index eigenschap retourneert de op nul gebaseerde beginpositie van de overeenkomende tekenreeks in de invoertekenreeks.
De Match klasse heeft ook twee methoden voor patroonkoppeling:
De Match.NextMatch methode vindt de overeenkomst na de overeenkomst die wordt vertegenwoordigd door het huidige Match object en retourneert een Match object dat die overeenkomst vertegenwoordigt.
De Match.Result methode voert een opgegeven vervangingsbewerking uit op de overeenkomende tekenreeks en retourneert het resultaat.
In het volgende voorbeeld wordt de Match.Result methode gebruikt om een $-symbool en een spatie voor elk getal met twee breukcijferen voor te stellen.
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
Het reguliere expressiepatroon \b\d+(,\d{3})*\.\d{2}\b wordt gedefinieerd zoals wordt weergegeven in de volgende tabel.
| Patroon | Beschrijving |
|---|---|
\b |
Begin de overeenkomst bij een woordgrens. |
\d+ |
Kom overeen met een of meer decimale cijfers. |
(,\d{3})* |
Kom overeen met nul of meer exemplaren van een komma, gevolgd door drie decimale cijfers. |
\. |
Komt overeen met het decimaalteken. |
\d{2} |
Kom overeen met twee decimalen. |
\b |
Beëindig de overeenkomst op een woordgrens. |
Het vervangende patroon $$ $& geeft aan dat de overeenkomende subtekenreeks moet worden vervangen door een dollarteken ($) (het $$ patroon), een spatie en de waarde van de overeenkomst (het $& patroon).
De groepverzameling
De Match.Groups eigenschap retourneert een GroupCollection object dat objecten bevat Group die vastgelegde groepen in één overeenkomst vertegenwoordigen. Het eerste Group object in de verzameling (op index 0) vertegenwoordigt de volledige overeenkomst. Elk object dat volgt vertegenwoordigt de resultaten van één vastleggende groep.
U kunt afzonderlijke Group objecten in de verzameling ophalen met behulp van de GroupCollection.Item[] eigenschap. U kunt niet-benoemde groepen ophalen op basis van hun rangtelpositie in de verzameling en benoemde groepen ophalen op naam of rangschikkpositie. Niet-benoemde opnamen worden eerst in de verzameling weergegeven en worden van links naar rechts geïndexeerd in de volgorde waarin ze worden weergegeven in het reguliere expressiepatroon. Benoemde opnamen worden geïndexeerd na niet-benoemde opnamen, van links naar rechts in de volgorde waarin ze worden weergegeven in het reguliere expressiepatroon. Als u wilt bepalen welke genummerde groepen beschikbaar zijn in de verzameling die wordt geretourneerd voor een bepaalde reguliere expressiekoppelingsmethode, kunt u de instantiemethode Regex.GetGroupNumbers aanroepen. Als u wilt bepalen welke benoemde groepen beschikbaar zijn in de verzameling, kunt u de instantiemethode Regex.GetGroupNames aanroepen. Beide methoden zijn met name nuttig in routines voor algemeen gebruik die de overeenkomsten analyseren die zijn gevonden door een reguliere expressie.
De GroupCollection.Item[] eigenschap is de indexeerfunctie van de verzameling in C# en de standaardeigenschap van het verzamelingsobject in Visual Basic. Dit betekent dat afzonderlijke Group objecten als volgt toegankelijk zijn via index (of op naam, in het geval van benoemde groepen):
Group group = match.Groups[ctr];
Dim group As Group = match.Groups(ctr)
In het volgende voorbeeld wordt een reguliere expressie gedefinieerd die gebruikmaakt van groeperingsconstructies om de maand, dag en het jaar van een datum vast te leggen.
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
Het reguliere expressiepatroon \b(\w+)\s(\d{1,2}),\s(\d{4})\b wordt gedefinieerd zoals wordt weergegeven in de volgende tabel.
| Patroon | Beschrijving |
|---|---|
\b |
Begin de overeenkomst bij een woordgrens. |
(\w+) |
Komt overeen met een of meer woordtekens. Dit is de eerste opnamegroep. |
\s |
Overeenkomst met een spatieteken. |
(\d{1,2}) |
Kom overeen met een of twee decimale cijfers. Dit is de tweede vastleggende groep. |
, |
Komma's overeen. |
\s |
Overeenkomst met een spatieteken. |
(\d{4}) |
Kom overeen met vier decimalen. Dit is de derde groep die vastlegt. |
\b |
Beëindig de overeenkomst op een woordgrens. |
De vastgelegde groep
De Group klasse vertegenwoordigt het resultaat van één vastleggende groep. Groepsobjecten die de vastleggende groepen vertegenwoordigen die zijn gedefinieerd in een reguliere expressie, worden geretourneerd door de Item[] eigenschap van het GroupCollection object dat door de Match.Groups eigenschap wordt geretourneerd. De Item[] eigenschap is de indexeerfunctie (in C#) en de standaardeigenschap (in Visual Basic) van de Group klasse. U kunt ook afzonderlijke leden ophalen door de verzameling te herhalen met behulp van de foreach of For Each constructie. Zie de vorige sectie voor een voorbeeld.
In het volgende voorbeeld worden geneste groeperingsconstructies gebruikt om subtekenreeksen vast te leggen in groepen. Het reguliere expressiepatroon (a(b))c komt overeen met de tekenreeks 'abc'. De subtekenreeks 'ab' wordt toegewezen aan de eerste groep voor vastleggen en de subtekenreeks 'b' aan de tweede groep voor vastleggen.
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
In het volgende voorbeeld wordt benoemde groeperingsconstructies gebruikt om subtekenreeksen vast te leggen van een tekenreeks die gegevens bevat in de indeling 'DATANAME:VALUE', die de reguliere expressie splitst op de dubbele punt (:)).
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
Het reguliere expressiepatroon ^(?<name>\w+):(?<value>\w+) wordt gedefinieerd zoals wordt weergegeven in de volgende tabel.
| Patroon | Beschrijving |
|---|---|
^ |
Begin de overeenkomst aan het begin van de invoertekenreeks. |
(?<name>\w+) |
Komt overeen met een of meer woordtekens. De naam van deze vastleggende groep is name. |
: |
Komt overeen met een dubbele punt. |
(?<value>\w+) |
Komt overeen met een of meer woordtekens. De naam van deze vastleggende groep is value. |
De eigenschappen van de Group klasse bevatten informatie over de vastgelegde groep: De Group.Value eigenschap bevat de vastgelegde subtekenreeks, de Group.Index eigenschap geeft de beginpositie van de vastgelegde groep aan in de invoertekst, de Group.Length eigenschap bevat de lengte van de vastgelegde tekst en de Group.Success eigenschap geeft aan of een subtekenreeks overeenkomt met het patroon dat is gedefinieerd door de vastleggende groep.
Door kwantificatoren toe te passen op een groep (zie Kwantifiers) wijzigt u de relatie van één opname per vastleggende groep op twee manieren:
Als de
*of*?kwantificeerder (waarmee nul of meer overeenkomsten worden opgegeven) wordt toegepast op een groep, heeft een vastleggende groep mogelijk geen overeenkomst in de invoertekenreeks. Wanneer er geen vastgelegde tekst is, worden de eigenschappen van het Group object ingesteld zoals wordt weergegeven in de volgende tabel.Groepseigenschap Weergegeven als SuccessfalseValueString.Empty Length0 In het volgende voorbeeld ziet u een afbeelding. In het reguliere expressiepatroon
aaa(bbb)*ccckan de eerste opnamegroep (de subtekenreeks 'bbb') worden vergeleken met nul of meer keren. Omdat de invoertekenreeks 'aaaccc' overeenkomt met het patroon, heeft de vastleggende groep geen overeenkomst.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.Kwantificators kunnen overeenkomen met meerdere exemplaren van een patroon dat wordt gedefinieerd door een vastleggende groep. In dit geval bevatten de
ValueenLengtheigenschappen van een Group object alleen informatie over de laatste vastgelegde subtekenreeks. De volgende reguliere expressie komt bijvoorbeeld overeen met één zin die eindigt in een punt. Het maakt gebruik van twee groeperingsconstructies: de eerste legt afzonderlijke woorden samen met een witruimteteken vast; de tweede legt afzonderlijke woorden vast. Zoals in de uitvoer van het voorbeeld wordt weergegeven, hoewel de reguliere expressie erin slaagt een hele zin vast te leggen, wordt alleen het laatste woord vastgelegd door de tweede groep voor vastleggen.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
De Capture-verzameling
Het Group object bevat alleen informatie over de laatste opname. De volledige set opnamen die worden gemaakt door een groep vastleggen, is echter nog steeds beschikbaar vanuit het CaptureCollection object dat door de Group.Captures eigenschap wordt geretourneerd. Elk lid van de verzameling is een Capture object dat een opname vertegenwoordigt die is gemaakt door die groep, in de volgorde waarin ze zijn vastgelegd (en dus in de volgorde waarin de vastgelegde tekenreeksen van links naar rechts in de invoertekenreeks overeenkomen). U kunt afzonderlijke Capture objecten op twee manieren ophalen uit de verzameling:
Door de verzameling te doorlopen met behulp van een constructie zoals
foreach(in C#) ofFor Each(in Visual Basic).Door de CaptureCollection.Item[] eigenschap te gebruiken om een specifiek object op te halen op basis van index. De Item[] eigenschap is de standaardeigenschap van het CaptureCollection object (in Visual Basic) of de indexeerfunctie (in C#).
Als een kwantificator niet wordt toegepast op een vastleggende groep, bevat het CaptureCollection object één Capture object dat weinig interesse heeft, omdat het informatie biedt over dezelfde overeenkomst als het Group object. Als een kwantificator wordt toegepast op een vastleggende groep, bevat het CaptureCollection object alle opnamen die zijn gemaakt door de groep vastleggen en het laatste lid van de verzameling vertegenwoordigt dezelfde opname als het Group object.
Als u bijvoorbeeld het reguliere expressiepatroon ((a(b))c)+ (waarbij de +kwantifier een of meer overeenkomsten opgeeft) gebruikt om overeenkomsten van de tekenreeks 'abcabcabc' vast te leggen, bevat het CaptureCollection object voor elk Group object drie leden.
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
In het volgende voorbeeld wordt de reguliere expressie (Abc)+ gebruikt om een of meer opeenvolgende uitvoeringen van de tekenreeks 'Abc' te vinden in de tekenreeks 'XYZAbcAbcAbcXYZAbcAb'. Het voorbeeld illustreert het gebruik van de Group.Captures eigenschap om meerdere groepen vastgelegde subtekenreeksen te retourneren.
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
De afzonderlijke opname
De Capture klasse bevat de resultaten van één subexpressieopname. De Capture.Value eigenschap bevat de overeenkomende tekst en de Capture.Index eigenschap geeft de positie op basis van nul aan in de invoertekenreeks waarop de overeenkomende subtekenreeks begint.
In het volgende voorbeeld wordt een invoertekenreeks geparseerd voor de temperatuur van geselecteerde steden. Een komma (",") wordt gebruikt om een stad en de temperatuur ervan te scheiden en er wordt een puntkomma (";") gebruikt om de gegevens van elke stad te scheiden. De volledige invoertekenreeks vertegenwoordigt één overeenkomst. In het reguliere expressiepatroon ((\w+(\s\w+)*),(\d+);)+, dat wordt gebruikt om de tekenreeks te parseren, wordt de plaatsnaam toegewezen aan de tweede vastleggende groep en wordt de temperatuur toegewezen aan de vierde vastleggende groep.
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
De reguliere expressie wordt gedefinieerd zoals wordt weergegeven in de volgende tabel.
| Patroon | Beschrijving |
|---|---|
\w+ |
Komt overeen met een of meer woordtekens. |
(\s\w+)* |
Kom overeen met nul of meer exemplaren van een spatieteken, gevolgd door een of meer woordtekens. Dit patroon komt overeen met plaatsnamen met meerdere woorden. Dit is de derde groep die vastlegt. |
(\w+(\s\w+)*) |
Komt overeen met een of meer woordtekens gevolgd door nul of meer exemplaren van een spatieteken en een of meer woordtekens. Dit is de tweede vastleggende groep. |
, |
Komma's overeen. |
(\d+) |
Komt overeen met een of meer cijfers. Dit is de vierde opnamegroep. |
; |
Kom overeen met een puntkomma. |
((\w+(\s\w+)*),(\d+);)+ |
Komt overeen met het patroon van een woord gevolgd door eventuele extra woorden, gevolgd door een komma, een of meer cijfers en een puntkomma, een of meer keren. Dit is de eerste opnamegroep. |
Zie ook
Feedback
Binnenkort beschikbaar: In de loop van 2024 zullen we GitHub-problemen geleidelijk uitfaseren als het feedbackmechanisme voor inhoud en deze vervangen door een nieuw feedbacksysteem. Zie voor meer informatie: https://aka.ms/ContentUserFeedback.
Feedback verzenden en weergeven voor