Het objectmodel van de reguliere expressie

Artikel
06/20/2024

In dit artikel wordt het objectmodel beschreven dat wordt gebruikt voor het werken met reguliere .NET-expressies.

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, dat wil gezegd 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.

Overeenkomen 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 `MatchCollection` en `Match` objecten

Regex-methoden retourneren twee objecten die deel uitmaken van het reguliere expressieobjectmodel: het MatchCollection object en het Match object.

De `MatchCollection` klasse

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 `Match` klasse

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 foreach constructie (in C#) of For 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 foreach of For 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.Success eigenschap op te halen. Als u objecten wilt ophalen Match die de volgende overeenkomsten vertegenwoordigen, roept u de Match.NextMatch methode herhaaldelijk aan totdat de Success eigenschap van het geretourneerde Match object is false.

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.Captures eigenschap retourneert een CaptureCollection object dat beperkt wordt gebruikt. De verzameling is niet ingevuld voor een Match object waarvan Success de eigenschap is false. Anders bevat het één Capture object met dezelfde informatie als het Match object.

Zie De GroupCollection klasse- en klassesecties CaptureCollection verderop in dit artikel 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 `GroupCollection` klasse

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
`Success`	`false`
`Value`	String.Empty
`Length`	0

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 Value en Length eigenschappen 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: sentence

Imports 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 `CaptureCollection` klasse

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#) of For 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 `Capture` klasse

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.

Delen via

Het objectmodel van de reguliere expressie

De engine voor reguliere expressies

Overeenkomen met een patroon voor reguliere expressies

Eén overeenkomst of de eerste overeenkomst extraheren

Alle overeenkomsten extraheren

Een overeenkomende subtekenreeks vervangen

Een enkele tekenreeks splitsen in een matrix met tekenreeksen

De `MatchCollection` en `Match` objecten

De `MatchCollection` klasse

De `Match` klasse

De `GroupCollection` klasse

De vastgelegde groep

De `CaptureCollection` klasse

De `Capture` klasse

Zie ook

Aanvullende resources

Delen via

Het objectmodel van de reguliere expressie

De engine voor reguliere expressies

Overeenkomen met een patroon voor reguliere expressies

Eén overeenkomst of de eerste overeenkomst extraheren

Alle overeenkomsten extraheren

Een overeenkomende subtekenreeks vervangen

Een enkele tekenreeks splitsen in een matrix met tekenreeksen

De MatchCollection en Match objecten

De MatchCollection klasse

De Match klasse

De GroupCollection klasse

De vastgelegde groep

De CaptureCollection klasse

De Capture klasse

Zie ook

Aanvullende resources

De `MatchCollection` en `Match` objecten

De `MatchCollection` klasse

De `Match` klasse

De `GroupCollection` klasse

De `CaptureCollection` klasse

De `Capture` klasse