Modèle objet d'expression régulière

Article
08/10/2011

Cette rubrique décrit le modèle objet utilisé avec les expressions régulières .NET Framework. Elle contient les sections suivantes :

Moteur des expressions régulières
Objets MatchCollection et Match
Collection de groupe
Groupe capturé
Collection de capture
Capture individuelle

Moteur des expressions régulières

Le moteur des expressions régulières du .NET Framework est représenté par la classe Regex. Le moteur des expressions régulières est chargé de l'analyse et de la compilation d'une expression régulière, ainsi que de l'exécution des opérations de correspondance entre le modèle d'expression régulière et une chaîne d'entrée. Le moteur est le composant central du modèle objet d'expression régulière .NET Framework.

Vous pouvez utiliser le moteur des expressions régulières de deux façons :

En appelant les méthodes statiques de la classe Regex. Les paramètres de méthode incluent la chaîne d'entrée et le modèle d'expression régulière. Le moteur des expressions régulières met en cache les expressions régulières utilisées dans les appels de méthodes statiques. Les appels répétés aux méthodes d'expressions régulières statiques qui utilisent la même expression régulière offrent donc des performances relativement élevées.
En instanciant un objet Regex, en passant une expression régulière au constructeur de classe. Dans ce cas, l'objet Regex est immuable (en lecture seule) et représente un moteur des expressions régulières fortement couplé à une expression régulière unique. Étant donné que les expressions régulières utilisées par les instances de Regex ne sont pas mises en cache, vous ne devez pas instancier un objet Regex plusieurs fois avec la même expression régulière.

Vous pouvez appeler les méthodes de la classe Regex pour effectuer les opérations suivantes :

Déterminer si une chaîne correspond à un modèle d'expression régulière.
Extraire une correspondance unique ou la première correspondance.
Extraire toutes les correspondances.
Remplacer une sous-chaîne correspondante.
Fractionner une chaîne unique dans un tableau de chaînes.

Ces opérations sont décrites dans les sections suivantes.

Mise en correspondance d'un modèle d'expression régulière

La méthode Regex.IsMatch retourne true si la chaîne correspond au modèle, ou false si elle ne correspond pas. La méthode IsMatch est souvent utilisée pour valider l'entrée de chaîne. Par exemple, le code suivant vérifie qu'une chaîne correspond à un numéro de sécurité sociale valide aux États-Unis.

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

Le modèle d'expression régulière ^\d{3}-\d{2}-\d{4}$ est interprété comme indiqué dans le tableau suivant.

Modèle	Description
^	Mettre en correspondance le début de la chaîne d'entrée.
\d{3}	Mettre en correspondance trois chiffres décimaux.
-	Mettre en correspondance un trait d'union.
\d{2}	Mettre en correspondance deux chiffres décimaux.
-	Mettre en correspondance un trait d'union.
\d{4}	Mettre en correspondance quatre chiffres décimaux.
$	Mettre en correspondance la fin de la chaîne d'entrée.

Extraction d'une correspondance unique ou de la première correspondance.

La méthode Regex.Match retourne un objet Match qui contient des informations sur la première sous-chaîne qui correspond à un modèle d'expression régulière. Si la propriété Match.Success retourne la valeur true, en indiquant qu'une correspondance a été trouvée, vous pouvez extraire les informations relatives aux correspondances suivantes en appelant la méthode Match.NextMatch. Ces appels de méthode peuvent continuer jusqu'à ce que la propriété Match.Success retourne la valeur false. Par exemple, le code suivant utilise la méthode Regex.Match(String, String) pour rechercher la première occurrence d'un mot dupliqué dans une chaîne. Il appelle ensuite la méthode Match.NextMatch pour rechercher les éventuelles occurrences supplémentaires. L'exemple examine la propriété Match.Success après chaque appel de méthode pour déterminer si la correspondance actuelle était la bonne et si un appel à la méthode Match.NextMatch doit suivre.

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.

Le modèle d'expression régulière \b(\w+)\W+(\1)\b est interprété comme indiqué dans le tableau suivant.

Modèle	Description
\b	Commencer la correspondance à la limite d'un mot.
(\w+)	Mettre en correspondance un ou plusieurs caractères alphabétiques. Il s'agit du premier groupe de capture.
\W+	Mettre en correspondance un ou plusieurs caractères non alphabétiques.
(\1)	Mettre en correspondance la première chaîne capturée. Il s'agit du deuxième groupe de capture.
\b	Terminez la correspondance sur la limite d'un mot.

Extraction de toutes les correspondances

La méthode Regex.Matches retourne un objet MatchCollection qui contient des informations sur toutes les correspondances trouvées par le moteur d'expression régulière dans la chaîne d'entrée. Ainsi, l'exemple précédent pourrait être réécrit pour appeler la méthode Matches au lieu des méthodes Match et 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.

Remplacement d'une sous-chaîne correspondante

La méthode Regex.Replace remplace chaque sous-chaîne qui fait correspondre le modèle d'expression régulière à une chaîne ou un modèle d'expression régulière spécifié, et retourne la chaîne d'entrée entière avec les remplacements. Par exemple, le code suivante ajoute un symbole monétaire US avant un nombre décimal dans une chaîne.

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

Le modèle d'expression régulière \b\d+\.\d{2}\b est interprété comme indiqué dans le tableau suivant.

Modèle	Description
\b	Commencer la correspondance à la limite d'un mot.
\d+	Mettre en correspondance un ou plusieurs chiffres décimaux.
\.	Mettre en correspondance un point.
\d{2}	Mettre en correspondance deux chiffres décimaux.
\b	Terminer la correspondance à la limite d'un mot.

Le modèle de remplacement $$$& est interprété comme indiqué dans le tableau suivant.

Modèle	Chaîne de remplacement
$$	Caractère du dollar ($).
$&	Sous-chaîne correspondante entière.

Fractionnement d'une chaîne unique dans un tableau de chaînes

La méthode Regex.Split fractionne la chaîne d'entrée aux emplacements définis par une correspondance d'expression régulière. Par exemple, le code suivant place les éléments d'une liste numérotée dans un tableau de chaînes.

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

Le modèle d'expression régulière \b\d{1,2}\.\s est interprété comme indiqué dans le tableau suivant.

Modèle	Description
\b	Commencer la correspondance à la limite d'un mot.
\d{1,2}	Mettre en correspondance un ou deux chiffres décimaux.
\.	Mettre en correspondance un point.
\s	Mettre en correspondance un espace blanc.

Objets MatchCollection et Match

Les méthodes Regex retournent deux objets qui font partie du modèle objet d'expression régulière : l'objet MatchCollection et l'objet Match.

Collection Match

La méthode Regex.Matches retourne un objet MatchCollection qui contient des objets Match qui représentent toutes les correspondances trouvées par le moteur d'expression régulière, dans l'ordre dans lequel elles se produisent dans la chaîne d'entrée. S'il n'y a aucune correspondance, la méthode retourne un objet MatchCollection sans membres. La propriété MatchCollection.Item vous permet d'accéder aux membres individuels de la collection par index, de zéro à un de moins que la valeur de la propriété MatchCollection.Count. Item est l'indexeur (en C#) et la propriété par défaut (en Visual Basic) de la collection.

Par défaut, l'appel à la méthode Regex.Matches utilise l'évaluation tardive pour remplir l'objet MatchCollection. L'accès aux propriétés qui nécessitent une collection entièrement remplie, telles que les propriétés MatchCollection.Count et MatchCollection.Item, peut impliquer une diminution des performances. Par conséquent, nous vous recommandons d'accéder à la collection à l'aide de l'objet IEnumerator retourné par la méthode MatchCollection.GetEnumerator. Les langages individuels fournissent des constructions, telles que ForEach en Visual Basic et foreach en C#, qui incluent dans un wrapper l'interface IEnumerator de la collection.

L'exemple suivant utilise la méthode Regex.Matches(String) pour remplir un objet MatchCollection avec toutes les correspondances trouvées dans une chaîne d'entrée. L'exemple énumère la collection, copie les correspondances vers un tableau de chaînes et enregistre les positions des caractères dans un tableau d'entiers.

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.

Match

La classe Match représente le résultat d'une correspondance d'expression régulière unique. Vous pouvez accéder aux objets Match de deux façons :

En les extrayant de l'objet MatchCollection qui est retourné par la méthode Regex.Matches. Pour extraire des objets Match individuels, itérez au sein de la collection à l'aide d'une construction foreach (en C#) ou For Each...Next (en Visual Basic), ou utilisez la propriété MatchCollection.Item pour extraire un objet Match spécifique grâce à son index ou son nom. Vous pouvez également extraire des objets Match individuels de la collection en itérant au sein la collection par index, de zéro à un de moins que le nombre d'objets de la collection. Toutefois, cette méthode ne tire pas parti de l'évaluation tardive, parce qu'elle accède à la propriété MatchCollection.Count.

L'exemple suivant extrait des objets Match individuels d'un objet MatchCollection en itérant au sein de la collection à l'aide de la construction foreach ou For Each...Next. L'expression régulière correspond simplement ) la chaîne « abc » de la chaîne d'entrée.

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.

En appelant la méthode Regex.Match, qui retourne un objet Match qui représente la première correspondance d'une chaîne ou d'une partie d'une chaîne. Vous pouvez déterminer si la correspondance a été trouvée en extrayant la valeur de la propriété Match.Success. Pour extraire les objets Match qui représentent les correspondances suivantes, appelez la méthode Match.NextMatch à plusieurs reprises, jusqu'à la propriété Success de l'objet Match retourné ait la valeur false.

L'exemple suivant utilise les méthodes Regex.Match(String, String) et Match.NextMatch pour faire correspondre la chaîne « abc » dans la chaîne d'entrée.

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.

Deux propriétés de la classe Match retournent des objets de collection :

La propriété Match.Groups retourne un objet GroupCollection qui contient des informations à propos des sous-chaînes qui correspondent aux groupes de capture dans le modèle d'expression régulière.
La propriété Group.Captures retourne un objet CaptureCollection d'utilisation limitée. La collection n'est pas remplie pour un objet Match dont la propriété Success a la valeur false. Sinon, elle contient un objet Capture unique qui a les mêmes informations que l'objet Match.

Pour plus d'informations sur ces objets, consultez les sections Collection de groupe et Collection de capture plus loin dans cette rubrique.

Deux propriétés supplémentaires de la classe Match fournissent des informations à propos de la correspondance. La propriété Match.Value retourne la sous-chaîne de la chaîne d'entrée qui correspond au modèle d'expression régulière. La propriété Match.Index retourne la position de départ basée sur zéro de la chaîne correspondante dans la chaîne d'entrée.

La classe Match dispose également de deux méthodes de correspondance de modèle :

La méthode Match.NextMatch trouve la correspondance après la correspondance représentée par l'objet Match actuel, et retourne un objet Match qui représente cette correspondance.
La méthode Match.Result exécute une opération de remplacement spécifiée sur la chaîne correspondante et retourne le résultat.

L'exemple suivant utilise la méthode Match.Result pour ajouter un symbole $ et un espace avant chaque nombre qui inclut deux chiffres fractionnaires.

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

Le modèle d'expression régulière \b\d+(,\d{3})*\.\d{2}\b est défini comme indiqué dans le tableau suivant.

Modèle	Description
\b	Commencez la correspondance à la limite d'un mot.
\d+	Mettre en correspondance un ou plusieurs chiffres décimaux.
(,\d{3})*	Mettre en correspondance zéro, une ou plusieurs occurrences d'une virgule suivie de trois chiffres décimaux.
\.	Mettre en correspondance le caractère de virgule décimale.
\d{2}	Mettre en correspondance deux chiffres décimaux.
\b	Terminez la correspondance à la limite d'un mot.

Le modèle de remplacement $$ $& indique que la sous-chaîne correspondante doit être remplacée par un dollar ($) (modèle $$), un espace et la valeur de la correspondance (modèle $&).

Retour au début

Collection de groupe

La propriété Match.Groups retourne un objet GroupCollection qui contient des objets Group qui représentent des groupes capturés dans une correspondance unique. Le premier objet Group de la collection (à l'index 0) représente la correspondance entière. Chaque objet qui suit représente les résultats d'un groupe de capture unique.

Vous pouvez extraire des objets Group individuels de la collection à l'aide de la propriété GroupCollection.Item. Vous pouvez extraire des groupes sans nom avec leur position ordinale dans la collection, et extraire des groupes nommés grâce à leur nom ou leur position ordinale. Les captures sans nom apparaissent en premier dans la collection et sont indexées de gauche à droite dans l'ordre dans lequel elles s'affichent dans le modèle d'expression régulière. Les captures nommées sont indexées après les captures sans nom, de gauche à droite dans l'ordre dans lequel elles s'affichent dans le modèle d'expression régulière.

La propriété GroupCollection.Item est l'indexeur de la collection en C# et la propriété par défaut de l'objet collection en Visual Basic. Cela signifie que les objets Group individuels peut faire l'objet d'accès en fonction de leur index (ou de leur nom, en cas de groupes nommés) comme suit :

Dim group As Group = match.Groups(ctr)

Group group = match.Groups[ctr];

L'exemple suivant définit une expression régulière qui utilise des constructions de regroupement pour capturer le mois, jour et année d'une date.

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

Le modèle d'expression régulière \b(\w+)\s(\d{1,2}),\s(\d{4})\b est défini comme indiqué dans le tableau suivant.

Modèle	Description
\b	Commencez la correspondance à la limite d'un mot.
(\w+)	Mettre en correspondance un ou plusieurs caractères alphabétiques. Il s'agit du premier groupe de capture.
\s	Mettre en correspondance un espace blanc.
(\d{1,2})	Mettre en correspondance un ou deux chiffres décimaux. Il s'agit du deuxième groupe de capture.
,	Mettre en correspondance une virgule.
\s	Mettre en correspondance un espace blanc.
(\d{4})	Mettre en correspondance quatre chiffres décimaux. Il s'agit du troisième groupe de capture.
\b	Terminez la correspondance sur la limite d'un mot.

Retour au début

Groupe capturé

La classe Group représente le résultat d'un groupe de capture unique. Les objets de groupe qui représentent les groupes de capture définis dans une expression régulière sont retournés par la propriété Item de l'objet GroupCollection retourné par la propriété Match.Groups. La propriété Item est l'indexeur (en C#) et la propriété par défaut (en Visual Basic) de la classe Group. Vous pouvez également extraire des membres individuels en itérant au sein de la collection à l'aide de la construction foreach ou ForEach. Pour obtenir un exemple, consultez la section précédente.

L'exemple suivant utilise des constructions de regroupement imbriquées pour capturer des sous-chaînes dans des groupes. Le modèle d'expression régulière (a(b))c correspond à la chaîne « abc ». Il assigne la sous-chaîne « ab » au premier groupe de capture et la sous-chaîne « b » au deuxième groupe de capture.

 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 suivant utilise des constructions de regroupement nommées pour capturer des sous-chaînes d'une chaîne qui contient des données au format « DATANAME:VALUE », que l'expression régulière fractionne au niveau du 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

Le modèle d'expression régulière ^(?<name>\w+):(?<value>\w+) est défini comme indiqué dans le tableau suivant.

Modèle	Description
^	Commencer la correspondance au début de la chaîne d'entrée.
(?<name>\w+)	Mettre en correspondance un ou plusieurs caractères alphabétiques. Le nom de ce groupe de capture est name.
:	Mettre en correspondance un deux-points.
(?<value>\w+)	Mettre en correspondance un ou plusieurs caractères alphabétiques. Le nom de ce groupe de capture est value.

Les propriétés de la classe Group fournissent des informations à propos du groupe capturé : la propriété Group.Value contient la sous-chaîne capturée, la propriété Group.Index indique la position de départ du groupe capturé dans le texte d'entrée, la propriété Group.Length contient la longueur du texte capturé, et la propriété Group.Success indique si une sous-chaîne a correspondu au modèle défini par le groupe de capture.

L'application de quantificateurs à un groupe (pour plus d'informations, consultez Quantificateurs) modifie la relation d'une capture par groupe de capture de deux façons :

Si le quantificateur * ou *? (qui spécifie zéro, une ou plusieurs correspondances) est appliqué à un groupe, un groupe de capture peut ne pas avoir de correspondance dans la chaîne d'entrée. Lorsqu'il n'y a aucun texte capturé, les propriétés de l'objet Group sont définies comme indiqué dans le tableau suivant.

Propriété de groupe	Valeur
Success	false
Value	String.Empty
Length	0

L'exemple suivant illustre cette situation. Dans le modèle d'expression régulière aaa(bbb)*ccc, le premier groupe de capture (la sous-chaîne « bbb ») peut être mise en correspondance zéro, une ou plusieurs fois. Étant donné que la chaîne d'entrée « aaaccc » correspond au modèle, le groupe de capture n'a pas de correspondance.

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.

Les quantificateurs peuvent correspondre à plusieurs occurrences d'un modèle défini par un groupe de capture. Dans ce cas, les propriétés Value et Length d'un objet Group contiennent des informations uniquement à propos de la dernière sous-chaîne capturée. Par exemple, l'expression régulière suivante correspond à une phrase unique qui se termine avec un point. Elle utilise deux constructions de regroupement : la première capture des mots individuels avec un caractère d'espace blanc et la deuxième capture des mots individuels. Comme le montre la sortie de l'exemple, bien que l'expression régulière réussisse à capturer une phrase entière, le deuxième groupe de capture capture uniquement le dernier mot.

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

Retour au début

Collection de capture

L'objet Group contient des informations uniquement à propos de la dernière capture. Toutefois, l'ensemble des captures réalisées par un groupe de capture est toujours disponible à partir de l'objet CaptureCollection retourné par la propriété Group.Captures. Chaque membre de la collection est un objet Capture qui représente une capture effectuée par ce groupe de capture, dans l'ordre dans lequel elles ont été capturées (et, par conséquent, dans l'ordre dans lequel les chaînes capturées ont été mises en correspondance de gauche à droite dans la chaîne d'entrée). Vous pouvez extraire des objets Capture individuels de la collection de deux façons :

En itérant au sein de la collection à l'aide d'une construction telle que foreach (en C#) ou ForEach (en Visual Basic).
En utilisant la propriété CaptureCollection.Item pour extraire un objet spécifique en fonction de son index. La propriété Item est la propriété par défaut (en Visual Basic) ou l'indexeur (en C#) de l'objet CaptureCollection.

Si un quantificateur n'est pas appliqué à un groupe de capture, l'objet CaptureCollection contient un objet Capture unique qui présent peu d'intérêt, car il fournit des informations à propos de la même correspondance que son objet Group. Si un quantificateur est appliqué à un groupe de capture, l'objet CaptureCollection contient toutes les captures effectuées par le groupe de capture, et le dernier membre de la collection représente la même capture que l'objet Group.

Par exemple, si vous utilisez le modèle d'expression régulière ((a(b))c)+ (où le quantificateur + spécifie une ou plusieurs correspondances) pour capturer des correspondances à partir de la chaîne « abcabcabc », l'objet CaptureCollection pour chaque objet Group contient trois membres.

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

L'exemple suivant utilise l'expression régulière (Abc)+ pour rechercher un ou plusieurs passages consécutifs de la chaîne « Abc » dans la chaîne « XYZAbcAbcAbcXYZAbcAb ». Cet exemple illustre l'utilisation de la propriété Group.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

Retour au début

Capture individuelle

La classe Capture contient les résultats d'une seule capture de sous-expressions. La propriété Capture.Value contient le texte mis en correspondance, et la propriété Capture.Index indique la position basée sur zéro de la chaîne d'entrée à laquelle la sous-chaîne correspondante commence.

L'exemple suivant analyse une chaîne d'entrée pour la température de villes sélectionnées. Une virgule (« , ») est utilisée pour séparer une ville et sa température, et un point-virgule (« ; ») est utilisé pour séparer les données de chaque ville. La chaîne d'entrée entière représente une correspondance unique. Dans le modèle d'expression régulière ((\w+(\s\w+)*),(\d+);)+, utilisé pour analyser la chaîne, le nom de ville est assigné au deuxième groupe de capture et la température est assignée au quatrième groupe de capture.

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'expression régulière est définie comme indiqué dans le tableau suivant.

Modèle	Description
\w+	Mettre en correspondance un ou plusieurs caractères alphabétiques.
(\s\w+)*	Mettre en correspondance zéro, une ou plusieurs occurrences d'un caractère d'espace blanc suivi par un ou plusieurs caractères alphabétiques. Ce modèle correspond aux noms de villes à plusieurs mots. Il s'agit du troisième groupe de capture.
(\w+(\s\w+)*)	Mettre en correspondance un ou plusieurs caractères alphabétiques suivis par zéro, une ou plusieurs occurrences d'un caractère d'espace blanc et un ou plusieurs caractères alphabétiques. Il s'agit du deuxième groupe de capture.
,	Mettre en correspondance une virgule.
(\d+)	Mettre en correspondance un ou plusieurs chiffres. Il s'agit du quatrième groupe de capture.
;	Mettre en correspondance un point-virgule.
((\w+(\s\w+)*),(\d+);)+	Mettre en correspondance le modèle d'un mot suivi par des mots supplémentaires suivis par une virgule, un ou plusieurs chiffres et un point-virgule, une ou plusieurs fois. Il s'agit du premier groupe de capture.

Retour au début

Voir aussi

Référence

System.Text.RegularExpressions

Concepts

Expressions régulières du .NET Framework

Éléments du langage des expressions régulières

Modèle objet d'expression régulière

Moteur des expressions régulières

Mise en correspondance d'un modèle d'expression régulière

Extraction d'une correspondance unique ou de la première correspondance.

Extraction de toutes les correspondances

Remplacement d'une sous-chaîne correspondante

Fractionnement d'une chaîne unique dans un tableau de chaînes

Objets MatchCollection et Match

Collection Match

Match

Collection de groupe

Groupe capturé

Collection de capture

Capture individuelle

Voir aussi

Référence

Concepts

Ressources supplémentaires