Constructions de regroupement

  • Article

Les constructions de regroupement délimitent les sous-expressions d'une expression régulière et capturent les sous-chaînes d'une chaîne d'entrée. Vous pouvez utiliser des constructions de regroupement pour effectuer les opérations suivantes :

  • Mettre en correspondance une sous-expression répétée dans la chaîne d'entrée.

  • Appliquez un quantificateur à une sous-expression qui a plusieurs éléments de langage d'expression régulière. Pour plus d'informations sur les quantificateurs, consultez Quantificateurs.

  • Incluez une sous-expression dans la chaîne retournée par les méthodes Regex.Replace et Match.Result.

  • Récupérez des sous-expressions individuelles de la propriété Match.Groups et traitez-les indépendamment du texte correspondant global.

Le .NET Framework prend en charge les constructions de regroupement d'expressions régulières suivantes :

  • Sous-expressions mises en correspondance

  • Sous-expressions mises en correspondance nommées

  • Définitions de groupes d'équilibrage

  • Groupes sans capture

  • Options de groupe

  • Assertions de préanalyse positive de largeur nulle

  • Assertions de préanalyse négative de largeur nulle

  • Assertions de postanalyse positive de largeur nulle

  • Assertions de postanalyse négative de largeur nulle

  • Sous-expressions non rétroactives

  • Constructions de regroupement et objets d'expression régulière

Sous-expressions mises en correspondance

La construction de regroupement suivante capture une sous-expression mise en correspondance :

( sous-expression )

où sous-expression est tout modèle d'expression régulière valide. Les captures qui utilisent des parenthèses sont numérotées automatiquement de gauche à droite selon l'ordre des parenthèses ouvrantes dans l'expression régulière, en démarrant à partir d'un. La capture numérotée zéro est le texte mis en correspondance par le modèle d'expression régulière complet.

RemarqueRemarque

Si le paramètre RegexOptions d'une méthode d'expression régulière courante comprend l'indicateur RegexOptions.ExplicitCapture, ou si l'option n est appliquée à cette sous-expression (consultez Options de groupe plus loin dans cette rubrique), la sous-expression correspondante n'est pas capturée.

Vous pouvez accéder aux groupes capturés de quatre façons :

  • En utilisant la construction de référence arrière dans l'expression régulière. La sous-expression mise en correspondance est référencée dans la même expression régulière à l'aide de la syntaxe \nombre, où nombre est le nombre ordinal correspondant à la sous-expression capturée.

  • En utilisant la construction de référence arrière nommée dans l'expression régulière. La sous-expression mise en correspondance est référencée dans la même expression régulière à l'aide de la syntaxe \k<nombre>, où nombre est le nombre ordinal correspondant à la sous-expression capturée. La sous-expression capturée a un nom par défaut qui est identique à son nombre ordinal. Pour plus d'informations, consultez Sous-expressions mises en correspondance nommées plus loin dans cette rubrique.

  • En utilisant la séquence de remplacement $number dans un appel de méthode Regex.Replace ou Match.Result, où number est le nombre ordinal de la sous-expression capturée.

  • Par programme, en utilisant l'objet GroupCollection retourné par la propriété Match.Groups. Le membre situé à la position zéro dans la collection représente la correspondance d'expression régulière entière. Chaque membre suivant représente une sous-expression mise en correspondance. Pour plus d'informations, consultez la section Constructions de regroupement et objets d'expression régulière.

L'exemple suivant illustre une expression régulière qui identifie les mots dupliqués dans le texte. Les deux groupes de capture du modèle d'expression régulière représentent les deux instances du mot dupliqué. La deuxième instance est capturée pour signaler sa position de départ dans la chaîne d'entrée.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(\w+)\s(\1)\W"
      Dim input As String = "He said that that was the the correct answer."
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
         Console.WriteLine("Duplicate '{0}' found at positions {1} and {2}.", _
                           match.Groups(1).Value, match.Groups(1).Index, match.Groups(2).Index)
      Next
   End Sub
End Module
' The example displays the following output:
'       Duplicate 'that' found at positions 8 and 13.
'       Duplicate 'the' found at positions 22 and 26.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\w+)\s(\1)";
      string input = "He said that that was the the correct answer.";
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
         Console.WriteLine("Duplicate '{0}' found at positions {1} and {2}.", 
                           match.Groups[1].Value, match.Groups[1].Index, match.Groups[2].Index);
   }
}
// The example displays the following output:
//       Duplicate 'that' found at positions 8 and 13.
//       Duplicate 'the' found at positions 22 and 26.

Le modèle d'expression régulière est le suivant :

(\w+)\s(\1)\W

Le tableau suivant montre comment le modèle d'expression régulière est interprété.

Modèle

Description

(\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.

(\1)

Mettre en correspondance la chaîne dans le premier groupe capturé. Il s'agit du deuxième groupe de capture. L'exemple l'assigne à un groupe capturé afin que la position de départ du mot en double puisse être récupérée à partir de la propriété Match.Index.

\W

Mettre en correspondance un caractère non-alphabétique, notamment l'espace blanc et ponctuation. Cela empêche le modèle d'expression régulière de faire correspondre un mot qui commence par le mot du premier groupe capturé.

Sous-expressions mises en correspondance nommées

La construction de regroupement suivante capture une sous-expression mise en correspondance et vous permet d'y accéder par nom ou par numéro :

(?<name>subexpression)

ou :

(?'name' subexpression)

où nom est un nom de groupe valide, et sous-expression est tout modèle d'expression régulière valide. nom ne doit pas contenir de caractères de ponctuation et ne peut pas commencer par un nombre.

RemarqueRemarque

Si le paramètre RegexOptions d'une méthode d'expression régulière courante l'indicateur RegexOptions.ExplicitCapture, ou si l'option n est appliquée à cette sous-expression (consultez Options de groupe plus loin dans cette rubrique), la seule méthode pour capturer une sous-expression est de nommer des groupes de capture explicitement.

Vous pouvez accéder aux groupes capturés nommés des façons suivantes :

  • En utilisant la construction de référence arrière nommée dans l'expression régulière. La sous-expression correspondante est référencée dans la même expression régulière à l'aide de la syntaxe \k<name>, où name est le nom de la sous-expression capturée.

  • En utilisant la construction de référence arrière dans l'expression régulière. La sous-expression mise en correspondance est référencée dans la même expression régulière à l'aide de la syntaxe \nombre, où nombre est le nombre ordinal correspondant à la sous-expression capturée. Les sous-expressions mises en correspondance nommées sont numérotées consécutivement de gauche à droite après les sous-expressions mises en correspondance.

  • En utilisant la séquence de remplacement ${name} dans un appel de méthode Regex.Replace ou Match.Result, où name est le nom de la sous-expression capturée.

  • En utilisant la séquence de remplacement $number> dans un appel de méthode Regex.Replace ou Match.Result, où number est le nombre ordinateur de la sous-expression capturée.

  • Par programme, en utilisant l'objet GroupCollection retourné par la propriété Match.Groups. Le membre situé à la position zéro dans la collection représente la correspondance d'expression régulière entière. Chaque membre suivant représente une sous-expression mise en correspondance. Les groupes capturés nommés sont stockés dans la collection après les groupes capturés numérotés.

  • Par programme, en fournissant le nom de la sous-expression à l'indexeur de l'objet (en C#) GroupCollection ou à sa propriété Item (en Visual Basic).

Un modèle d'expression régulière simple illustre comment les groupes nommés et les groupes numérotés (sans nom) peuvent être référencés soit par programmation ou en utilisant la syntaxe du langage de l'expression régulière. L'expression régulière ((?<One>abc)\d+)?(?<Two>xyz)(.*) produit les groupes de capture suivants par numéro et par nom. Le premier groupe de capture (numéro 0) fait toujours référence au modèle entier.

Nombre

Nom

Modèle

0

0 (nom par défaut)

((?<One>abc)\d+)?(?<Two>xyz)(.*)

1

1 (nom par défaut)

((?<One>abc)\d+)

2

2 (nom par défaut)

(.*)

3

One

(?<One>abc)

4

Two

(?<Two>xyz)

L'exemple suivant illustre une expression régulière qui identifie les mots dupliqués et le mot qui suit immédiatement chaque mot dupliqué. Le modèle d'expression régulière définit deux sous-expressions nommées : duplicateWord, qui représente le mot dupliqué et nextWord, qui représente le mot suivant le mot dupliqué.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(?<duplicateWord>\w+)\s\k<duplicateWord>\W(?<nextWord>\w+)"
      Dim input As String = "He said that that was the the correct answer."
      Console.WriteLine(Regex.Matches(input, pattern, RegexOptions.IgnoreCase).Count)
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
         Console.WriteLine("A duplicate '{0}' at position {1} is followed by '{2}'.", _
                           match.Groups("duplicateWord").Value, match.Groups("duplicateWord").Index, _
                           match.Groups("nextWord").Value)
      Next
   End Sub
End Module
' The example displays the following output:
'    A duplicate 'that' at position 8 is followed by 'was'.
'    A duplicate 'the' at position 22 is followed by 'correct'.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(?<duplicateWord>\w+)\s\k<duplicateWord>\W(?<nextWord>\w+)";
      string input = "He said that that was the the correct answer.";
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
         Console.WriteLine("A duplicate '{0}' at position {1} is followed by '{2}'.", 
                           match.Groups["duplicateWord"].Value, match.Groups["duplicateWord"].Index, 
                           match.Groups["nextWord"].Value);

   }
}
// The example displays the following output:
//       A duplicate 'that' at position 8 is followed by 'was'.
//       A duplicate 'the' at position 22 is followed by 'correct'.

Le modèle d'expression régulière est défini comme suit :

(?<duplicateWord>\w+)\s\k<duplicateWord>\W(?<nextWord>\w+)

Le tableau suivant montre comment l'expression régulière est interprétée.

Modèle

Description

(?<duplicateWord>\w+)

Mettre en correspondance un ou plusieurs caractères alphabétiques. Nommez ce duplicateWord de groupe de capture.

\s

Mettre en correspondance un espace blanc.

\k<duplicateWord>

Mettre en correspondance la chaîne à partir du groupe capturé nommé duplicateWord.

\W

Mettre en correspondance un caractère non-alphabétique, notamment l'espace blanc et ponctuation. Cela empêche le modèle d'expression régulière de faire correspondre un mot qui commence par le mot du premier groupe capturé.

(?<nextWord>\w+)

Mettre en correspondance un ou plusieurs caractères alphabétiques. Nommez ce nextWord de groupe de capture.

Définitions de groupes d'équilibrage

Une définition de groupe d'équilibrage supprime la définition d'un groupe défini précédemment et stocke, dans le groupe actuel, l'intervalle entre le groupe précédemment défini et le groupe actuel. Cette construction de regroupement a le format suivant :

(?<name1-name2>subexpression)

ou :

(?'name1-name2' subexpression)

où nom1 est le groupe actuel (facultatif), , nom2 est un groupe défini précédemment, et sous-expression est tout modèle d'expression régulière valide. La définition de groupe d'équilibrage supprime la définition de nom2 et stocke l'intervalle entre nom2 et nom1 dans nom1. Si aucun groupe name2 n'est défini, la correspondance revient en arrière. Étant donné que la suppression de la dernière définition de name2 révèle la définition précédente de name2, cette construction vous permet d'utiliser la pile de saisies pour le groupe name2 comme un compteur pour effectuer le suivi de constructions imbriquées telles que les parenthèses ou des crochets ouvrants et fermants.

La définition de groupe d'équilibrage utilise nom2 comme pile. Le caractère de début de chaque construction imbriquée est placé dans le groupe et dans sa collection Group.Captures. Lorsque le caractère fermant est mis en correspondance, son caractère ouvrant correspondant est supprimé du groupe, et la collection Captures est diminuée de un. Une fois les caractères d'ouverture et de fermeture de toutes les constructions imbriquées mis en correspondance, name1 est vide.

RemarqueRemarque

Après avoir modifié l'expression régulière dans l'exemple suivant pour utiliser le caractère d'ouverture et de fermeture approprié d'une construction imbriquée, vous pouvez l'utiliser pour gérer la plupart des constructions imbriquées, telles que des expressions mathématiques ou des lignes de code du programme qui incluent plusieurs appels de méthode imbriqués.

L'exemple suivant utilise une définition de groupe d'équilibrage pour faire correspondre les crochets pointus droite et gauche (<>) dans une chaîne d'entrée. L'exemple définit deux groupes nommés, Open et Close, qui sont utilisés comme pile pour le suivi des paires correspondantes de signes « inférieur à » et « supérieur à ». Chaque crochet pointu gauche capturé est poussé dans la collection de captures du groupe Open, et chaque crochet pointu droit capturé est poussé dans la collection de captures du groupe Close. La définition de groupe d'équilibrage garantit qu'il existe un signe « supérieur à » correspondant pour chaque signe « inférieur à ». S'il n'y en a pas, le dernier subpattern, (?(Open)(?!)), est évalué uniquement si le groupe Open n'est pas vide (et, par conséquent, si toutes les constructions imbriquées n'ont pas été fermées). Si le dernier subpattern est évalué, la correspondance échoue, parce que la chaîne d'entrée ne doit pas contenir d'occurrences du ?!de sous-chaîne.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main() 
        Dim pattern As String = "^[^<>]*" & _
                                "(" + "((?'Open'<)[^<>]*)+" & _
                                "((?'Close-Open'>)[^<>]*)+" + ")*" & _
                                "(?(Open)(?!))$"
        Dim input As String = "<abc><mno<xyz>>"
        Dim rgx AS New Regex(pattern)'
        Dim m As Match = Regex.Match(input, pattern)
        If m.Success Then
            Console.WriteLine("Input: ""{0}"" " & vbCrLf & "Match: ""{1}""", _
                               input, m)
            Dim grpCtr As Integer = 0
            For Each grp As Group In m.Groups
               Console.WriteLine("   Group {0}: {1}", grpCtr, grp.Value)
               grpCtr += 1
               Dim capCtr As Integer = 0
               For Each cap As Capture In grp.Captures            
                  Console.WriteLine("      Capture {0}: {1}", capCtr, cap.Value)
                  capCtr += 1
               Next
            Next
        Else
            Console.WriteLine("Match failed.")
        End If
    End Sub
End Module  
' The example displays the following output:
'       Input: "<abc><mno<xyz>>"
'       Match: "<abc><mno<xyz>>"
'          Group 0: <abc><mno<xyz>>
'             Capture 0: <abc><mno<xyz>>
'          Group 1: <mno<xyz>>
'             Capture 0: <abc>
'             Capture 1: <mno<xyz>>
'          Group 2: <xyz
'             Capture 0: <abc
'             Capture 1: <mno
'             Capture 2: <xyz
'          Group 3: >
'             Capture 0: >
'             Capture 1: >
'             Capture 2: >
'          Group 4:
'          Group 5: mno<xyz>
'             Capture 0: abc
'             Capture 1: xyz
'             Capture 2: mno<xyz>

using System;
using System.Text.RegularExpressions;

class Example
{
   public static void Main() 
   {
      string pattern = "^[^<>]*" +
                       "(" + 
                       "((?'Open'<)[^<>]*)+" +
                       "((?'Close-Open'>)[^<>]*)+" +
                       ")*" +
                       "(?(Open)(?!))$";
      string input = "<abc><mno<xyz>>";

      Match m = Regex.Match(input, pattern);
      if (m.Success == true)
      {
         Console.WriteLine("Input: \"{0}\" \nMatch: \"{1}\"", input, m);
         int grpCtr = 0;
         foreach (Group grp in m.Groups)
         {
            Console.WriteLine("   Group {0}: {1}", grpCtr, grp.Value);
            grpCtr++;
            int capCtr = 0;
            foreach (Capture cap in grp.Captures)
            {            
                Console.WriteLine("      Capture {0}: {1}", capCtr, cap.Value);
                capCtr++;
            }
          }
      }
      else
      {
         Console.WriteLine("Match failed.");
      }   
    }
}
// The example displays the following output:
//    Input: "<abc><mno<xyz>>"
//    Match: "<abc><mno<xyz>>"
//       Group 0: <abc><mno<xyz>>
//          Capture 0: <abc><mno<xyz>>
//       Group 1: <mno<xyz>>
//          Capture 0: <abc>
//          Capture 1: <mno<xyz>>
//       Group 2: <xyz
//          Capture 0: <abc
//          Capture 1: <mno
//          Capture 2: <xyz
//       Group 3: >
//          Capture 0: >
//          Capture 1: >
//          Capture 2: >
//       Group 4:
//       Group 5: mno<xyz>
//          Capture 0: abc
//          Capture 1: xyz
//          Capture 2: mno<xyz>

Le modèle d'expression régulière est le suivant :

^[^<>]*(((?'Open'<)[^<>]*)+((?'Close-Open'>)[^<>]*)+)*(?(Open)(?!))$

L'expression régulière est interprétée comme suit :

Modèle

Description

^

Commencez au début de la chaîne.

[^<>]*

Mettre en correspondance zéro, un ou plusieurs caractères qui ne sont pas des crochets pointus droit ou gauche.

(?'Open'<)

Mettre en correspondance un crochet pointu et assignez-le à un groupe nommé Open.

[^<>]*

Mettre en correspondance zéro, un ou plusieurs caractères qui ne sont pas des crochets pointus droit ou gauche.

((?'Open'<)[^<>]*) +

Mettre en correspondance une ou plusieurs occurrences d'un croche pointu gauche suivies par zéro, un ou plusieurs caractères qui ne sont pas des crochets pointus gauches ou droits. Il s'agit du deuxième groupe de capture.

(?'Close-Open'>)

Mettre en correspondance un crochet pointu droit, assignez la sous-chaîne entre le groupe Open et le groupe actuel au groupe Close et supprimez la définition du groupe Open.

[^<>]*

Mettre en correspondance zéro, une ou plusieurs occurrences de n'importe quel caractère qui n'est pas un crochet pointu gauche ou droit.

((?'Close-Open'>)[^<>]*)+

Mettre en correspondance une ou plusieurs occurrences d'un crochet pointu droit, suivis par zéro, une ou plusieurs occurrences de n'importe quel caractère qui n'est pas un crochet pointu gauche ou droit. Lors de la mise en correspondance du signe supérieur, assignez la sous-chaîne entre le groupe Open et le groupe actuel au groupe Close et supprimez la définition du groupe Open. Il s'agit du troisième groupe de capture.

(((?'Open'<)[^<>]*)+((?'Close-Open'>)[^<>]*)+)*

Mettre en correspondance zéro ou plusieurs occurrences du modèle suivant : une ou plusieurs occurrences d'un crochet pointu gauche, suivies par zéro ou plusieurs crochets non-pointus, suivis par une ou plusieurs occurrences d'un crochet pointu droit, suivies par zéro ou plusieurs occurrences de crochets non pointus. Lors de la mise en correspondance du signe supérieur, supprimez la définition du groupe Open et assignez la sous-chaîne entre le groupe Open et le groupe actuel au groupe Close. Il s'agit du premier groupe de capture.

(?(Open)(?!))

Si le groupe Open existe, faire correspondre un point d'interrogation et un point d'exclamation. Si le groupe Open est défini, la correspondance échoue, ce qui indique que les crochets pointus ne sont pas équilibrés.

$

Mettre en correspondance la fin de la chaîne d'entrée.

La dernière sous-expression, (?(Open)(?!)), indique si les constructions d'imbrication de la chaîne d'entrée sont correctement équilibrées (par exemple, si chaque signe « inférieur à » correspond à un signe « supérieur à »). Il utilise la mise en correspondance conditionnelle basée sur un groupe capturé valide ; pour plus d'informations, consultez Constructions d'alternative. Si le groupe Open est défini, le moteur des expressions régulières essaie de faire correspondre la sous-expression (?!) dans la chaîne d'entrée. Le groupe Open doit être défini uniquement si les constructions d'imbrication sont déséquilibrées. Par conséquent, le modèle à faire correspondre dans la chaîne d'entrée doit être un modèle qui ne peut pas se produire dans la chaîne d'entrée, ce qui provoque l'échec de la correspondance.

Dans l'exemple, le moteur des expressions régulières évalue la chaîne d'entrée « <abc><mno<xyz>> » comme indiqué dans le tableau suivant.

Étape

Modèle

Résultat

1

^

Commence la correspondance au début de la chaîne d'entrée

2

[^<>]*

Recherche des crochets non pointus avant le crochet pointu gauche ; ne trouve rien.

3

(((?'Open'<)

Correspond au crochet pointu gauche « <abc> » et l'assigne au groupe Open.

4

[^<>]*

Correspond à « abc ».

5

)+

« <abc> »est la valeur du second groupe capturé.

Le caractère suivant dans la chaîne d'entrée n'est pas un signe « inférieur à », donc le moteur des expressions régulières ne retourne pas en boucle au sous-modèle (?'Open'<)[^<>]*).

6

((?'Close-Open'>)

Correspond au crochet pointu droit dans « <abc> », assigne « abc », qui est la sous-chaîne entre le groupe Open et le crochet pointu droit, au groupe Close, et supprime la valeur actuelle (« < ») du groupe Open, en le laissant vide.

7

[^<>]*

Recherche des crochets non pointus après le crochet pointu droit , ne trouve rien.

8

)+

La valeur du troisième groupe capturé est « > ».

Le caractère suivant de la chaîne d'entrée n'est pas un signe « supérieur à » ; par conséquent, le moteur des expressions régulières ne retourne pas en boucle au sous-modèle ((?'Close-Open'>)[^<>]*).

9

)*

La valeur du premier group capturé est « <abc> ».

Le caractère suivant de la chaîne d'entrée est un signe « inférieur à » ; par conséquent, le moteur des expressions régulières retourne en boucle au sous-modèle (((?'Open'<).

10

(((?'Open'<)

Correspond au crochet pointu gauche « <mno> » et l'assigne au groupe Open. Sa collection Group.Captures a désormais une valeur unique, « < ».

11

[^<>]*

Correspond à « mno ».

12

)+

« <mno> »est la valeur du second groupe capturé.

Le caractère suivant de la chaîne d'entrée est un signe « inférieur à » ; par conséquent, le moteur des expressions régulières retourne en boucle au sous-modèle (?'Open'<)[^<>]*).

13

(((?'Open'<)

Correspond au crochet pointu gauche « <xyz> » et l'assigne au groupe Open. La collection Group.Captures du groupe Open inclut désormais deux captures : le croche pointu gauche de « <mno> », et le crochet pointu gauche de « <xyz> ».

14

[^<>]*

Correspond à « xyz ».

15

)+

« <xyz> »est la valeur du second groupe capturé.

Le caractère suivant dans la chaîne d'entrée n'est pas un signe « inférieur à », donc le moteur des expressions régulières ne retourne pas en boucle au sous-modèle (?'Open'<)[^<>]*).

16

((?'Close-Open'>)

Correspond au crochet pointu droit dans « <xyz> ». " xyz », assigne la sous-chaîne entre le groupe Open et le signe « supérieur à » au groupe Close et supprime la valeur actuelle du groupe Open. La valeur de la capture précédente (le crochet pointu gauche dans « <mno> ») devient la valeur actuelle du groupe Open. La collection Captures du groupe Open inclut désormais une capture unique, le crochet pointu gauche de « <xyz> ».

17

[^<>]*

Recherche des crochets non pointus ; ne trouve rien.

18

)+

La valeur du troisième groupe capturé est « > ».

Le caractère suivant de la chaîne d'entrée est un signe « supérieur à » ; par conséquent, le moteur des expressions régulières retourne en boucle au sous-modèle ((?'Close-Open'>)[^<>]*).

19

((?'Close-Open'>)

Correspond au crochet pointu droit dans « xyz », assigne « mno<xyz » (la sous-chaîne entre le groupe Open et le crochet pointu droit) au groupe Close et supprime la valeur actuelle du groupe Open. Le groupe Open est maintenant vide.

20

[^<>]*

Recherche des crochets non pointus ; ne trouve rien.

21

)+

La valeur du troisième groupe capturé est « > ».

Le caractère suivant de la chaîne d'entrée n'est pas un signe « supérieur à » ; par conséquent, le moteur des expressions régulières ne retourne pas en boucle au sous-modèle ((?'Close-Open'>)[^<>]*).

22

)*

La valeur du premier group capturé est « <mnoc<xyz>> ».

Le caractère suivant dans la chaîne d'entrée n'est pas un signe « inférieur à », donc le moteur des expressions régulières ne retourne pas en boucle au sous-modèle (((?'Open'<).

23

(?(Open)(?!))

Le groupe Open n'est pas défini ; par conséquent, aucune recherche de correspondance n'est effectuée.

24

$

Correspond à la fin de la chaîne d'entrée.

Groupes sans capture

La construction de regroupement suivante ne capture pas la sous-chaîne correspondant à une sous-expression :

(?:subexpression)

où sous-expression est tout modèle d'expression régulière valide. La construction de groupe sans capture est généralement utilisée lorsqu'un quantificateur est appliqué à un groupe, mais que les sous-chaînes capturées par le groupe ne présentent pas d'intérêt.

RemarqueRemarque

Si une expression régulière inclut des constructions de regroupement imbriquées, une construction de groupe sans capture externe ne s'applique pas aux constructions de groupe imbriquées internes.

L'exemple suivant illustre une expression régulière qui inclut des groupes sans capture. Notez que la sortie n'inclut pas de groupes capturés.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(?:\b(?:\w+)\W*)+\."
      Dim input As String = "This is a short sentence."
      Dim match As Match = Regex.Match(input, pattern)
      Console.WriteLine("Match: {0}", match.Value)
      For ctr As Integer = 1 To match.Groups.Count - 1
         Console.WriteLine("   Group {0}: {1}", ctr, match.Groups(ctr).Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       Match: This is a short sentence.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(?:\b(?:\w+)\W*)+\.";
      string input = "This is a short sentence.";
      Match match = Regex.Match(input, pattern);
      Console.WriteLine("Match: {0}", match.Value);
      for (int ctr = 1; ctr < match.Groups.Count; ctr++)
         Console.WriteLine("   Group {0}: {1}", ctr, match.Groups[ctr].Value);
   }
}
// The example displays the following output:
//       Match: This is a short sentence.

L'expression régulière (?:\b(?:\w+)\W*)+\. correspond à une phrase terminée par un point. Parce que l'expression régulière se concentre sur les phrases et pas sur les mots individuels, les constructions de regroupement sont utilisées exclusivement comme quantificateurs. Le modèle d'expression régulière est interprété 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. N'assignez pas le texte correspondant à un groupe capturé.

\W*

Mettre en correspondance zéro ou davantage de caractères non-alphabétiques.

(?:\b(?:\w+)\W*)+

Mettre en correspondance le modèle d'un ou plusieurs caractères alphabétiques qui démarrent à une limite de mot, suivis par zéro, un ou plusieurs caractères non alphabétiques, une ou plusieurs fois. N'assignez pas le texte correspondant à un groupe capturé.

\.

Mettre en correspondance un point.

Options de groupe

La construction de regroupement suivante applique ou désactive les options spécifiées dans une sous-expression :

(?imnsx-imnsx: sous-expression )

où sous-expression est tout modèle d'expression régulière valide. Par exemple, (?i-s:) active le non-respect de la casse et désactive le mode ligne simple. Pour plus d'informations sur les options inline que vous pouvez spécifier, consultez Options des expressions régulières.

RemarqueRemarque

Vous pouvez spécifier des options qui s'appliquent à une expression régulière entière plutôt qu'à une sous-expression en utilisant un constructeur de classe System.Text.RegularExpressions.Regex ou une méthode statique.Vous pouvez également spécifier des options inline qui s'appliquent après un point spécifique dans une expression régulière à l'aide de la construction de langage (?imnsx-imnsx).

La construction d'options de groupe n'est pas un groupe de capture. Autrement dit, bien que toute partie d'une chaîne capturée par sous-expression soit incluse dans la correspondance, elle n'est pas incluse dans un groupe capturé ni utilisé pour remplir l'objet GroupCollection.

Par exemple, l'expression régulière \b(?ix: d \w+)\s dans l'exemple suivant utilise des options inline dans une construction de regroupement pour permettre la correspondance non sensible à la casse et ignorer l'espace blanc de modèle pour l'identification de tous les mots qui commencent par la lettre « d ». L'expression régulière est définie comme indiqué dans le tableau suivant.

Modèle

Description

\b

Commencez la correspondance à la limite d'un mot.

(?ix: d \w+)

À l'aide de la mise en correspondance qui ne respecte pas la casse et en ignorant les espaces blancs dans ce modèle, faites correspondre un « d » suivi d'un ou de plusieurs caractères alphabétiques.

\s

Mettre en correspondance un espace blanc.

 
Dim pattern As String = "\b(?ix: d \w+)\s"
Dim input As String = "Dogs are decidedly good pets."

For Each match As Match In Regex.Matches(input, pattern)
   Console.WriteLine("'{0}' found at index {1}.", match.Value, match.Index)
Next
' The example displays the following output:
'    'Dogs ' found at index 0.
'    'decidedly ' found at index 9.      

string pattern = @"\b(?ix: d \w+)\s";
string input = "Dogs are decidedly good pets.";

foreach (Match match in Regex.Matches(input, pattern))
   Console.WriteLine("'{0}// found at index {1}.", match.Value, match.Index);
// The example displays the following output:
//    'Dogs // found at index 0.
//    'decidedly // found at index 9.

Assertions de préanalyse positive de largeur nulle

La construction de regroupement suivante définit une assertion de préanalyse positive de largeur nulle :

(?= sous-expression )

où subexpression est n'importe quel modèle d'expression régulière. Pour qu'une correspondance soit réussie, la chaîne d'entrée doit correspondre au modèle d'expression régulière dans la sous-expression, bien que la sous-chaîne correspondante ne soit pas incluse dans le résultat de correspondance. Une assertion de préanalyse positive de largeur nulle ne revient pas en arrière.

En général, une assertion de préanalyse positive de largeur nulle figure à la fin d'un modèle d'expression régulière. Il définit une sous-chaîne qui doit être trouvée à la fin d'une chaîne pour une correspondance pour se produire mais cela ne doit pas être inclus dans la correspondance. C'est également utile pour empêcher une rétroaction excessive. Vous pouvez utiliser une assertion de préanalyse positive de largeur nulle pour garantir qu'un groupe capturé particulier commence avec le texte qui correspond à un sous-ensemble du modèle défini pour ce groupe capturé. Par exemple, si un groupe de capture correspond aux caractères alphabétiques consécutifs, vous pouvez utiliser une assertion de préanalyse positive de largeur nulle pour demander à ce que le premier caractère soit obligatoirement une majuscule alphabétique.

L'exemple suivant utilise une assertion de préanalyse positive de largeur nulle pour établir une correspondance avec le mot qui précède le verbe "is" dans la chaîne d'entrée.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\w+(?=\sis\b)"
      Dim inputs() As String = { "The dog is a Malamute.", _
                                 "The island has beautiful birds.", _
                                 "The pitch missed home plate.", _
                                 "Sunday is a weekend day." }

      For Each input As String In inputs
         Dim match As Match = Regex.Match(input, pattern)
         If match.Success Then
            Console.WriteLine("'{0}' precedes 'is'.", match.Value)
         Else
            Console.WriteLine("'{0}' does not match the pattern.", input) 
         End If     
      Next
   End Sub
End Module
' The example displays the following output:
'       'dog' precedes 'is'.
'       'The island has beautiful birds.' does not match the pattern.
'       'The pitch missed home plate.' does not match the pattern.
'       'Sunday' precedes 'is'.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+(?=\sis\b)";
      string[] inputs = { "The dog is a Malamute.", 
                          "The island has beautiful birds.", 
                          "The pitch missed home plate.", 
                          "Sunday is a weekend day." };

      foreach (string input in inputs)
      {
         Match match = Regex.Match(input, pattern);
         if (match.Success)
            Console.WriteLine("'{0}' precedes 'is'.", match.Value);
         else
            Console.WriteLine("'{0}' does not match the pattern.", input); 
      }
   }
}
// The example displays the following output:
//    'dog' precedes 'is'.
//    'The island has beautiful birds.' does not match the pattern.
//    'The pitch missed home plate.' does not match the pattern.
//    'Sunday' precedes 'is'.

L'expression régulière \b\w+(?=\sis\b) est interprétée 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.

(?=\sis\b)

Déterminez si les caractères alphabétiques sont suivis par un caractère d'espace blanc et la chaîne « is », qui termine sur une limite de mot. Si tel est le cas, la correspondance est réussie.

Assertions de préanalyse négative de largeur nulle

La construction de regroupement suivante définit une assertion de préanalyse négative de largeur nulle :

(?! sous-expression )

où subexpression est n'importe quel modèle d'expression régulière. Pour que la correspondance soit réussie, la chaîne d'entrée ne doit pas correspondre au modèle d'expression régulière dans sous-expression, bien que la chaîne correspondante ne soit pas incluse dans le résultat de correspondance.

Une assertion anticipative négative de largeur nulle est utilisée en général soit au début soit à la fin d'une expression régulière. Au début d'une expression régulière, il peut définir un modèle spécifique auquel ne doit pas être mis en correspondance lorsque le début de l'expression régulière définit un modèle semblable mais plus général à mettre en correspondance. Dans ce cas, il est souvent utilisé pour restreindre la rétroaction. À la fin d'une expression régulière, il peut définir une sous-expression qui ne peut pas se produire à la fin d'une correspondance.

L'exemple suivant définit une expression régulière qui utilise en position initiale une assertion de préanalyse de largeur nulle pour établir une correspondance avec les mots qui ne commencent pas par « un ».

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b(?!un)\w+\b"
      Dim input As String = "unite one unethical ethics use untie ultimate"
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
         Console.WriteLine(match.Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       one
'       ethics
'       use
'       ultimate

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(?!un)\w+\b";
      string input = "unite one unethical ethics use untie ultimate";
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       one
//       ethics
//       use
//       ultimate

L'expression régulière \b(?!un)\w+\b est interprétée comme indiqué dans le tableau suivant.

Modèle

Description

\b

Commencez la correspondance à la limite d'un mot.

(?!un)

Déterminez si les deux caractères suivants sont « un ». S'ils ne le sont pas, une correspondance est possible.

\w+

Mettre en correspondance un ou plusieurs caractères alphabétiques.

\b

Terminez la correspondance à la limite d'un mot.

L'exemple suivant définit une expression régulière qui utilise en position finale une assertion de préanalyse de largeur nulle pour établir une correspondance avec les mots qui ne se terminent pas par un caractère de ponctuation.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\w+\b(?!\p{P})"
      Dim input As String = "Disconnected, disjointed thoughts in a sentence fragment."
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
      Next   
   End Sub
End Module
' The example displays the following output:
'       disjointed
'       thoughts
'       in
'       a
'       sentence

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+\b(?!\p{P})";
      string input = "Disconnected, disjointed thoughts in a sentence fragment.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       disjointed
//       thoughts
//       in
//       a
//       sentence

L'expression régulière \b\w+\b(?!\p{P}) est interprétée 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.

\b

Terminez la correspondance à la limite d'un mot.

\p{P})

Si le caractère suivant n'est pas un symbole de ponctuation (tel qu'un point ou une virgule), la correspondance réussit.

Assertions de postanalyse positive de largeur nulle

La construction de regroupement suivante définit une assertion de postanalyse positive de largeur nulle :

(?<= sous-expression )

où subexpression est n'importe quel modèle d'expression régulière. Pour qu'une correspondance soit réussie, la sous-expression doit se produire à la chaîne d'entrée à gauche de la position actuelle, bien que subexpression ne soit pas inclus dans le résultat de correspondance. Une assertion de lookbehind positive de largeur nulle ne revient pas en arrière.

Les assertions de postanalyse positives de largeur nulle sont utilisées en général au début d'expressions régulières. Le modèle qu'ils définissent est une condition préalable pour une correspondance, bien qu'il ne fasse pas partie du résultat de la mise en correspondance.

Par exemple, l'exemple suivant correspond en premier aux deux derniers chiffres de l'année pour le vingtième siècle (autrement dit, il requiert que le chiffre « 20 » précède la chaîne correspondante).

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "2010 1999 1861 2140 2009"
      Dim pattern As String = "(?<=\b20)\d{2}\b"

      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
      Next      
   End Sub
End Module
' The example displays the following output:
'       10
'       09

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "2010 1999 1861 2140 2009";
      string pattern = @"(?<=\b20)\d{2}\b";

      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       10
//       09

Le modèle d'expression régulière (?<=\b20)\d{2}\b est interprété comme indiqué dans le tableau suivant.

Modèle

Description

\d{2}

Mettre en correspondance deux chiffres décimaux.

{?<=\b20)

Continuez la correspondance si les deux chiffres décimaux sont précédés par les chiffres décimaux « 20 » sur une limite de mot.

\b

Terminez la correspondance à la limite d'un mot.

Les assertions postanalyse positives de largeur nulle sont également utilisées pour limiter la rétroaction lorsque le ou les derniers caractères du groupe capturé doivent être un sous-ensemble des caractères qui correspondent au modèle d'expression régulière de ce groupe. Par exemple, si un groupe capture tous les caractères alphabétiques consécutifs, vous pouvez utiliser une assertion de postanalyse positive de largeur nulle pour demander à ce que le dernier caractère soit obligatoirement alphabétique.

Assertions de postanalyse négative de largeur nulle

La construction de regroupement suivante définit une assertion de postanalyse négative de largeur nulle :

(?<! sous-expression )

où subexpression est n'importe quel modèle d'expression régulière. Pour qu'une correspondance soit réussie, la sous-expression ne doit pas se produire à la chaîne d'entrée à gauche de la position actuelle. Toutefois, toute sous-chaîne qui ne correspond pas subexpression n'est pas incluse dans le résultat de correspondance.

Les assertions de postanalyse négatives de largeur nulle sont utilisées en général au début d'expressions régulières. Le modèle qu'ils définissent exclut une correspondance dans la chaîne qui suit. Elles sont également utilisées pour réduire la rétroaction lorsque le ou les derniers caractères d'un groupe capturé ne doivent pas correspondre à un ou plusieurs des caractères qui correspondent au modèle d'expression régulière de ce groupe. Par exemple, si un groupe capture tous les caractères alphabétiques consécutifs, vous pouvez utiliser une assertion de postanalyse positive de largeur nulle pour demander à ce que le dernier caractère ne soit pas un trait de soulignement (_).

L'exemple suivant fait correspondre la date associée à n'importe quel jour de la semaine qui n'est pas un week-end (autrement dit, qui ne correspond ni à un samedi, ni à un dimanche).

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim dates() As String = { "Monday February 1, 2010", _
                                "Wednesday February 3, 2010", _
                                "Saturday February 6, 2010", _
                                "Sunday February 7, 2010", _
                                "Monday, February 8, 2010" }
      Dim pattern As String = "(?<!(Saturday|Sunday) )\b\w+ \d{1,2}, \d{4}\b"

      For Each dateValue As String In dates
         Dim match As Match = Regex.Match(dateValue, pattern)
         If match.Success Then
            Console.WriteLine(match.Value)
         End If   
      Next      
   End Sub
End Module
' The example displays the following output:
'       February 1, 2010
'       February 3, 2010
'       February 8, 2010

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] dates = { "Monday February 1, 2010", 
                         "Wednesday February 3, 2010", 
                         "Saturday February 6, 2010", 
                         "Sunday February 7, 2010", 
                         "Monday, February 8, 2010" };
      string pattern = @"(?<!(Saturday|Sunday) )\b\w+ \d{1,2}, \d{4}\b";

      foreach (string dateValue in dates)
      {
         Match match = Regex.Match(dateValue, pattern);
         if (match.Success)
            Console.WriteLine(match.Value);
      }      
   }
}
// The example displays the following output:
//       February 1, 2010
//       February 3, 2010
//       February 8, 2010

Le modèle d'expression régulière (?<!(Saturday|Sunday) )\b\w+ \d{1,2}, \d{4}\b est interprété 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 suivis d'un espace.

\d{1,2},

Mettre en correspondance un ou deux chiffres décimaux suivis par un caractère d'espace blanc et une virgule.

\d{4}\b

Mettre en correspondance quatre chiffres décimaux et terminez la correspondance à une limite de mot.

(?<!(Saturday|Sunday) )

Si la correspondance est précédée par quelque chose autre que les chaînes « samedi » ou « dimanche » suivi par un espace, la correspondance est réussie.

Sous-expressions non rétroactives

La construction de regroupement suivante représente une sous-expression non rétroactive (également appelée sous-expression « gourmande ») :

(?> sous-expression )

où subexpression est n'importe quel modèle d'expression régulière.

Habituellement, si une expression régulière inclut un modèle de correspondance facultatif ou de remplacement et qu'une mise en correspondance échoue, le moteur des expressions régulières peut créer des branches dans plusieurs directions pour faire correspondre une chaîne d'entrée avec un modèle. Si une correspondance est introuvable lorsqu'il prend la première branche, le moteur des expressions régulières peut revenir en arrière au point où il a pris la première correspondance et tente la correspondance à l'aide de la deuxième branche. Ce processus peut continuer jusqu'à ce que toutes les branches aient été essayées.

La construction de langage (?>sous-expression) désactive la rétroaction. Le moteur des expressions régulières fera correspondre autant de caractères de la chaîne d'entrée que possible. Lorsqu'aucune autre correspondance n'est possible, il n'effectue pas de recherches rétroactives pour tenter d'autres correspondances de modèle. (C'est-à-dire , la sous-expression correspond uniquement aux chaînes auxquelles correspondraient la sous-expression seule ; il n'essaie pas de faire correspondre une chaîne selon la sous-expression et une sous-expression qui suit.)

Cette option est recommandée si vous savez que la rétroaction ne réussira pas. En empêchant le moteur des expressions régulières d'exécuter des recherches inutiles, vous améliorez les performances.

L'exemple suivant montre comment une sous-expression non rétroactive modifie les résultats d'une correspondance de modèle. L'expression régulière de rétroaction correspond à une série de caractères répétés, suivis d'une occurrence supplémentaire du même caractère sur une limite de mot, ce qui n'est pas le cas de l'expression régulière non rétroactive.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim inputs() As String = { "cccd.", "aaad", "aaaa" }
      Dim back As String = "(\w)\1+.\b"
      Dim noback As String = "(?>(\w)\1+).\b"

      For Each input As String In inputs
         Dim match1 As Match = Regex.Match(input, back)
         Dim match2 As Match = Regex.Match(input, noback)
         Console.WriteLine("{0}: ", input)

         Console.Write("   Backtracking : ")
         If match1.Success Then
            Console.WriteLine(match1.Value)
         Else
            Console.WriteLine("No match")
         End If

         Console.Write("   Nonbacktracking: ")
         If match2.Success Then
            Console.WriteLine(match2.Value)
         Else
            Console.WriteLine("No match")
         End If
      Next
   End Sub
End Module
' The example displays the following output:
'    cccd.:
'       Backtracking : cccd
'       Nonbacktracking: cccd
'    aaad:
'       Backtracking : aaad
'       Nonbacktracking: aaad
'    aaaa:
'       Backtracking : aaaa
'       Nonbacktracking: No match

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] inputs = { "cccd.", "aaad", "aaaa" };
      string back = @"(\w)\1+.\b";
      string noback = @"(?>(\w)\1+).\b";

      foreach (string input in inputs)
      {
         Match match1 = Regex.Match(input, back);
         Match match2 = Regex.Match(input, noback);
         Console.WriteLine("{0}: ", input);

         Console.Write("   Backtracking : ");
         if (match1.Success)
            Console.WriteLine(match1.Value);
         else
            Console.WriteLine("No match");

         Console.Write("   Nonbacktracking: ");
         if (match2.Success)
            Console.WriteLine(match2.Value);
         else
            Console.WriteLine("No match");
      }
   }
}
// The example displays the following output:
//    cccd.:
//       Backtracking : cccd
//       Nonbacktracking: cccd
//    aaad:
//       Backtracking : aaad
//       Nonbacktracking: aaad
//    aaaa:
//       Backtracking : aaaa
//       Nonbacktracking: No match

L'expression régulière nonbacktracking, (?>(\w)\1+).\b, est définie comme indiquée dans le tableau suivant.

Modèle

Description

(\w)

Mettre en correspondance un caractère alphabétique et l'assigner au premier groupe de capture.

\1+

Mettre en correspondance la valeur des premières sous-chaînes capturées une ou plusieurs fois.

.

Mettre en correspondance n'importe quel caractère.

\b

Terminez la correspondance sur la limite d'un mot.

(?>(\w)\1+)

Mettre en correspondance une ou plusieurs occurrences d'un caractère alphabétique dupliqué, mais ne revenez pas en arrière pour faire correspondre au dernier caractère sur une limite de mot.

Constructions de regroupement et objets d'expression régulière

Les sous-chaînes mises en correspondance par un groupe de capture d'expression régulière sont représentées par les objets System.Text.RegularExpressions.Group, qui peuvent être récupérés dans l'objet System.Text.RegularExpressions.GroupCollection retourné par la propriété Match.Groups. L'objet GroupCollection est rempli comme suit :

  • Le premier objet Group de la collection (objet situé à l'index zéro) représente la correspondance entière.

  • L'ensemble suivant d'objets Group représente des groupes de capture sans nom (numérotés). Ils s'affichent dans l'ordre dans lequel ils sont définis dans l'expression régulière, de gauche à droite. Les valeurs d'index de ces groupes sont comprises entre 1 et le nombre de groupes de capture sans nom présents dans la collection. (L'index d'un groupe particulier est équivalent à sa référence arrière numérotée. Pour plus d'informations sur les backreferences, consultez Constructions de backreference).

  • Le dernier ensemble d'objets Group représente des groupes de capture nommés. Ils s'affichent dans l'ordre dans lequel ils sont définis dans l'expression régulière, de gauche à droite. La valeur d'index du premier groupe de capture nommé est supérieure d'une unité à l'index du dernier groupe de capture sans nom. S'il n'y a pas de groupes de capture sans nom dans l'expression régulière, la valeur d'index du premier groupe de capture nommé est nulle.

Si vous appliquez un quantificateur à un groupe de capture, les propriétés Capture.Value, Capture.Index et Capture.Length de l'objet correspondant Group reflètent la dernière sous-chaîne capturée par un groupe de capture. Vous pouvez extraire un jeu complet des sous-chaînes capturées par les groupes qui ont des quantificateurs à partir de l'objet CaptureCollection retourné par la propriété Group.Captures.

L'exemple suivant clarifie la relation entre les objets Group et Capture.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(\b(\w+)\W+)+"
      Dim input As String = "This is a short sentence."
      Dim match As Match = Regex.Match(input, pattern)
      Console.WriteLine("Match: {0}", match.Value)
      For ctr As Integer = 1 To match.Groups.Count - 1
         Console.WriteLine("   Group {0}: {1}", ctr, match.Groups(ctr).Value)
         Dim capCtr As Integer = 0
         For Each capture As Capture In match.Groups(ctr).Captures
            Console.WriteLine("      Capture {0}: {1}", capCtr, capture.Value)
            capCtr += 1
         Next
      Next
   End Sub
End Module
' The example displays the following output:
'       Match: This is a short sentence.
'          Group 1: sentence.
'             Capture 0: This
'             Capture 1: is
'             Capture 2: a
'             Capture 3: short
'             Capture 4: sentence.
'          Group 2: sentence
'             Capture 0: This
'             Capture 1: is
'             Capture 2: a
'             Capture 3: short
'             Capture 4: sentence

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\b(\w+)\W+)+";
      string input = "This is a short sentence.";
      Match match = Regex.Match(input, pattern);
      Console.WriteLine("Match: {0}", match.Value);
      for (int ctr = 1; ctr < match.Groups.Count; ctr++)
      {
         Console.WriteLine("   Group {0}: {1}", ctr, match.Groups[ctr].Value);
         int capCtr = 0;
         foreach (Capture capture in match.Groups[ctr].Captures)
         {
            Console.WriteLine("      Capture {0}: {1}", capCtr, capture.Value);
            capCtr++;
         }
      }
   }
}
// The example displays the following output:
//       Match: This is a short sentence.
//          Group 1: sentence.
//             Capture 0: This
//             Capture 1: is
//             Capture 2: a
//             Capture 3: short
//             Capture 4: sentence.
//          Group 2: sentence
//             Capture 0: This
//             Capture 1: is
//             Capture 2: a
//             Capture 3: short
//             Capture 4: sentence

Le modèle d'expression régulière \b(\w+)\W+)+ extrait des mots individuels d'une chaîne. Il 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. Ensemble, ces caractères forment un mot. Il s'agit du deuxième groupe de capture.

\W+

Mettre en correspondance un ou plusieurs caractères non alphabétiques.

(\w+)\W+)+

Mettre en correspondance un ou plusieurs caractères alphabétiques suivis par un ou plusieurs caractères non alphabétiques une ou plusieurs fois. Il s'agit du premier groupe de capture.

Le premier groupe de capture établit une correspondance avec chaque mot de la phrase. Le deuxième groupe de capture établit une correspondance avec chaque mot, accompagné de la ponctuation et de l'espace blanc qui le suivent. L'objet Group dont l'index est 2 fournit les informations à propos du texte mis en correspondance par le deuxième groupe de capture. L'ensemble complet de mots capturés par le groupe de capture est disponible à partir de l'objet CaptureCollection retourné par la propriété Group.Captures.

Voir aussi

Concepts

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

Rétroaction