Comment fonctionnent les groupes d'expressions régulières en C# ?

Groupes d'expressions régulières en C#

Dans le bloc de code suivant, l'expression régulière fournie extrait le contenu entre crochets :

var pattern = @"\[(.*?)\]";
var matches = Regex.Matches(user, pattern);

Avec l'entrée user == "Josh Smith [jsmith]":

matches.Count == 1
matches[0].Value == "[jsmith]"

Cependant, matches[0].Groups.Count == 2, avec :

matches[0].Groups[0].Value == "[jsmith]"
matches[0].Groups[1].Value == "jsmith"

Comprendre la collection de groupes

• match.Groups[0] contient toujours la correspondance entière, identique à match.Value.
• match.Groups[1 ] capture le premier groupe de l'expression régulière.

Dans ce cas :

• le motif est défini comme @"[(.*?)]", où (. *?) est le groupe de capture.
• L'expression rationnelle correspond à l'intégralité de la chaîne entre crochets ainsi qu'au contenu entre parenthèses.

Par conséquent, match.Groups[1]. Value récupère le contenu entre parenthèses, "jsmith".

Nombre de groupes dans une correspondance

Les règles suivantes régissent le nombre de groupes dans une correspondance :

• Chaque correspondance a un seul groupe à l'index 0, qui correspond toujours à la correspondance entière.
• Le nombre de groupes supplémentaires dépend des groupes de capture définis dans l'expression régulière.
• Si aucun groupe de capture n'est défini, la correspondance n'aura qu'un seul groupe.

Dans l'exemple fourni, puisque le modèle contient un groupe de capture, match.Groups.Count sera toujours 2. Cependant, des expressions régulières plus complexes avec plusieurs groupes de capture entraîneront un plus grand nombre de groupes.

Exemples supplémentaires

Considérez le modèle suivant et faites correspondre :

var pattern = @"\[(.*?)\](.*)";
var match = Regex.Match("ignored [john] John Johnson", pattern);

• match.Value est "[john] John Johnson".
• match.Groups[0] est "[john] John Johnson".
• match.Groups[1 ] est [john].
• match.Groups[2] est John Johnson.

Dans un modèle plus complexe :

var pattern = @"(\[.*?\])+";
var match = Regex.Match("[john][johnny]", pattern);

• match .La valeur est "[john][johnny]".
• match.Groups[0] est "[john][johnny]".
• match.Groups[1] est [john] [johnny].
• match.Groups[1].Captures[0] est [john].
• match.Groups[1].Captures[1] est [johnny].

Comprendre ces concepts est crucial pour exploiter la puissance des groupes d'expressions régulières en C#.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!