Classes d'expressions régulières
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.
' cCreate 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.
' (Character position 3 in this case.)
Console.WriteLine("Found match at position " & m.Index.ToString())
End If
// 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.
// (Character position 3 in this case.)
Console.WriteLine("Found match at position " + m.Index);
}
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 une 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(20) As String
Dim matchposition(20) As 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.
Dim i As Integer
For i = 0 To mc.Count - 1
' Add the match string to the string array.
results(i) = mc(i).Value
' Record the character position where the match was found.
matchposition(i) = mc(i).Index
Next i
MatchCollection mc;
String[] results = new String[20];
int[] matchposition = new int[20];
// 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[i] = mc[i].Value;
// Record the character position where the match was found.
matchposition[i] = mc[i].Index;
}
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 d'application console 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.
Imports System
Imports System.Text.RegularExpressions
Public Class RegexTest
Public Shared Sub RunTest()
' 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.ToString())
End Sub
Public Shared Sub Main()
RunTest()
End Sub
End Class
using System;
using System.Text.RegularExpressions;
public class RegexTest
{
public static void RunTest()
{
// 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);
}
public static void Main()
{
RunTest();
}
}
Cet exemple génère la sortie suivante :
Number of groups found = 3
Number of groups found = 3
CaptureCollection
La classe CaptureCollection représente une séquence 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 d'application console 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.
Imports System
Imports System.Text.RegularExpressions
Public Class RegexTest
Public Shared Sub RunTest()
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
' Print 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
' Print number of captures in this group.
Console.WriteLine("Captures count = " & counter.ToString())
' Loop through each capture in group.
For ii = 0 To counter - 1
' Print capture and position.
Console.WriteLine(cc(ii).ToString() _
& " Starts at character " & cc(ii).Index.ToString())
Next ii
Next i
End Sub
Public Shared Sub Main()
RunTest()
End Sub
End Class
using System;
using System.Text.RegularExpressions;
public class RegexTest
{
public static void RunTest()
{
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;
// Print 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;
// Print number of captures in this group.
Console.WriteLine("Captures count = " + counter.ToString());
// Loop through each capture in group.
for (int ii = 0; ii < counter; ii++)
{
// Print capture and position.
Console.WriteLine(cc[ii] + " Starts at character " +
cc[ii].Index);
}
}
}
public static void Main() {
RunTest();
}
}
Cet exemple retourne la sortie suivante :
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
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(20) As Integer
Dim results(20) As 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 = "")
' Copy groups to string array.
results(i) = m.Groups(i).Value
' Record character position.
matchposition(i) = m.Groups(i).Index
i = i + 1
End While
int[] matchposition = new int[20];
String[] results = new String[20];
// 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++)
{
// Copy groups to string array.
results[i]=m.Groups[i].Value;
// Record character position.
matchposition[i] = m.Groups[i].Index;
}
Cet exemple retourne la sortie suivante :
results(0) = "abc" matchposition(0) = 3
results(1) = "ab" matchposition(1) = 3
results(2) = "b" matchposition(2) = 4
results[0] = "abc" matchposition[0] = 3
results[1] = "ab" matchposition[1] = 3
results[2] = "b" matchposition[2] = 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")
Regex r = new Regex("^(?<name>\\w+):(?<value>\\w+)");
Match m = r.Match("Section1:119900");
Cette expression régulière retourne la sortie suivante :
m.Groups("name").Value = "Section1"
m.Groups("value").Value = "119900"
m.Groups["name"].Value = "Section1"
m.Groups["value"].Value = "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
While m.Groups(i).Value <> ""
' Grab the Collection for Group(i).
cc = m.Groups(i).Captures
For j = 0 To cc.Count - 1
' Position of Capture object.
posn = cc(j).Index
' Length of Capture object.
length = cc(j).Length
Next j
i += 1
End While
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++)
{
// Capture the Collection for Group(i).
cc = m.Groups[i].Captures;
for (int j = 0; j < cc.Count; j++)
{
// Position of Capture object.
posn = cc[j].Index;
// Length of Capture object.
length = cc[j].Length;
}
}
Voir aussi
Référence
System.Text.RegularExpressions