Constructions de regroupement
Les constructions de regroupement délimitent les sous-expressions d'une expression régulière et capturent généralement les sous-chaînes d'une chaîne d'entrée. Le tableau suivant décrit les constructions de regroupement d'expressions régulières.
| Construction de regroupement | Description |
|---|---|
( sous-expression ) |
Capture la sous-expression correspondante (ou le groupe sans capture ; pour plus d'informations, consultez l'option ExplicitCapture dans Options des expressions régulières). Les captures utilisant () sont numérotées automatiquement selon l'ordre des parenthèses ouvrantes à partir de 1 (un). La première capture, élément de capture numéro zéro, désigne le texte correspondant à la totalité du modèle d'expression régulière. |
(?< nom > sous-expression) |
Capture la sous-expression correspondante dans un nom de groupe ou un nom numérique. La chaîne utilisée comme nom ne doit contenir aucun signe de ponctuation et ne peut pas commencer par un nombre. Vous pouvez utiliser des apostrophes simples au lieu de crochets ; par exemple, |
(?< nom1 - nom2 > sous-expression) |
(Équilibre la définition du groupe.) Supprime la définition du groupe préalablement nommé nom2 et stocke dans le groupe nom1 l'intervalle entre le groupe préalablement nommé nom2 et le groupe actuel. Si aucun groupe nom2 n'est défini, la recherche de correspondances s'effectue par rétroaction (backtracking). Comme la suppression de la dernière définition de nom2 laisse apparaître la définition précédente de nom2, cette construction permet d'utiliser la pile de captures du groupe nom2 comme compteur de constructions imbriquées telles que les parenthèses. Dans cette construction, nom1 est facultatif. Vous pouvez utiliser des apostrophes simples au lieu de crochets ; par exemple, Pour plus d'informations, consultez l'exemple dans cette rubrique. |
(?: sous-expression) |
(Groupe sans capture.) Ne capture pas la sous-chaîne correspondant à la sous-expression. |
(?imnsx-imnsx: sous-expression) |
Active ou désactive les options spécifiées au sein de la sous-expression. Par exemple, |
(?= sous-expression) |
(Assertion de préanalyse positive de largeur nulle.) Ne poursuit la correspondance que si la sous-expression correspond à cette position sur la droite. Par exemple, |
(?! sous-expression) |
(Assertion de préanalyse négative de largeur nulle.) Ne poursuit la correspondance que si la sous-expression ne correspond pas à cette position sur la droite. Par exemple, |
(?<= sous-expression) |
(Assertion de postanalyse positive de largeur nulle.) Ne poursuit la correspondance que si la sous-expression correspond à cette position sur la gauche. Par exemple, |
(?<! sous-expression) |
(Assertion de postanalyse négative de largeur nulle.) Ne poursuit la correspondance que si la sous-expression ne correspond pas à cette position sur la gauche. |
(?> sous-expression) |
(Sous-expression de recherche de correspondances non rétroactive (également connue sous le nom de sous-expression gourmande)). Une seule correspondance complète de la sous-expression est recherchée, puis celle-ci n'est plus incluse dans la recherche de correspondances rétroactive. (Autrement dit, la sous-expression ne correspond qu'aux chaînes auxquelles la sous-expression seule correspond). Par défaut, si une correspondance n'aboutit pas, la rétroaction recherche d'autres correspondances possibles. Si vous savez que la rétroaction ne pourra pas aboutir, vous pouvez utiliser une sous-expression de recherche de correspondances non rétroactive pour éviter toute recherche inutile, ce qui améliore les performances. |
Les captures nommées sont numérotées de façon séquentielle, en fonction de l'ordre des parenthèses ouvrantes (comme les captures sans nom), en allant de la gauche vers la droite, mais la numérotation des captures nommées ne commence qu'une fois que toutes les captures sans nom ont été comptées. Par exemple, le modèle ((?<One>abc)/d+)?(?<Two>xyz)(.*) génère les groupes de capture suivants, classés par numéro et par nom. (La première capture (numéro 0) fait toujours référence au modèle complet).
| Numéro | Nom | Modèle |
|---|---|---|
0 |
0 (nom par défaut) |
|
1 |
1 (nom par défaut) |
|
2 |
2 (nom par défaut) |
|
3 |
One |
|
4 |
Two |
|
Exemple d'équilibre de la définition du groupe
L'exemple de code suivant illustre l'utilisation d'un équilibre de définition de groupe pour faire correspondre les crochets angulaires à droite et à gauche (<>) dans une chaîne d'entrée. Les collections de captures des groupes Ouvrir et Fermer de l'exemple sont utilisées comme une pile pour suivre les paires de crochets angulaires correspondantes : chaque crochet angulaire gauche capturé est envoyé dans la collection de captures du groupe Ouvrir, chaque crochet angulaire droit capturé est envoyé dans la collection de captures du groupe Fermer, et l'équilibre de la définition du groupe garantit qu'il existe un crochet angulaire droit correspondant à chaque crochet angulaire gauche.
' This code example demonstrates using the balancing group definition feature of
' regular expressions to match balanced left angle bracket (<) and right angle
' bracket (>) characters in a string.
Imports System
Imports System.Text.RegularExpressions
Class Sample
Public Shared Sub Main()
'
' The following expression matches all balanced left and right angle brackets(<>).
' The expression:
' 1) Matches and discards zero or more non-angle bracket characters.
' 2) Matches zero or more of:
' 2a) One or more of:
' 2a1) A group named "Open" that matches a left angle bracket, followed by zero
' or more non-angle bracket characters.
' "Open" essentially counts the number of left angle brackets.
' 2b) One or more of:
' 2b1) A balancing group named "Close" that matches a right angle bracket,
' followed by zero or more non-angle bracket characters.
' "Close" essentially counts the number of right angle brackets.
' 3) If the "Open" group contains an unaccounted for left angle bracket, the
' entire regular expression fails.
'
Dim pattern As String = "^[^<>]*" & _
"(" + "((?'Open'<)[^<>]*)+" & _
"((?'Close-Open'>)[^<>]*)+" + ")*" & _
"(?(Open)(?!))$"
Dim input As String = "<abc><mno<xyz>>"
'
Dim m As Match = Regex.Match(input, pattern)
If m.Success = True Then
Console.WriteLine("Input: ""{0}"" " & vbCrLf & "Match: ""{1}""", _
input, m)
Else
Console.WriteLine("Match failed.")
End If
End Sub 'Main
End Class 'Sample
'This code example produces the following results:
'
'Input: "<abc><mno<xyz>>"
'Match: "<abc><mno<xyz>>"
'
// This code example demonstrates using the balancing group definition feature of
// regular expressions to match balanced left angle bracket (<) and right angle
// bracket (>) characters in a string.
using System;
using System.Text.RegularExpressions;
class Sample
{
public static void Main()
{
/*
The following expression matches all balanced left and right angle brackets(<>).
The expression:
1) Matches and discards zero or more non-angle bracket characters.
2) Matches zero or more of:
2a) One or more of:
2a1) A group named "Open" that matches a left angle bracket, followed by zero
or more non-angle bracket characters.
"Open" essentially counts the number of left angle brackets.
2b) One or more of:
2b1) A balancing group named "Close" that matches a right angle bracket,
followed by zero or more non-angle bracket characters.
"Close" essentially counts the number of right angle brackets.
3) If the "Open" group contains an unaccounted for left angle bracket, the
entire regular expression fails.
*/
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);
else
Console.WriteLine("Match failed.");
}
}
/*
This code example produces the following results:
Input: "<abc><mno<xyz>>"
Match: "<abc><mno<xyz>>"
*/