Classes d'expressions régulières
Mise à jour : novembre 2007
Les sections suivantes décrivent les classes d'expressions régulières du .NET Framework.
Regex
La classe Regex représente une expression régulière immuable (en lecture seule). Elle contient également des méthodes statiques qui permettent l'utilisation d'autres classes d'expressions régulières sans créer explicitement des instances des autres classes.
L'exemple de code suivant crée une instance de la classe Regex et définit une expression régulière simple lors de l'initialisation de l'objet. Vous remarquerez l'utilisation d'une barre oblique inverse supplémentaire en tant que caractère d'échappement désignant comme caractère littéral la barre oblique inverse dans la classe de caractères \s de correspondance.
' 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 représente les résultats d'une opération de recherche de correspondances à l'aide d'expressions régulières. L'exemple suivant utilise la méthode Match de la classe Regex pour retourner un objet de type Match afin de rechercher la première correspondance dans la chaîne d'entrée. L'exemple utilise la propriété Match.Success de la classe Match pour indiquer si une correspondance a été trouvée.
' 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 représente une séquence de correspondances non superposées réussies. La collection est immuable (en lecture seule) et n'a pas de constructeur public. Les instances de MatchCollection sont retournées par la méthode Regex.Matches.
L'exemple suivant utilise la méthode Matches de la classe Regex pour remplir MatchCollection avec toutes les correspondances trouvées dans la chaîne d'entrée. L'exemple copie la collection dans un tableau de chaînes qui contient chaque correspondance et dans un tableau d'entiers qui indique l'emplacement de chaque correspondance.
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 représente une collection de groupes capturés et retourne l'ensemble de groupes capturés dans une même correspondance. La collection est immuable (en lecture seule) et n'a pas de constructeur public. Les instances de GroupCollection sont retournées dans la collection retournée par la propriété Match.Groups.
L'exemple suivant recherche et imprime le nombre de groupes capturés par une expression régulière. Pour obtenir un exemple de méthode d'extraction des captures individuelles dans chaque membre d'une collection de groupes, consultez l'exemple de Capture Collection dans la section suivante.
' 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 représente une suite de sous-chaînes capturées et retourne l'ensemble des captures effectuées par un seul groupe de capture. Un groupe de capture peut capturer plusieurs chaînes dans une seule correspondance grâce aux quantifieurs. La propriété Captures, objet de la classe CaptureCollection, est fournie en tant que membre des classes Match et Group pour simplifier l'accès à l'ensemble de sous-chaînes capturées.
Par exemple, si vous utilisez l'expression régulière ((a(b))c)+ (où le quantifieur + spécifie une ou plusieurs correspondances) pour capturer les correspondances dans la chaîne « abcabcabc », la CaptureCollection contient trois membres pour chaque Group de sous-chaînes correspondant.
L'exemple suivant utilise l'expression régulière (Abc)+ pour rechercher une ou plusieurs correspondances dans la chaîne « XYZAbcAbcAbcXYZAbcAb ». Cet exemple illustre l'utilisation de la propriété Captures pour retourner plusieurs groupes de sous-chaînes capturées.
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 représente les résultats d'un seul groupe de capture. Comme Group peut capturer zéro, une ou plusieurs chaînes dans une même correspondance (à l'aide des quantifieurs), elle contient une collection d'objets Capture. Étant donné que Group hérite de Capture, la dernière sous-chaîne capturée est accessible directement (l'instance Group elle-même est équivalente au dernier élément de la collection retournée par la propriété Captures).
Les instances de Group sont retournées en indexant l'objet GroupCollection retourné par la propriété Groups. L'indexeur peut être un numéro de groupe ou le nom d'un groupe de capture si la construction de regroupement "(?<groupname>)" est utilisée. Par exemple, en code C#, vous pouvez utiliser Match.Groups[groupnum] ou Match.Groups["groupname"] ou, en code Visual Basic, vous pouvez utiliser Match.Groups(groupnum) ou Match.Groups("groupname").
L'exemple de code suivant utilise des constructions de regroupement imbriquées pour capturer des sous-chaînes dans des groupes.
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
L'exemple de code suivant utilise des constructions de regroupement nommées pour capturer des sous-chaînes à partir d'une chaîne contenant des données sous un format " NOMDONNÉES:VALEUR " que l'expression régulière scinde à l'endroit des deux-points (« : »).
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 contient les résultats d'une seule capture de sous-expressions.
L'exemple suivant exécute une boucle dans une collection Group, extrait la collection Capture de chaque membre de Group et assigne les variables posn et length à l'emplacement du caractère dans la chaîne d'origine dans laquelle chaque chaîne a été trouvée et à la longueur de chaque chaîne, respectivement.
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.
Voir aussi
Référence
System.Text.RegularExpressions