Modello a oggetti delle espressioni regolari

Articolo
08/11/2011

In questo argomento viene descritto il modello a oggetti utilizzato con le espressioni regolari di .NET Framework. Include le sezioni seguenti:

Motore delle espressioni regolari
Oggetti MatchCollection e Match
Insieme di gruppi
Gruppo acquisito
Insieme di acquisizioni
Acquisizione singola

Motore delle espressioni regolari

Il motore delle espressioni regolari in .NET Framework è rappresentato dalla classe Regex. Tale motore è responsabile dell'analisi e della compilazione di un'espressione regolare, nonché dell'esecuzione di operazioni che trovano corrispondenze tra il modello di espressione regolare e una stringa di input. Il motore è il componente centrale nel modello a oggetti delle espressioni regolari di .NET Framework.

Il motore delle espressioni regolari può essere utilizzato in due modi:

Chiamando i metodi statici della classe Regex. I parametri dei metodi includono la stringa di input e il modello di espressione regolare. Il motore delle espressioni regolari memorizza nella cache le espressioni utilizzate nelle chiamate ai metodi statici; di conseguenza, ripetute chiamate a metodi statici che utilizzano la stessa espressione regolare offrono prestazioni relativamente buone.
Creando un'istanza di un oggetto Regex mediante il passaggio di un'espressione regolare al costruttore di classe. In questo caso, l'oggetto Regex non è modificabile (sola lettura) e rappresenta un motore delle espressioni regolari strettamente associato a un'unica espressione regolare. Poiché le espressioni regolari utilizzate dalle istanze di Regex non vengono memorizzate nella cache, si consiglia di non creare più volte un'istanza di un oggetto Regex con la stessa espressione regolare.

È possibile chiamare i metodi della classe Regex per eseguire le seguenti operazioni:

Stabilire se una stringa corrisponde a un modello di espressione regolare.
Estrarre un'unica corrispondenza o la prima corrispondenza.
Estrarre tutte le corrispondenze.
Sostituire una sottostringa corrispondente.
Suddividere una singola stringa in una matrice di stringhe.

Queste operazioni vengono descritte nelle sezioni che seguono.

Corrispondenza con un modello di espressione regolare

Il metodo Regex.IsMatch restituisce true se la stringa corrisponde al modello, in caso contrario false. Il metodo IsMatch viene spesso utilizzato per convalidare l'input della stringa. Il codice seguente assicura ad esempio che una stringa corrisponda a un numero di previdenza sociale valido negli Stati Uniti.

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

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

Il modello di espressione regolare ^\d{3}-\d{2}-\d{4}$ viene interpretato come illustrato nella tabella seguente.

Modello	Descrizione
^	Corrisponde all'inizio della stringa di input.
\d{3}	Corrisponde a tre cifre decimali.
-	Corrisponde a un trattino.
\d{2}	Corrisponde a due cifre decimali.
-	Corrisponde a un trattino.
\d{4}	Corrisponde a quattro cifre decimali.
$	Corrisponde alla fine della stringa di input.

Estrazione di un'unica corrispondenza o della prima corrispondenza

Il metodo Regex.Match restituisce un oggetto Match che contiene informazioni sulla prima sottostringa corrispondente a un modello di espressione regolare. Se la proprietà Match.Success restituisce true, a indicare che è stata trovata una corrispondenza, è possibile recuperare le informazioni sulle corrispondenze successive chiamando il metodo Match.NextMatch. Queste chiamate al metodo possono continuare fino a che la proprietà Match.Success non restituisce false. Nel seguente codice viene ad esempio utilizzato il metodo Regex.Match(String, String) per individuare la prima occorrenza di una parola duplicata in una stringa. Viene quindi chiamato il metodo Match.NextMatch per trovare ulteriori occorrenze. Nell'esempio, la proprietà Match.Success viene esaminata dopo ogni chiamata al metodo per stabilire se la corrispondenza corrente abbia avuto esito positivo e se debba seguire una chiamata al metodo Match.NextMatch.

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.

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.

Il modello di espressione regolare \b(\w+)\W+(\1)\b viene interpretato come illustrato nella tabella seguente.

Modello	Descrizione
\b	Inizia la corrispondenza sul confine di parola.
(\w+)	Trova la corrispondenza di uno o più caratteri alfanumerici. Equivale al primo gruppo di acquisizione.
\W+	Corrisponde a uno o più caratteri non alfanumerici.
(\1)	Corrisponde alla prima stringa acquisita. Equivale al secondo gruppo di acquisizione.
\b	Termina la corrispondenza sul confine di parola.

Estrazione di tutte le corrispondenze

Il metodo Regex.Matches restituisce un oggetto MatchCollection che contiene informazioni su tutte le corrispondenze trovate dal motore delle espressioni regolari nella stringa di input. Ad esempio, è possibile riscrivere l'esempio precedente in modo da chiamare il metodo Matches anziché i metodi Match e NextMatch.

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.

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.

Sostituzione di una sottostringa corrispondente

Il metodo Regex.Replace sostituisce ogni sottostringa corrispondente al modello di espressione regolare con una stringa o un modello di espressione regolare specificati, restituendo l'intera stringa di input con le relative sostituzioni. Nel codice seguente viene ad esempio aggiunto un simbolo di valuta degli Stati Uniti prima di un numero decimale in una stringa.

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

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

Il modello di espressione regolare \b\d+\.\d{2}\b viene interpretato come illustrato nella tabella seguente.

Modello	Descrizione
\b	Inizia la corrispondenza sul confine di parola.
\d+	Corrisponde a una o più cifre decimali.
\.	Corrisponde a un punto.
\d{2}	Corrisponde a due cifre decimali.
\b	Termina la corrispondenza sul confine di parola.

Il modello sostitutivo $$$& viene interpretato come illustrato nella tabella seguente.

Modello	Stringa di sostituzione
$$	Simbolo del dollaro ($).
$&	Intera sottostringa corrispondente.

Suddivisione di una singola stringa in una matrice di stringhe

Il metodo Regex.Split suddivide la stringa di input in corrispondenza delle posizioni definite da una corrispondenza di espressione regolare. Nel codice seguente, ad esempio, gli elementi di un elenco numerato vengono inseriti in una matrice di stringhe.

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

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

Il modello di espressione regolare \b\d{1,2}\.\s viene interpretato come illustrato nella tabella seguente.

Modello	Descrizione
\b	Inizia la corrispondenza sul confine di parola.
\d{1,2}	Corrisponde a una o due cifre decimali.
\.	Corrisponde a un punto.
\s	Trova la corrispondenza di uno spazio vuoto.

Oggetti MatchCollection e Match

I metodi regex restituiscono due oggetti appartenenti al modello a oggetti delle espressioni regolari: MatchCollection e Match.

Insieme di corrispondenze

Il metodo Regex.Matches restituisce un oggetto MatchCollection contenente oggetti Match che rappresentano tutte le corrispondenze trovate dal motore delle espressioni regolari, nell'ordine in cui si verificano nella stringa di input. In assenza di corrispondenze, il metodo restituisce un oggetto MatchCollection privo di membri. La proprietà MatchCollection.Item consente di accedere a singoli membri dell'insieme in base all'indice, da zero fino al numero inferiore di uno rispetto al valore della proprietà MatchCollection.Count. Item è l'indicizzatore dell'insieme (in C#) e la proprietà predefinita (in Visual Basic).

Per impostazione predefinita, la chiamata al metodo Regex.Matches utilizza la valutazione differita per popolare l'oggetto MatchCollection. L'accesso a proprietà che richiedono un insieme completamente popolato, ad esempio MatchCollection.Count e MatchCollection.Item, può comportare una riduzione delle prestazioni. Di conseguenza, si consiglia di accedere all'insieme tramite l'oggetto IEnumerator restituito dal metodo MatchCollection.GetEnumerator. I singoli linguaggi forniscono costrutti, ad esempio For Each in Visual Basic e foreach in C#, che eseguono il wrapping dell'interfaccia IEnumerator dell'insieme.

Nell'esempio che segue viene utilizzato il metodo Regex.Matches(String) per popolare un oggetto MatchCollection con tutte le corrispondenze trovate in una stringa di input. Nell'esempio l'insieme viene enumerato, le corrispondenze vengono copiate in una matrice di stringhe e le posizioni dei caratteri vengono registrate in una matrice di interi.

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.

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.

Corrispondenza

La classe Match rappresenta il risultato di una singola corrispondenza di espressione regolare. Esistono due modi per accedere agli oggetti Match:

Recuperandoli dall'oggetto MatchCollection restituito dal metodo Regex.Matches. Per recuperare singoli oggetti Match, scorrere l'insieme utilizzando un costrutto foreach (in C#) o For Each...Next (in Visual Basic) oppure utilizzare la proprietà MatchCollection.Item per recuperare un oggetto Match specifico in base all'indice o al nome. È inoltre possibile recuperare singoli oggetti Match dall'insieme scorrendolo in base all'indice, da zero fino al numero inferiore di uno rispetto al numero di oggetti nell'insieme. Tuttavia, questo metodo non sfrutta la valutazione differita in quanto accede alla proprietà MatchCollection.Count.

Nell'esempio seguente, singoli oggetti Match vengono recuperati da un oggetto MatchCollection scorrendo l'insieme mediante il costrutto foreach o For Each...Next. L'espressione regolare corrisponde semplicemente alla stringa "abc" nella stringa di input.

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.

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.

Chiamando il metodo Regex.Match, il quale restituisce un oggetto Match che rappresenta la prima corrispondenza in una stringa o porzione di stringa. È possibile stabilire se la corrispondenza sia stata trovata recuperando il valore della proprietà Match.Success. Per recuperare gli oggetti Match che rappresentano le corrispondenze successive, chiamare ripetutamente il metodo Match.NextMatch fino a che la proprietà Success dell'oggetto Match restituito non è false.

Nell'esempio seguente vengono utilizzati i metodi Regex.Match(String, String) e Match.NextMatch per trovare la corrispondenza della stringa "abc" nella stringa di input.

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.

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.

Due proprietà della classe Match restituiscono oggetti di insieme:

La proprietà Match.Groups restituisce un oggetto GroupCollection che contiene informazioni sulle sottostringhe corrispondenti ai gruppi di acquisizione nel modello di espressione regolare.
La proprietà Group.Captures restituisce un oggetto CaptureCollection il cui uso è limitato. L'insieme non viene popolato per un oggetto Match la cui proprietà Success è false. In caso contrario, contiene un unico oggetto Capture con le stesse informazioni dell'oggetto Match.

Per ulteriori informazioni su questi oggetti, vedere le sezioni Insieme di gruppi e Insieme di acquisizioni più avanti in questo argomento.

Altre due proprietà della classe Match forniscono informazioni sulla corrispondenza. La proprietà Match.Value restituisce la sottostringa nella stringa di input che corrisponde al modello di espressione regolare. La proprietà Match.Index restituisce la posizione iniziale in base zero della stringa corrispondente nella stringa di input.

La classe Match dispone inoltre di due metodi di corrispondenza dei modelli:

Il metodo Match.NextMatch trova la corrispondenza successiva alla corrispondenza rappresentata dall'oggetto Match corrente e restituisce un oggetto Match che rappresenta tale corrispondenza.
Il metodo Match.Result esegue un'operazione di sostituzione specificata nella stringa corrispondente e restituisce il risultato.

Nell'esempio seguente viene utilizzato il metodo Match.Result per anteporre un simbolo $ e uno spazio a ogni numero che include due cifre frazionarie.

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

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

Il modello di espressione regolare \b\d+(,\d{3})*\.\d{2}\b viene definito come illustrato nella tabella seguente.

Modello	Descrizione
\b	Inizia la corrispondenza sul confine di parola.
\d+	Corrisponde a una o più cifre decimali.
(,\d{3})*	Corrisponde a zero o più occorrenze di una virgola seguita da tre cifre decimali.
\.	Corrisponde al separatore decimale.
\d{2}	Corrisponde a due cifre decimali.
\b	Termina la corrispondenza sul confine di parola.

Il modello sostitutivo $$ $& indica che la sottostringa corrispondente deve essere sostituita da un simbolo del dollaro $ (modello $$), uno spazio e il valore della corrispondenza (modello $&).

Torna all'inizio

Insieme di gruppi

La proprietà Match.Groups restituisce un oggetto GroupCollection contenente oggetti Group che rappresentano i gruppi acquisiti in una singola corrispondenza. Il primo oggetto Group nell'insieme (in corrispondenza dell'indice 0) rappresenta l'intera corrispondenza. Ciascun oggetto che segue rappresenta i risultati di un singolo gruppo di acquisizione.

È possibile recuperare singoli oggetti Group nell'insieme utilizzando la proprietà GroupCollection.Item. I gruppi senza nome possono essere recuperati in base alla rispettiva posizione ordinale nell'insieme, mentre i gruppi denominati possono essere recuperati in base al nome o alla posizione ordinale. Le acquisizioni senza nome vengono visualizzate per prime nell'insieme e vengono indicizzate da sinistra a destra nell'ordine in cui appaiono nel modello di espressione regolare. Le acquisizioni denominate vengono indicizzate dopo le acquisizioni senza nome, da sinistra a destra nell'ordine in cui appaiono nel modello di espressione regolare.

La proprietà GroupCollection.Item è l'indicizzatore dell'insieme in C# e la proprietà predefinita dell'oggetto insieme in Visual Basic. Ciò significa che è possibile accedere a singoli oggetti Group in base all'indice (o in base al nome, nel caso dei gruppi denominati) come segue:

Dim group As Group = match.Groups(ctr)

Group group = match.Groups[ctr];

Nell'esempio seguente viene definita un'espressione regolare che utilizza costrutti di raggruppamento per acquisire il mese, il giorno e l'anno di una data.

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

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

Il modello di espressione regolare \b(\w+)\s(\d{1,2}),\s(\d{4})\b viene definito come illustrato nella tabella seguente.

Modello	Descrizione
\b	Inizia la corrispondenza sul confine di parola.
(\w+)	Corrisponde a uno o più caratteri alfanumerici. Equivale al primo gruppo di acquisizione.
\s	Corrisponde a uno spazio vuoto.
(\d{1,2})	Corrisponde a una o due cifre decimali. Equivale al secondo gruppo di acquisizione.
,	Corrisponde a una virgola.
\s	Corrisponde a uno spazio vuoto.
(\d{4})	Corrisponde a quattro cifre decimali. Equivale al terzo gruppo di acquisizione.
\b	Termina la corrispondenza sul confine di parola.

Torna all'inizio

Gruppo acquisito

La classe Group rappresenta il risultato di un singolo gruppo di acquisizione. Gli oggetti gruppo che rappresentano i gruppi di acquisizione definiti in un'espressione regolare vengono restituiti dalla proprietà Item dell'oggetto GroupCollection restituito dalla proprietà Match.Groups. La proprietà Item è l'indicizzatore (in C#) e la proprietà predefinita (in Visual Basic) della classe Group. È inoltre possibile recuperare singoli membri scorrendo l'insieme mediante il costrutto foreach o For Each. Per un esempio, vedere la sezione precedente.

Nell'esempio seguente vengono utilizzati costrutti di raggruppamento annidati per acquisire le sottostringhe nei gruppi. Il modello di espressione regolare (a(b))c corrisponde alla stringa "abc". Assegna la sottostringa "ab" al primo gruppo di acquisizione e la sottostringa "b" al secondo gruppo di acquisizione.

 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

List<int> matchposition = new List<int>();
List<string> results = new List<string>();
// Define substrings abc, ab, b.
Regex 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

Nell'esempio seguente vengono utilizzati costrutti di raggruppamento denominati per acquisire sottostringhe da una stringa contenente dati nel formato "DATANAME:VALUE", suddiviso dall'espressione regolare in corrispondenza dei due punti (:).

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

Regex 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

Il modello di espressione regolare ^(?<name>\w+):(?<value>\w+) viene definito come illustrato nella tabella seguente.

Modello	Descrizione
^	Inizia la corrispondenza all'inizio della stringa di input.
(?<name>\w+)	Corrisponde a uno o più caratteri alfanumerici. Il nome di questo gruppo di acquisizione è name.
:	Corrisponde al segno dei due punti.
(?<value>\w+)	Corrisponde a uno o più caratteri alfanumerici. Il nome di questo gruppo di acquisizione è value.

Le proprietà della classe Group forniscono informazioni sul gruppo acquisito: la proprietà Group.Value contiene la sottostringa acquisita, la proprietà Group.Index indica la posizione iniziale del gruppo acquisito nel testo di input, la proprietà Group.Length contiene la lunghezza del testo acquisito e la proprietà Group.Success indica l'eventuale corrispondenza di una sottostringa con il modello definito dal gruppo di acquisizione.

L'applicazione di quantificatori a un gruppo (per ulteriori informazioni, vedere Quantificatori) modifica la relazione di un'acquisizione per gruppo di acquisizione in due modi:

Se il quantificatore * o *? (che specifica zero o più corrispondenze) viene applicato a un gruppo, è possibile che un gruppo di acquisizione non abbia una corrispondenza nella stringa di input. In assenza di un testo acquisito, le proprietà dell'oggetto Group vengono impostate come illustrato nella tabella seguente.

Proprietà del gruppo	Valore
Success	false
Value	String.Empty
Length	0

Nell'esempio seguente viene illustrato questo concetto. Nel modello di espressione regolare aaa(bbb)*ccc, il primo gruppo di acquisizione (sottostringa "bbb") può essere oggetto di corrispondenza zero o più volte. Poiché la stringa di input "aaaccc" corrisponde al modello, il gruppo di acquisizione non presenta corrispondenze.

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.

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.

I quantificatori possono corrispondere a più occorrenze di un modello definito da un gruppo di acquisizione. In questo caso, le proprietà Value e Length di un oggetto Group contengono unicamente informazioni sull'ultima sottostringa acquisita. Ad esempio, l'espressione regolare che segue corrisponde a un'unica frase che termina con un punto. Utilizza due costrutti di raggruppamento: il primo acquisisce singole parole assieme a uno spazio vuoto; il secondo acquisisce singole parole. Come illustra l'output dell'esempio, sebbene l'espressione regolare riesca ad acquisire una frase intera, il secondo gruppo di acquisizione acquisisce solo l'ultima parola.

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

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

Torna all'inizio

Insieme di acquisizioni

L'oggetto Group contiene unicamente le informazioni relative all'ultima acquisizione. Tuttavia, l'intero set di acquisizioni eseguite da un gruppo di acquisizione resta disponibile grazie all'oggetto CaptureCollection restituito dalla proprietà Group.Captures. Ogni membro dell'insieme è un oggetto Capture che rappresenta un'acquisizione eseguita da tale gruppo di acquisizione, nell'ordine in cui è stato acquisito (e quindi nell'ordine in cui sono state trovate corrispondenze per le stringhe acquisite, da sinistra a destra nella stringa di input). Esistono due modi per recuperare singoli oggetti Capture dall'insieme:

Scorrendo l'insieme mediante un costrutto quale foreach (in C#) o For Each (in Visual Basic).
Utilizzando la proprietà CaptureCollection.Item per recuperare un oggetto specifico in base all'indice. La proprietà Item è la proprietà predefinita (in Visual Basic) o l'indicizzatore (in C#) dell'oggetto CaptureCollection.

Se un quantificatore non viene applicato a un gruppo di acquisizione, l'oggetto CaptureCollection conterrà un unico oggetto Capture di poco interesse, in quanto fornisce informazioni sulla stessa corrispondenza dell'oggetto Group. Se un quantificatore viene applicato a un gruppo di acquisizione, l'oggetto CaptureCollection conterrà tutte le acquisizioni eseguite dal gruppo e l'ultimo membro dell'insieme rappresenterà la stessa acquisizione dell'oggetto Group.

Se ad esempio si utilizza il modello di espressione regolare ((a(b))c)+ (dove il quantificatore + specifica una o più corrispondenze) per acquisire le corrispondenze dalla stringa "abcabcabc", l'oggetto CaptureCollection di ogni oggetto Group conterrà tre membri.

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 dosplays 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

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

Nell'esempio seguente viene utilizzata l'espressione regolare (Abc)+ per trovare una o più esecuzioni consecutive della stringa "Abc" nella stringa "XYZAbcAbcAbcXYZAbcAb". Nell'esempio viene illustrato l'utilizzo della proprietà Group.Captures per restituire più gruppi di sottostringhe acquisite.

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

   int counter;
   Match m;
   CaptureCollection cc;
   GroupCollection gc;

   // Look for groupings of "Abc".
   Regex 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

Torna all'inizio

Acquisizione singola

La classe Capture contiene i risultati di una singola acquisizione di sottoespressioni. La proprietà Capture.Value contiene il testo corrispondente, mentre la proprietà Capture.Index indica la posizione in base zero nella stringa di input in corrispondenza della quale inizia la sottostringa corrispondente.

Nell'esempio seguente, una stringa di input viene analizzata per ottenere la temperatura delle città selezionate. Una virgola (",") viene utilizzata per separare una città dalla rispettiva temperatura, mentre un punto e virgola (";") viene utilizzato per separare i dati di ogni città. L'intera stringa di input rappresenta una singola corrispondenza. Nel modello di espressione regolare ((\w+(\s\w+)*),(\d+);)+, utilizzato per analizzare la stringa, il nome della città è assegnato al secondo gruppo di acquisizione, mentre la temperatura è assegnata al quarto gruppo di acquisizione.

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

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

L'espressione regolare viene definita come illustrato nella tabella seguente.

Modello	Descrizione
\w+	Corrisponde a uno o più caratteri alfanumerici.
(\s\w+)*	Corrisponde a zero o più occorrenze di uno spazio vuoto seguito da uno o più caratteri alfanumerici. Questo modello corrisponde a nomi di città formati da più parole. Equivale al terzo gruppo di acquisizione.
(\w+(\s\w+)*)	Corrisponde a uno o più caratteri alfanumerici seguiti da zero o più occorrenze di uno spazio vuoto e uno o più caratteri alfanumerici. Equivale al secondo gruppo di acquisizione.
,	Corrisponde a una virgola.
(\d+)	Corrisponde a una o più cifre. Equivale al quarto gruppo di acquisizione.
;	Corrisponde a un punto e virgola.
((\w+(\s\w+)*),(\d+);)+	Corrisponde al modello di una parola seguita da altre parole seguite da una virgola, una o più cifre e un punto e virgola, una o più volte. Equivale al primo gruppo di acquisizione.

Torna all'inizio

Vedere anche

Riferimenti

System.Text.RegularExpressions

Concetti

Espressioni regolari di .NET Framework

Elementi del linguaggio di espressioni regolari

Condividi tramite

Modello a oggetti delle espressioni regolari

Motore delle espressioni regolari

Corrispondenza con un modello di espressione regolare

Estrazione di un'unica corrispondenza o della prima corrispondenza

Estrazione di tutte le corrispondenze

Sostituzione di una sottostringa corrispondente

Suddivisione di una singola stringa in una matrice di stringhe

Oggetti MatchCollection e Match

Insieme di corrispondenze

Corrispondenza

Insieme di gruppi

Gruppo acquisito

Insieme di acquisizioni

Acquisizione singola

Vedere anche

Riferimenti

Concetti

Risorse aggiuntive