Objektmodell för reguljärt uttryck

I det här avsnittet beskrivs den objektmodell som används för att arbeta med reguljära .NET-uttryck. Den innehåller följande avsnitt:

• Motorn för reguljära uttryck

• MatchCollection- och Match-objekt

• Gruppsamlingen

• Den insamlade gruppen

• Insamlingssamlingen

• Den enskilda avbildningen

Motorn för reguljära uttryck

Motorn för reguljära uttryck i .NET representeras av Regex klassen. Motorn för reguljära uttryck ansvarar för att parsa och kompilera ett reguljärt uttryck och för att utföra åtgärder som matchar mönstret för reguljära uttryck med en indatasträng. Motorn är den centrala komponenten i objektmodellen för .NET-reguljära uttryck.

Du kan använda motorn för reguljära uttryck på något av två sätt:

• Genom att anropa klassens Regex statiska metoder. Metodparametrarna innehåller indatasträngen och mönster för reguljära uttryck. Motorn för reguljära uttryck cachelagrar reguljära uttryck som används i statiska metodanrop, så upprepade anrop till statiska reguljära uttrycksmetoder som använder samma reguljära uttryck ger relativt bra prestanda.

• Genom att instansiera ett Regex objekt genom att skicka ett reguljärt uttryck till klasskonstruktorn. I det här fallet Regex är objektet oföränderligt (skrivskyddat) och representerar en reguljär uttrycksmotor som är nära kopplad till ett enda reguljärt uttryck. Eftersom reguljära uttryck som används av Regex instanser inte cachelagras bör du inte instansiera ett Regex objekt flera gånger med samma reguljära uttryck.

Du kan anropa klassmetoderna Regex för att utföra följande åtgärder:

• Avgör om en sträng matchar ett mönster för reguljära uttryck.

• Extrahera en enskild matchning eller den första matchningen.

• Extrahera alla matchningar.

• Ersätt en matchad delsträng.

• Dela upp en enskild sträng i en matris med strängar.

Dessa åtgärder beskrivs i följande avsnitt.

Matcha ett mönster för reguljära uttryck

Metoden Regex.IsMatch returnerar true om strängen matchar mönstret, eller false om den inte gör det. Metoden IsMatch används ofta för att verifiera strängindata. Följande kod säkerställer till exempel att en sträng matchar ett giltigt personnummer i USA.

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

Mönster för ^\d{3}-\d{2}-\d{4}$ reguljära uttryck tolkas enligt följande tabell.

Mönster	beskrivning
^	Matcha början av indatasträngen.
\d{3}	Matcha tre decimalsiffror.
-	Matcha ett bindestreck.
\d{2}	Matcha två decimalsiffror.
-	Matcha ett bindestreck.
\d{4}	Matcha fyra decimalsiffror.
$	Matcha slutet av indatasträngen.

Extrahera en enskild matchning eller den första matchningen

Metoden Regex.Match returnerar ett Match objekt som innehåller information om den första delsträngen som matchar ett reguljärt uttrycksmönster. Om egenskapen Match.Success returnerar true, som anger att en matchning hittades, kan du hämta information om efterföljande matchningar genom att anropa Match.NextMatch metoden. Dessa metodanrop kan fortsätta tills egenskapen Match.Success returnerar false. Följande kod använder Regex.Match(String, String) till exempel metoden för att hitta den första förekomsten av ett duplicerat ord i en sträng. Den anropar Match.NextMatch sedan metoden för att hitta ytterligare förekomster. Exemplet undersöker Match.Success egenskapen efter varje metodanrop för att avgöra om den aktuella matchningen lyckades och om ett anrop till Match.NextMatch metoden ska följa.

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.

Mönster för \b(\w+)\W+(\1)\b reguljära uttryck tolkas enligt följande tabell.

Mönster	beskrivning
\b	Börja matcha på en ordgräns.
(\w+)	Matcha ett eller flera ordtecken. Det här är den första insamlingsgruppen.
\W+	Matcha ett eller flera tecken som inte är ord.
(\1)	Matcha den första insamlade strängen. Det här är den andra insamlingsgruppen.
\b	Avsluta matchningen på en ordgräns.

Extrahera alla matchningar

Metoden Regex.Matches returnerar ett MatchCollection objekt som innehåller information om alla matchningar som den reguljära uttrycksmotorn hittade i indatasträngen. Det tidigare exemplet kan till exempel skrivas om för att anropa Matches metoden i stället för Match metoderna och NextMatch .

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.

Ersätta en matchad delsträng

Metoden Regex.Replace ersätter varje understräng som matchar mönstret för reguljära uttryck med ett angivet sträng- eller reguljärt uttrycksmönster och returnerar hela indatasträngen med ersättningar. Följande kod lägger till exempel till en amerikansk valutasymbol före ett decimaltal i en sträng.

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

Mönster för \b\d+\.\d{2}\b reguljära uttryck tolkas enligt följande tabell.

Mönster	beskrivning
\b	Starta matchningen vid en ordgräns.
\d+	Matcha en eller flera decimaler.
\.	Matcha en punkt.
\d{2}	Matcha två decimalsiffror.
\b	Avsluta matchningen vid en ordgräns.

Ersättningsmönstret $$$& tolkas enligt följande tabell.

Mönster	Ersättningssträng
$$	Dollartecknet ($).
$&	Hela den matchade delsträngen.

Dela upp en enskild sträng i en matris med strängar

Metoden Regex.Split delar indatasträngen på de positioner som definieras av en reguljär uttrycksmatchning. Följande kod placerar till exempel objekten i en numrerad lista i en strängmatris.

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

Mönster för \b\d{1,2}\.\s reguljära uttryck tolkas enligt följande tabell.

Mönster	beskrivning
\b	Starta matchningen vid en ordgräns.
\d{1,2}	Matcha en eller två decimalsiffror.
\.	Matcha en punkt.
\s	Matcha ett blankstegstecken.

MatchCollection- och Match-objekt

Regex-metoder returnerar två objekt som ingår i objektmodellen för reguljära uttryck: MatchCollection objektet och Match objektet.

Matchningssamlingen

Metoden Regex.Matches returnerar ett MatchCollection objekt som innehåller Match objekt som representerar alla matchningar som den reguljära uttrycksmotorn hittade i den ordning de inträffar i indatasträngen. Om det inte finns några matchningar returnerar metoden ett MatchCollection objekt utan medlemmar. Med MatchCollection.Item[] egenskapen kan du komma åt enskilda medlemmar i samlingen efter index, från noll till en mindre än värdet för MatchCollection.Count egenskapen. Item[] är samlingens indexerare (i C#) och standardegenskapen (i Visual Basic).

Som standard använder anropet Regex.Matches till metoden lat utvärdering för att fylla i MatchCollection objektet. Åtkomst till egenskaper som kräver en helt ifylld samling, till exempel MatchCollection.Count egenskaperna och MatchCollection.Item[] , kan innebära en prestandaavgift. Därför rekommenderar vi att du kommer åt samlingen med hjälp av objektet IEnumerator som returneras av MatchCollection.GetEnumerator metoden. Enskilda språk innehåller konstruktioner, till exempel For Each i Visual Basic och foreach i C#, som omsluter samlingens IEnumerator gränssnitt.

I följande exempel används Regex.Matches(String) metoden för att fylla i ett MatchCollection objekt med alla matchningar som finns i en indatasträng. Exemplet räknar upp samlingen, kopierar matchningarna till en strängmatris och registrerar teckenpositionerna i en heltalsmatris.

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.

Matchningen

Klassen Match representerar resultatet av en enda reguljär uttrycksmatchning. Du kan komma åt Match objekt på två sätt:

• Genom att hämta dem från objektet MatchCollection som returneras av Regex.Matches metoden. Om du vill hämta enskilda Match objekt itererar du samlingen med hjälp av en foreach (i C#) eller For Each...Next (i Visual Basic) konstruktion, eller använder MatchCollection.Item[] egenskapen för att hämta ett specifikt Match objekt antingen efter index eller efter namn. Du kan också hämta enskilda Match objekt från samlingen genom att iterera samlingen efter index, från noll till ett mindre än antalet objekt i samlingen. Den här metoden drar dock inte nytta av lat utvärdering eftersom den MatchCollection.Count har åtkomst till egenskapen.

  I följande exempel hämtas enskilda Match objekt från ett MatchCollection objekt genom att samlingen itereras med hjälp av konstruktionen foreach eller For Each...Next . Det reguljära uttrycket matchar helt enkelt strängen "abc" i indatasträngen.

  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.
  

• Genom att anropa Regex.Match metoden, som returnerar ett Match objekt som representerar den första matchningen i en sträng eller en del av en sträng. Du kan avgöra om matchningen har hittats genom att hämta värdet för Match.Success egenskapen. Om du vill hämta Match objekt som representerar efterföljande matchningar anropar Match.NextMatch du metoden upprepade gånger tills Success egenskapen för det returnerade Match objektet är false.

  I följande exempel används Regex.Match(String, String) metoderna och Match.NextMatch för att matcha strängen "abc" i indatasträngen.

  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.
  

Två egenskaper för klassen returnerar samlingsobjekt Match :

• Egenskapen Match.Groups returnerar ett GroupCollection objekt som innehåller information om de delsträngar som matchar grupper som avbildas i mönstret för reguljära uttryck.

• Egenskapen Match.Captures returnerar ett CaptureCollection objekt som är av begränsad användning. Samlingen fylls inte i för ett Match objekt vars Success egenskap är false. Annars innehåller den ett enda Capture objekt som har samma information som objektet Match .

Mer information om dessa objekt finns i avsnitten Gruppsamling och Insamlingssamling senare i det här avsnittet.

Två ytterligare egenskaper för Match klassen innehåller information om matchningen. Egenskapen Match.Value returnerar delsträngen i indatasträngen som matchar mönstret för reguljära uttryck. Egenskapen Match.Index returnerar den nollbaserade startpositionen för den matchade strängen i indatasträngen.

Klassen Match har också två mönstermatchningsmetoder:

• Metoden Match.NextMatch hittar matchningen efter matchningen som representeras av det aktuella Match objektet och returnerar ett Match objekt som representerar den matchningen.

• Metoden Match.Result utför en angiven ersättningsåtgärd på den matchade strängen och returnerar resultatet.

I följande exempel används Match.Result metoden för att förbereda en $-symbol och ett blanksteg före varje tal som innehåller två bråksiffror.

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

Mönster för \b\d+(,\d{3})*\.\d{2}\b reguljära uttryck definieras enligt följande tabell.

Mönster	beskrivning
\b	Starta matchningen vid en ordgräns.
\d+	Matcha en eller flera decimaler.
(,\d{3})*	Matcha noll eller fler förekomster av ett kommatecken följt av tre decimalsiffror.
\.	Matcha decimaltecknet.
\d{2}	Matcha två decimalsiffror.
\b	Avsluta matchningen vid en ordgräns.

Ersättningsmönstret $$ $& anger att den matchade delsträngen ska ersättas av ett dollartecken ($) ( $$ mönstret), ett blanksteg och värdet för matchningen ( $& mönstret).

Tillbaka till början

Gruppsamlingen

Egenskapen Match.Groups returnerar ett GroupCollection objekt som innehåller Group objekt som representerar insamlade grupper i en enda matchning. Det första Group objektet i samlingen (vid index 0) representerar hela matchningen. Varje objekt som följer representerar resultatet av en enda insamlingsgrupp.

Du kan hämta enskilda Group objekt i samlingen med hjälp av egenskapen GroupCollection.Item[] . Du kan hämta namnlösa grupper efter deras ordningsposition i samlingen och hämta namngivna grupper antingen efter namn eller efter ordningstal. Icke namngivna avbildningar visas först i samlingen och indexeras från vänster till höger i den ordning de visas i mönstret för reguljära uttryck. Namngivna avbildningar indexeras efter namnlösa avbildningar, från vänster till höger i den ordning de visas i mönstret för reguljära uttryck. För att avgöra vilka numrerade grupper som är tillgängliga i samlingen som returneras för en viss matchningsmetod för reguljära uttryck kan du anropa instansmetoden Regex.GetGroupNumbers . För att avgöra vilka namngivna grupper som är tillgängliga i samlingen kan du anropa instansmetoden Regex.GetGroupNames . Båda metoderna är särskilt användbara i allmänna rutiner som analyserar matchningarna som hittas av ett reguljärt uttryck.

Egenskapen GroupCollection.Item[] är indexeraren för samlingen i C# och samlingsobjektets standardegenskap i Visual Basic. Det innebär att enskilda Group objekt kan nås via index (eller efter namn, för namngivna grupper) enligt följande:

Group group = match.Groups[ctr];

Dim group As Group = match.Groups(ctr)

I följande exempel definieras ett reguljärt uttryck som använder grupperingskonstruktioner för att avbilda månad, dag och år för ett datum.

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

Mönster för \b(\w+)\s(\d{1,2}),\s(\d{4})\b reguljära uttryck definieras enligt följande tabell.

Mönster	beskrivning
\b	Starta matchningen vid en ordgräns.
(\w+)	Matcha ett eller flera ordtecken. Det här är den första insamlingsgruppen.
\s	Matcha ett blankstegstecken.
(\d{1,2})	Matcha en eller två decimalsiffror. Det här är den andra insamlingsgruppen.
,	Matcha ett kommatecken.
\s	Matcha ett blankstegstecken.
(\d{4})	Matcha fyra decimalsiffror. Det här är den tredje insamlingsgruppen.
\b	Avsluta matchningen på en ordgräns.

Tillbaka till början

Den insamlade gruppen

Klassen Group representerar resultatet från en enda insamlingsgrupp. Gruppobjekt som representerar de insamlingsgrupper som definierats i ett reguljärt uttryck returneras av Item[] egenskapen för objektet GroupCollection som returneras av Match.Groups egenskapen. Egenskapen Item[] är indexeraren (i C#) och standardegenskapen (i Visual Basic) för Group klassen. Du kan också hämta enskilda medlemmar genom att iterera samlingen med hjälp av eller For Each -konstruktionenforeach. Ett exempel finns i föregående avsnitt.

I följande exempel används kapslade grupperingskonstruktioner för att samla in delsträngar i grupper. Mönster för (a(b))c reguljära uttryck matchar strängen "abc". Den tilldelar delsträngen "ab" till den första insamlingsgruppen och delsträngen "b" till den andra insamlingsgruppen.

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

I följande exempel används namngivna grupperingskonstruktioner för att samla in delsträngar från en sträng som innehåller data i formatet "DATANAME:VALUE", som det reguljära uttrycket delar vid kolonet (:).

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

Mönster för ^(?<name>\w+):(?<value>\w+) reguljära uttryck definieras enligt följande tabell.

Mönster	beskrivning
^	Börja matchningen i början av indatasträngen.
(?<name>\w+)	Matcha ett eller flera ordtecken. Namnet på den här insamlingsgruppen är name.
:	Matcha ett kolon.
(?<value>\w+)	Matcha ett eller flera ordtecken. Namnet på den här insamlingsgruppen är value.

Egenskaperna för Group klassen ger information om den insamlade gruppen: Egenskapen Group.Value innehåller den insamlade delsträngen Group.Index , egenskapen anger startpositionen för den insamlade gruppen i indatatexten Group.Length , egenskapen innehåller längden på den insamlade texten och Group.Success egenskapen anger om en delsträng matchade det mönster som definierats av insamlingsgruppen.

Om du tillämpar kvantifierare på en grupp (mer information finns i Kvantifierare) ändras relationen mellan en avbildning per insamlingsgrupp på två sätt:

• Om kvantifieraren * eller *? (som anger noll eller fler matchningar) tillämpas på en grupp kanske en insamlingsgrupp inte har någon matchning i indatasträngen. När det inte finns någon insamlad text anges objektets Group egenskaper enligt följande tabell.

  Gruppegenskap	Värde
  Success	false
  Value	String.Empty
  Length	0

  I följande exempel visas en bild. I mönster för aaa(bbb)*cccreguljära uttryck kan den första insamlingsgruppen (understrängen "bbb") matchas noll eller fler gånger. Eftersom indatasträngen "aaaccc" matchar mönstret har insamlingsgruppen ingen matchning.

  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.
  

• Kvantifierare kan matcha flera förekomster av ett mönster som definieras av en insamlingsgrupp. I det här fallet Value innehåller egenskaperna och Length för ett Group objekt endast information om den senaste insamlade delsträngen. Följande reguljära uttryck matchar till exempel en enda mening som slutar i en period. Den använder två grupperingskonstruktioner: Den första fångar enskilda ord tillsammans med ett blankstegstecken. den andra fångar enskilda ord. Som utdata från exemplet visar, även om det reguljära uttrycket lyckas samla in en hel mening, fångar den andra samlande gruppen bara det sista ordet.

  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
  

Tillbaka till början

Insamlingssamlingen

Objektet Group innehåller endast information om den senaste avbildningen. Hela uppsättningen av avbildningar som görs av en insamlingsgrupp är dock fortfarande tillgänglig från objektet CaptureCollection som returneras av Group.Captures egenskapen. Varje medlem i samlingen är ett Capture objekt som representerar en avbildning som gjorts av den samlande gruppen, i den ordning de hämtades (och därför i den ordning som de insamlade strängarna matchades från vänster till höger i indatasträngen). Du kan hämta enskilda Capture objekt från samlingen på något av två sätt:

• Genom att iterera genom samlingen med hjälp av en konstruktion som foreach (i C#) eller For Each (i Visual Basic).

• Genom att använda egenskapen CaptureCollection.Item[] för att hämta ett specifikt objekt efter index. Egenskapen Item[] är CaptureCollection objektets standardegenskap (i Visual Basic) eller indexerare (i C#).

Om en kvantifierare inte tillämpas på en insamlingsgrupp CaptureCollection innehåller objektet ett enda Capture objekt som är av föga intresse, eftersom det innehåller information om samma matchning som objektet Group . Om en kvantifierare tillämpas på en insamlingsgrupp CaptureCollection innehåller objektet alla avbildningar som gjorts av insamlingsgruppen, och den sista medlemmen i samlingen representerar samma avbildning som Group objektet.

Om du till exempel använder mönster ((a(b))c)+ för reguljära uttryck (där + kvantifieraren anger en eller flera matchningar) för att samla in matchningar från strängen "abcabcabc" CaptureCollection innehåller objektet för varje Group objekt tre medlemmar.

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

I följande exempel används det reguljära uttrycket (Abc)+ för att hitta en eller flera efterföljande körningar av strängen "Abc" i strängen "XYZAbcAbcAbcXYZAbcAb". Exemplet illustrerar användningen av Group.Captures egenskapen för att returnera flera grupper av insamlade delsträngar.

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  

Tillbaka till början

Den enskilda avbildningen

Klassen Capture innehåller resultatet från en enda underuttrycksinsamling. Egenskapen Capture.Value innehåller den matchade texten och egenskapen Capture.Index anger den nollbaserade positionen i indatasträngen där den matchade delsträngen börjar.

I följande exempel parsas en indatasträng för temperaturen i valda städer. Ett kommatecken (",") används för att separera en stad och dess temperatur, och ett semikolon (";") används för att separera varje stads data. Hela indatasträngen representerar en enda matchning. I det reguljära uttrycksmönstret ((\w+(\s\w+)*),(\d+);)+, som används för att parsa strängen, tilldelas stadsnamnet till den andra insamlingsgruppen och temperaturen tilldelas till den fjärde insamlingsgruppen.

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

Det reguljära uttrycket definieras enligt följande tabell.

Mönster	beskrivning
\w+	Matcha ett eller flera ordtecken.
(\s\w+)*	Matcha noll eller flera förekomster av ett blankstegstecken följt av ett eller flera ordtecken. Det här mönstret matchar ortnamn med flera ord. Det här är den tredje insamlingsgruppen.
(\w+(\s\w+)*)	Matcha ett eller flera ordtecken följt av noll eller fler förekomster av ett blankstegstecken och ett eller flera ordtecken. Det här är den andra insamlingsgruppen.
,	Matcha ett kommatecken.
(\d+)	Matcha en eller flera siffror. Det här är den fjärde insamlingsgruppen.
;	Matcha ett semikolon.
((\w+(\s\w+)*),(\d+);)+	Matcha mönstret för ett ord följt av ytterligare ord följt av ett kommatecken, en eller flera siffror och ett semikolon, en eller flera gånger. Det här är den första insamlingsgruppen.

Se även

• System.Text.RegularExpressions
• Reguljära .NET-uttryck
• Språk för reguljärt uttryck – snabbreferens