Modello a oggetti delle espressioni regolari
In questo argomento viene illustrato il modello a oggetti usato con le espressioni regolari di .NET. Contiene le sezioni seguenti:
Motore delle espressioni regolari
Il motore delle espressioni regolari di .NET è rappresentato dalla classe Regex. Il motore delle espressioni regolari è responsabile dell'analisi e della compilazione di un'espressione regolare e dell'esecuzione di operazioni che associano il criterio di espressione regolare a una stringa di input. Il motore è il componente centrale del modello a oggetti delle espressioni regolari di .NET.
È possibile usare il motore delle espressioni regolari in uno dei due modi seguenti:
Tramite la chiamata di metodi statici della classe Regex. I parametri del metodo includono la stringa di input e il criterio di espressione regolare. Il motore delle espressioni regolari memorizza nella cache le espressioni regolari usate nelle chiamate del metodo statico. Le chiamate ripetute a metodi di espressione regolare che usano la stessa espressione regolare offrono quindi prestazioni relativamente buone.
Tramite la creazione di istanze 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 una singola espressione regolare. Poiché le espressioni regolari usate dalle istanze di Regex non sono memorizzate nella cache, è consigliabile non creare più volte istanze di un oggetto Regex con la stessa espressione regolare.
È possibile chiamare i metodi della classe Regex per eseguire le operazioni seguenti:
Determinare se una stringa corrisponde a un criterio di espressione regolare.
Estrarre una singola corrispondenza o la prima corrispondenza.
Estrarre tutte le corrispondenze.
Sostituire una sottostringa con corrispondenza.
Suddividere una singola stringa in una matrice di stringhe.
Queste operazioni sono descritte nelle sezioni seguenti.
Corrispondenza con un criterio di espressione regolare
Il metodo Regex.IsMatch restituisce true se la stringa corrisponde al modello. In caso contrario, false. Il metodo IsMatch è usato spesso per convalidare l'input di stringa. Ad esempio, il codice seguente assicura che una stringa corrisponda a un numero di previdenza sociale negli Stati Uniti.
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
Il criterio di espressione regolare ^\d{3}-\d{2}-\d{4}$ è interpretato nel modo illustrato nella tabella seguente.
| Modello | Descrizione |
|---|---|
^ |
Trova la corrispondenza con l'inizio della stringa di input. |
\d{3} |
Trova la corrispondenza con tre cifre decimali. |
- |
Trova la corrispondenza con un segno meno. |
\d{2} |
Trova la corrispondenza con due cifre decimali. |
- |
Trova la corrispondenza con un segno meno. |
\d{4} |
Trova la corrispondenza con quattro cifre decimali. |
$ |
Trova la corrispondenza con la fine della stringa di input. |
Estrazione di una singola corrispondenza o della prima corrispondenza
Il metodo Regex.Match restituisce un oggetto Match che include informazioni sulla prima sottostringa corrispondente a un criterio di espressione regolare. Se la proprietà Match.Success restituisce true, indicando che è stata rilevata una corrispondenza, sarà possibile ottenere informazioni sulle corrispondenze successive chiamando il metodo Match.NextMatch. Le chiamate ai metodi possono continuare finché la proprietà Match.Success non restituisce false. Ad esempio, il codice seguente usa il metodo Regex.Match(String, String) per trovare la prima occorrenza di una parola duplicata in una stringa. Chiama quindi i metodi Match.NextMatch per trovare eventuali occorrenze aggiuntive. L'esempio esamina la proprietà Match.Success dopo ogni chiamata al metodo, per determinare se la corrispondenza corrente è riuscita e se deve essere seguita da una chiamata al metodo Match.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";
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.
Il criterio di espressione regolare \b(\w+)\W+(\1)\b è interpretato nel modo 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+ |
Trova la corrispondenza di uno o più caratteri non alfanumerici. |
(\1) |
Trova la corrispondenza con la 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 include informazioni su tutte le corrispondenze rilevate dal motore delle espressioni regolari nella stringa di input. Ad esempio, è possibile riscrivere l'esempio precedente in modo da chiamare il metodo Matches invece dei metodi Match e 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.
Sostituzione di una sottostringa con corrispondenza
Il metodo Regex.Replace sostituisce ogni sottostringa corrispondente al criterio di espressione regolare con una stringa specificata o con un criterio di espressione regolare e restituisce l'intera stringa di input con le sostituzioni. Ad esempio, il codice riportato di seguito aggiunge il simbolo di valuta degli Stati Uniti prima di un numero decimale in una stringa.
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
Il criterio di espressione regolare \b\d+\.\d{2}\b è interpretato nel modo illustrato nella tabella seguente.
| Modello | Descrizione |
|---|---|
\b |
Inizia la corrispondenza sul confine di parola. |
\d+ |
Trova la corrispondenza con una o più cifre decimali. |
\. |
Trova la corrispondenza con un punto. |
\d{2} |
Trova la corrispondenza con due cifre decimali. |
\b |
Termina la corrispondenza sul confine di parola. |
Il modello di sostituzione $$$& è interpretato nel modo illustrato nella tabella seguente.
| Modello | Stringa di sostituzione |
|---|---|
$$ |
Simbolo del dollaro ($). |
$& |
Intera stringa corrispondente. |
Suddivisione di una singola stringa in una matrice di stringhe
Il metodo Regex.Split suddivide la stringa di input nelle posizioni definite da una corrispondenza di espressione regolare. Ad esempio, il codice seguente inserisce gli elementi di un elenco numerato in una matrice di stringhe.
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
Il criterio di espressione regolare \b\d{1,2}\.\s è interpretato nel modo illustrato nella tabella seguente.
| Modello | Descrizione |
|---|---|
\b |
Inizia la corrispondenza sul confine di parola. |
\d{1,2} |
Trova la corrispondenza con una o due cifre decimali. |
\. |
Trova la corrispondenza con un punto. |
\s |
Trova la corrispondenza con uno spazio vuoto. |
Oggetti MatchCollection e Match
I metodi Regex restituiscono due oggetti che fanno parte del modello a oggetti delle espressioni regolari: l'oggetto MatchCollection e l'oggetto Match.
Raccolta Match
Il metodo Regex.Matches restituisce un oggetto MatchCollection contenente gli oggetti Match che rappresentano tutte le corrispondenze rilevate dal motore delle espressioni regolari, in base all'ordine in cui si trovano nella stringa di input. Se non sono rilevate corrispondenze, il metodo restituisce un oggetto MatchCollection senza membri. La proprietà MatchCollection.Item[] permette di accedere a singoli membri della raccolta in base all'indice, da zero al valore della proprietà MatchCollection.Count meno uno. Item[] è l'indicizzatore della raccolta (in C#) e la proprietà predefinita (in Visual Basic).
Per impostazione predefinita, la chiamata al metodo Regex.Matches usa la valutazione lenta per il popolamento dell'oggetto MatchCollection. L'accesso alle proprietà che necessitano di una raccolta completamente popolata, ad esempio le proprietà MatchCollection.Count e MatchCollection.Item[], potrebbe comportare gravi conseguenze per le prestazioni. È quindi consigliabile accedere alla raccolta usando l'oggetto IEnumerator restituito dal metodo MatchCollection.GetEnumerator. I singoli linguaggi forniscono i costrutti, ad esempio For Each in Visual Basic e foreach in C#, che eseguono il wrapping dell'interfaccia IEnumerator della raccolta.
L'esempio seguente usa il metodo Regex.Matches(String) per popolare un oggetto MatchCollection con tutte le corrispondenze rilevate in una stringa di input. L'esempio enumera la raccolta, copia le corrispondenze a una matrice di stringhe e registra le posizioni dei caratteri in una matrice di valori di tipo Integer.
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.
Oggetto Match
La classe Match rappresenta il risultato della corrispondenza di una singola espressione regolare. È possibile accedere agli oggetti Match in due modi:
Tramite il recupero dall'oggetto MatchCollection restituito dal metodo Regex.Matches. Per recuperare i singoli oggetti Match, eseguire l'iterazione della raccolta usando il costrutto
foreach(in C#) o .For Each...Next.(in Visual Basic) oppure usare la proprietà MatchCollection.Item[] per recuperare un oggetto Match specifico in base all'indice o al nome. È anche possibile recuperare singoli oggetti Match dalla raccolta eseguendo l'iterazione della raccolta in base all'indice, da zero al numero di oggetti della raccolta meno uno. Questo metodo, tuttavia, non permette di avvalersi della valutazione lenta, poiché accede alla proprietà MatchCollection.Count.L'esempio seguente recupera singoli oggetti Match da un oggetto MatchCollection eseguendo l'iterazione della raccolta tramite il costrutto
foreachoFor Each...Next. L'espressione regolare corrisponde semplicemente alla stringa "abc" nella stringa di input.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.Tramite la chiamata al metodo Regex.Match, che restituisce un oggetto Match che rappresenta la prima corrispondenza in una stringa o in una parte di una stringa. È possibile stabilire se la corrispondenza è stata rilevata tramite il recupero del valore della proprietà
Match.Success. Per recuperare gli oggetti Match che rappresentano corrispondenze successive, chiamare ripetutamente il metodo Match.NextMatch, fino a quando la proprietàSuccessdell'oggetto Match restituito non saràfalse.L'esempio seguente usa i metodi Regex.Match(String, String) e Match.NextMatch per la corrispondenza con la stringa "abc" nella stringa di input.
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.
Due proprietà della classe Match restituiscono oggetti della raccolta:
La proprietà Match.Groups restituisce un oggetto GroupCollection che include informazioni sulle sottostringhe che corrispondono a gruppi di acquisizione nel criterio di espressione regolare.
La proprietà
Match.Capturesrestituisce un oggetto CaptureCollection di uso limitato. La raccolta non è popolata per un oggetto Match la cui proprietàSuccessèfalse. In caso contrario, contiene un singolo oggetto Capture che include le stesse informazioni dell'oggetto Match.
Per altre informazioni su questi oggetti, vedere le sezioni Raccolta Group e Raccolta Capture più avanti in questo argomento.
Due proprietà aggiuntive della classe Match forniscono informazioni sulla corrispondenza. La proprietà Match.Value restituisce la sottostringa nella stringa di input corrispondente al criterio di espressione regolare. La proprietà Match.Index restituisce la posizione di inizio a base zero della stringa con corrispondenza nella stringa di input.
La classe Match include anche due metodi di corrispondenza del modello:
Il metodo Match.NextMatch trova la corrispondenza dopo la corrispondenza rappresentata dall'oggetto corrente Match e restituisce un oggetto Match che rappresenta quella corrispondenza.
Il metodo Match.Result esegue un'operazione di sostituzione specificata nella stringa con corrispondenza e restituisce il risultato.
L'esempio seguente usa il metodo Match.Result per aggiungere un simbolo $ e uno spazio davanti a qualsiasi numero che include due cifre frazionarie.
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
Il criterio di ricerca di espressioni regolari \b\d+(,\d{3})*\.\d{2}\b è definito nel modo illustrato nella tabella seguente.
| Modello | Descrizione |
|---|---|
\b |
Inizia la corrispondenza sul confine di parola. |
\d+ |
Trova la corrispondenza con una o più cifre decimali. |
(,\d{3})* |
Trova la corrispondenza con zero o più occorrenze di una virgola seguita da tre cifre decimali. |
\. |
Trova la corrispondenza con il carattere del separatore decimale. |
\d{2} |
Trova la corrispondenza con due cifre decimali. |
\b |
Termina la corrispondenza sul confine di parola. |
Il modello di sostituzione $$ $& indica che la stringa con corrispondenza deve essere sostituita da un simbolo del dollaro ($) (modello $$), uno spazio e il valore della corrispondenza (modello $&).
Raccolta Group
La proprietà Match.Groups restituisce un oggetto GroupCollection che include gli oggetti Group che rappresentano i gruppi acquisiti in una singola corrispondenza. Il primo oggetto Group della raccolta (in corrispondenza dell'indice 0) rappresenta l'intera corrispondenza. Ogni oggetto successivo rappresenta i risultati di un singolo gruppo di acquisizione.
È possibile recuperare singoli oggetti Group nella raccolta usando la proprietà GroupCollection.Item[]. I gruppi senza nome possono essere recuperati in base alla relativa posizione ordinale nella raccolta e i gruppi con nome possono essere recuperati in base al nome o alla posizione ordinale. Le acquisizioni senza nome compaiono per prime nella raccolta e sono indicizzate da sinistra a destra nell'ordine di visualizzazione nel criterio di espressione regolare. Le acquisizioni con nome sono indicizzate dopo le acquisizioni senza nome, da sinistra a destra nell'ordine di visualizzazione nel criterio di espressione regolare. Per determinare i gruppi numerati disponibili nella raccolta restituita per un metodo specifico di corrispondenza con l'espressione regolare, è possibile chiamare il metodo Regex.GetGroupNumbers dell'istanza. Per determinare i gruppi con nome disponibili nella raccolta, è possibile chiamare il metodo Regex.GetGroupNames dell'istanza. Entrambi i metodi sono particolarmente utili in routine di uso generale, che analizzano le corrispondenze rilevate da un'espressione regolare.
La proprietà GroupCollection.Item[] è l'indicizzatore della raccolta in C# e la proprietà predefinita dell'oggetto della raccolta in Visual Basic. È quindi possibile accedere ai singoli oggetti Group in base all'indice oppure in base al nome, nel caso dei gruppi con nome, come indicato di seguito:
Group group = match.Groups[ctr];
Dim group As Group = match.Groups(ctr)
L'esempio seguente definisce un'espressione regolare che usa costrutti di raggruppamento per acquisire il mese, il giorno e l'anno di una data.
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
Il criterio di ricerca di espressioni regolari \b(\w+)\s(\d{1,2}),\s(\d{4})\b è definito nel modo 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. |
\s |
Trova la corrispondenza con uno spazio vuoto. |
(\d{1,2}) |
Trova la corrispondenza con una o due cifre decimali. Equivale al secondo gruppo di acquisizione. |
, |
Trova la corrispondenza con una virgola. |
\s |
Trova la corrispondenza con uno spazio vuoto. |
(\d{4}) |
Trova la corrispondenza con quattro cifre decimali. Equivale al terzo gruppo di acquisizione. |
\b |
Termina la corrispondenza sul confine di parola. |
Gruppo acquisito
La classe Group rappresenta il risultato di un singolo gruppo di acquisizione. Gli oggetti di gruppo che rappresentano i gruppi di acquisizione definiti in un'espressione regolare sono 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. È anche possibile recuperare i singoli membri eseguendo l'iterazione della raccolta mediante il costrutto foreach o For Each. Per un esempio, vedere la sezione precedente.
L'esempio seguente usa i costrutti di raggruppamento annidati per acquisire le sottostringhe nei gruppi. Il criterio 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.
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
L'esempio seguente usa costrutti di raggruppamento con nome per acquisire sottostringhe da una stringa che include dati nel formato "DATANAME:VALUE" e viene suddivisa in corrispondenza dei due punti (:) dall'espressione regolare.
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
Il criterio di ricerca di espressioni regolari ^(?<name>\w+):(?<value>\w+) è definito nel modo illustrato nella tabella seguente.
| Modello | Descrizione |
|---|---|
^ |
Inizia la corrispondenza all'inizio della stringa di input. |
(?<name>\w+) |
Trova la corrispondenza di uno o più caratteri alfanumerici. Il nome di questo gruppo di acquisizione è name. |
: |
Trova la corrispondenza con i due punti. |
(?<value>\w+) |
Trova la corrispondenza di 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 include la sottostringa acquisita, la proprietàGroup.Index indica la posizione iniziale del gruppo acquisito nel testo di input, la proprietà Group.Length include la lunghezza del testo acquisito e la proprietà Group.Success indica se una sottostringa corrisponde al modello definito dal gruppo di acquisizione.
L'applicazione di quantificatori a un gruppo (per altre informazioni, vedere Quantificatori) modifica la relazione di un'acquisizione per ogni gruppo di acquisizione in due modi:
Se il quantificatore
*o*?(che specifica zero o più corrispondenze) è applicato a un gruppo, è possibile che per un gruppo di acquisizione non siano rilevate corrispondenze nella stringa di input. Se non è presente testo acquisito, le proprietà dell'oggetto Group sono impostate come mostrato nella tabella seguente.Proprietà del gruppo Valore SuccessfalseValueString.Empty Length0 Di seguito ne viene illustrato un esempio. Nel criterio di espressione regolare
aaa(bbb)*cccper il primo gruppo di acquisizione (sottostringa "bbb") possono essere rilevate zero o più corrispondenze. Poiché la stringa di input "aaaccc" corrisponde al modello, per il gruppo di acquisizione non sono rilevate corrispondenze.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.I quantificatori possono corrispondere a più occorrenze di un modello definito da un gruppo di acquisizione. In questo caso, le proprietà
ValueeLengthdi un oggetto Group contengono informazioni sull'ultima sottostringa acquisita. Ad esempio, l'espressione regolare seguente corrisponde a una singola frase che termina con un punto. Usa due costrutti di raggruppamento: il primo acquisisce singole parole insieme a un carattere di spaziatura e il secondo acquisisce le singole parole. Come illustrato dall'output dell'esempio, anche se l'espressione regolare riesce ad acquisire un'intera frase, il secondo gruppo di acquisizione acquisisce solo l'ultima parola.using System; using System.Text.RegularExpressions; public class Example { public static void Main() { string pattern = @"\b((\w+)\s?)+\."; string input = "This is a sentence. This is another sentence."; Match match = Regex.Match(input, pattern); if (match.Success) { Console.WriteLine("Match: " + match.Value); Console.WriteLine("Group 2: " + match.Groups[2].Value); } } } // The example displays the following output: // Match: This is a sentence. // Group 2: sentenceImports System.Text.RegularExpressions Module Example Public Sub Main() Dim pattern As String = "\b((\w+)\s?)+\." Dim input As String = "This is a sentence. This is another sentence." Dim match As Match = Regex.Match(input, pattern) If match.Success Then Console.WriteLine("Match: " + match.Value) Console.WriteLine("Group 2: " + match.Groups(2).Value) End If End Sub End Module ' The example displays the following output: ' Match: This is a sentence. ' Group 2: sentence
Raccolta Capture
L'oggetto Group include informazioni solo sull'ultima acquisizione. L'intero set di acquisizioni eseguite da un gruppo di acquisizione è tuttavia ancora disponibile tramite l'oggetto CaptureCollection restituito dalla proprietà Group.Captures. Ogni membro della raccolta è un oggetto Capture che rappresenta un'acquisizione eseguita da quel gruppo di acquisizione, in base all'ordine di acquisizione e quindi in base all'ordine in cui sono state rilevate corrispondenze per le stringhe acquisite da sinistra a destra nella stringa di input. È possibile recuperare singoli oggetti Capture dalla raccolta in uno dei due modi seguenti:
Eseguendo un'iterazione nella raccolta tramite un costrutto, ad esempio
foreach(in C#) oFor Each(in Visual Basic).Usando 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 a un gruppo di acquisizione non è applicato alcun quantificatore, l'oggetto CaptureCollection conterrà un singolo oggetto Capture di scarso interesse, poiché fornisce informazioni sulla stessa corrispondenza indicata dall'oggetto Group. Se a un gruppo di acquisizione è applicato un quantificatore, l'oggetto CaptureCollection conterrà tutte le acquisizioni eseguite dal gruppo di acquisizione e l'ultimo membro della raccolta rappresenterà la stessa acquisizione indicata dall'oggetto Group.
Ad esempio, se si usa il criterio di espressione regolare ((a(b))c)+, in cui il quantificatore + specifica una o più corrispondenze, per acquisire corrispondenze dalla stringa "abcabcabc", l'oggetto CaptureCollection per ogni oggetto Group includerà tre membri.
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
L'esempio seguente usa l'espressione regolare (Abc)+ per trovare una o più esecuzioni consecutive della stringa "Abc" nella stringa "XYZAbcAbcAbcXYZAbcAb". L'esempio illustra l'uso della proprietà Group.Captures per restituire più gruppi di sottostringhe acquisite.
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
Singola acquisizione
La classe Capture include i risultati di una singola acquisizione di sottoespressione. La proprietà Capture.Value include il testo con corrispondenza e la proprietà Capture.Index indica la posizione a base zero nella stringa di input in cui inizia la sottostringa con corrispondenza.
L'esempio seguente analizza una stringa di input per ottenere la temperatura di città selezionate. Una città e la relativa temperatura sono separate da una virgola (",") e un punto e virgola (";") separa i dati di ogni città. L'intera stringa di input rappresenta una singola corrispondenza. Nel criterio di espressione regolare ((\w+(\s\w+)*),(\d+);)+, usato per analizzare la stringa, il nome della città è assegnato al secondo gruppo di acquisizione e la temperatura al quarto.
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
L'espressione regolare è definita nel modo illustrato nella tabella seguente.
| Modello | Descrizione |
|---|---|
\w+ |
Trova la corrispondenza di uno o più caratteri alfanumerici. |
(\s\w+)* |
Trova la corrispondenza con zero o più occorrenze di un carattere di spaziatura seguito da uno o più caratteri di parola. Questo modello corrisponde a nomi di città composti da più parole. Equivale al terzo gruppo di acquisizione. |
(\w+(\s\w+)*) |
Trova la corrispondenza con uno o più caratteri di parola seguiti da zero o più caratteri di spaziatura e uno o più caratteri di parola. Equivale al secondo gruppo di acquisizione. |
, |
Trova la corrispondenza con una virgola. |
(\d+) |
Trova la corrispondenza con una o più cifre. Questo è il quarto gruppo di acquisizione. |
; |
Trova la corrispondenza con un punto e virgola. |
((\w+(\s\w+)*),(\d+);)+ |
Trova la corrispondenza con modello di una parola seguita da parole aggiuntive seguite da una virgola, una o più cifre e un punto e virgola, una o più volte. Equivale al primo gruppo di acquisizione. |
Vedi anche
Commenti e suggerimenti
Presto disponibile: nel corso del 2024 verranno dismessi i problemi di GitHub come meccanismo di feedback per il contenuto e verranno sostituiti con un nuovo sistema di feedback. Per altre informazioni, vedere: https://aka.ms/ContentUserFeedback.
Invia e visualizza il feedback per