Classi di espressioni regolari
Aggiornamento: novembre 2007
Nelle sezioni riportate di seguito vengono descritte le classi delle espressioni regolari di .NET Framework.
Regex
La classe Regex rappresenta un'espressione regolare immutabile, ovvero in sola lettura. Contiene inoltre i metodi statici che consentono di utilizzare altre classi di espressioni regolari senza creare in modo esplicito istanze delle altre classi.
Nell'esempio di codice che segue viene creata un'istanza della classe Regex e viene definita un'espressione regolare semplice al momento dell'inizializzazione dell'oggetto. L'uso di una barra rovesciata aggiuntiva come carattere di escape indica che la barra rovesciata presente nella classe del carattere di corrispondenza \s è un carattere effettivo.
' Declare object variable of type Regex.
Dim r As Regex
' Create a Regex object and define its regular expression.
r = New Regex("\s2000")
// Declare object variable of type Regex.
Regex r;
// Create a Regex object and define its regular expression.
r = new Regex("\\s2000");
Match
La classe Match rappresenta i risultati di un'analisi basata su un'espressione regolare. Nell'esempio che segue viene utilizzato il metodo Match della classe Regex per restituire un oggetto di tipo Match al fine di trovare la prima corrispondenza nella stringa di input. Nell'esempio viene utilizzata la proprietà Match.Success della classe Match per indicare se è stata trovata una corrispondenza.
' Create a new Regex object.
Dim r As New Regex("abc")
' Find a single match in the input string.
Dim m As Match = r.Match("123abc456")
If m.Success Then
' Print out the character position where a match was found.
Console.WriteLine("Found match at position " & m.Index.ToString())
End If
' The example displays the following output:
' Found match at position 3
// Create a new Regex object.
Regex r = new Regex("abc");
// Find a single match in the string.
Match m = r.Match("123abc456");
if (m.Success)
{
// Print out the character position where a match was found.
Console.WriteLine("Found match at position " + m.Index);
}
// The example displays the following output:
// Found match at position 3
MatchCollection
La classe MatchCollection rappresenta una sequenza di corrispondenze individuate e non sovrapposte. L'insieme non è modificabile (sola lettura) e non dispone di costruttori pubblici. Le istanze di MatchCollection vengono restituite dal metodo Regex.Matches.
Nell'esempio che segue viene utilizzato il metodo Matches della classe Regex per inserire in un oggetto MatchCollection tutte le corrispondenze trovate nella stringa di input. Nell'esempio l'insieme viene copiato in una matrice di stringhe che contiene ogni corrispondenza e in una matrice integer che indica la posizione di ogni corrispondenza.
Dim mc 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.
mc = r.Matches("123abc4abcd")
' Loop through the match collection to retrieve all
' matches and positions.
For i As Integer = 0 To mc.Count - 1
' Add the match string to the string array.
results.Add(mc(i).Value)
' Record the character position where the match was found.
matchposition.Add(mc(i).Index)
Next i
' List the results.
For ctr As Integer = 0 To Results.Count - 1
Console.WriteLine("'{0}' found at position {1}.", _
results(ctr), matchposition(ctr))
Next
' The example displays the following output:
' 'abc' found at position 3.
' 'abc' found at position 7.
MatchCollection mc;
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.
mc = r.Matches("123abc4abcd");
// Loop through the match collection to retrieve all
// matches and positions.
for (int i = 0; i < mc.Count; i++)
{
// Add the match string to the string array.
results.Add(mc[i].Value);
// Record the character position where the match was found.
matchposition.Add(mc[i].Index);
}
// List the results.
for(int ctr = 0; ctr <= results.Count - 1; 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.
GroupCollection
La classe GroupCollection rappresenta un insieme di gruppi acquisiti e lo restituisce in una singola corrispondenza. L'insieme non è modificabile (sola lettura) e non dispone di costruttori pubblici. Le istanze di GroupCollection vengono restituite nell'insieme restituito dalla proprietà Match.Groups.
Nell'esempio seguente viene trovato e stampato il numero di gruppi acquisiti da un'espressione regolare. Per un esempio di estrazione delle singole acquisizioni in ogni membro di un insieme di gruppi, vedere l'esempio CaptureCollection nella sezione che segue.
' Define groups "abc", "ab", and "b".
Dim r As New Regex("(a(b))c")
Dim m As Match = r.Match("abdabc")
Console.WriteLine("Number of groups found = " _
& m.Groups.Count)
' The example displays the following output:
' Number of groups found = 3
// Define groups "abc", "ab", and "b".
Regex r = new Regex("(a(b))c");
Match m = r.Match("abdabc");
Console.WriteLine("Number of groups found = " + m.Groups.Count);
// The example displays the following output:
// Number of groups found = 3
CaptureCollection
La classe CaptureCollection rappresenta una sequenza di sottostringhe acquisite e restituisce l'insieme di elementi acquisiti da un singolo gruppo di acquisizione. Un gruppo di cattura può catturare più stringhe in una singola corrispondenza grazie ai quantificatori. La proprietà Captures, un oggetto della classe CaptureCollection , viene fornita come membro delle classi Match e Group per semplificare l'accesso all'insieme di sottostringhe acquisite.
Se ad esempio si utilizza l'espressione regolare ((a(b))c)+, dove il quantificatore + specifica una o più corrispondenze, per catturare corrispondenze dalla stringa "abcabcabc", il CaptureCollection di ciascun Group corrispondente di sottostringhe conterrà tre membri.
Nell'esempio seguente viene utilizzata l'espressione regolare (Abc)+ per trovare una o più corrispondenze nella stringa "XYZAbcAbcAbcXYZAbcAb". Nell'esempio viene illustrato l'utilizzo della proprietà Captures per restituire più gruppi di sottostringhe catturate.
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
Group
La classe Group rappresenta i risultati di un singolo gruppo di acquisizione. Grazie ai quantificatori, in una singola corrispondenza Group può acquisire una o più stringhe o non acquisirne alcuna. Pertanto, contiene un insieme di oggetti Capture. Poiché Group eredita da Capture, è possibile accedere direttamente all'ultima sottostringa acquisita. La stessa istanza di Group è equivalente all'ultima voce dell'insieme restituito dalla proprietà Captures.
Vengono restituite istanze della classe Group indicizzando l'oggetto GroupCollection restituito dalla proprietà Groups. L'indicizzatore può essere un numero di gruppo o il nome di un gruppo di acquisizione se viene utilizzato il costrutto di raggruppamento "(?<nomegruppo>)". Nel codice C# ad esempio è possibile utilizzare Match.Groups[numgruppo] o Match.Groups["nomegruppo"] oppure nel codiceVisual Basic è possibile utilizzare Match.Groups(numgruppo) o Match.Groups("nomegruppo").
Nell'esempio di codice che segue vengono utilizzati costrutti di raggruppamento nidificati per catturare sottostringhe in gruppi.
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 di codice che segue vengono utilizzati i costrutti di raggruppamento denominati per acquisire le sottostringhe da una stringa contenente dati in formato "DATANAME:VALUE" che viene suddiviso in corrispondenza dei due punti (:) dall'espressione regolare.
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
Capture
La classe Capture contiene i risultati di una singola acquisizione di sottoespressioni.
Nell'esempio riportato di seguito si scorre un insieme Group, viene estratto l'insieme Capture da ciascun membro di Group e vengono impostate le variabili posn e length, la prima sulla posizione in cui, nella stringa originale, si trova il primo carattere di ciascuna stringa trovata e la seconda sulla lunghezza di ciascuna stringa.
Dim r As Regex
Dim m As Match
Dim cc As CaptureCollection
Dim posn, length As Integer
r = New Regex("(abc)+")
m = r.Match("bcabcabc")
Dim i, j As Integer
i = 0
Do While m.Groups(i).Value <> ""
Console.WriteLine(m.Groups(i).Value)
' Grab the Collection for Group(i).
cc = m.Groups(i).Captures
For j = 0 To cc.Count - 1
Console.WriteLine(" Capture at position {0} for {1} characters.", _
cc(j).Length, cc(j).Index)
' Position of Capture object.
posn = cc(j).Index
' Length of Capture object.
length = cc(j).Length
Next j
i += 1
Loop
' The example displays the following output:
' abcabc
' Capture at position 6 for 2 characters.
' abc
' Capture at position 3 for 2 characters.
' Capture at position 3 for 5 characters.
Regex r;
Match m;
CaptureCollection cc;
int posn, length;
r = new Regex("(abc)+");
m = r.Match("bcabcabc");
for (int i=0; m.Groups[i].Value != ""; i++)
{
Console.WriteLine(m.Groups[i].Value);
// Capture the Collection for Group(i).
cc = m.Groups[i].Captures;
for (int j = 0; j < cc.Count; j++)
{
Console.WriteLine(" Capture at position {0} for {1} characters.",
cc[j].Length, cc[j].Index);
// Position of Capture object.
posn = cc[j].Index;
// Length of Capture object.
length = cc[j].Length;
}
}
// The example displays the following output:
// abcabc
// Capture at position 6 for 2 characters.
// abc
// Capture at position 3 for 2 characters.
// Capture at position 3 for 5 characters.
Vedere anche
Riferimenti
System.Text.RegularExpressions