Expressions régulières

Introduction

Les expressions régulières ont pour but de rechercher des chaînes de caractères dans une autre chaîne de caractères à l’aide de modèles déterminés. Ces modèles sont définis sous forme d’objets de type string en une syntaxe précise comme pour un langage spécifique. L’espace de noms System.Text.RegularExpressions expose les classes utilisées pour travailler avec les expressions régulières comme Regex, Match ou Group.

Les expressions régulières permettent de réaliser différentes opérations sur les objets de type string. Vous pouvez par exemple identifier les mots en doublon, changer la casse, séparer les différents éléments d’une URL ou vérifier que le format correspond bien à un modèle.

L’utilisation des expressions régulières se fait essentiellement avec la classe Regex qui contient des méthodes statiques et qui peut aussi être instanciée. Une expression régulière ressemble de près à un objet string. La différence est qu’il contient des séquences d’échappement et des séries de caractères ayant un but spécifique.

Une première expression régulière

La chaîne Original est considérée comme étant la chaîne d’entrée. C’est sur celle-ci que les expressions régulières seront testées. Pour vérifier l’existence d’une série d’une chaîne dans celle-ci, il faudra exécuter les instructions suivantes :

string pattern = "vni"; 
MatchCollection matches = Regex.Matches(Original, 
                                       pattern, 
                                       RegexOptions.IgnoreCase); 
foreach (Match match in matches) 
{ 
    Console.WriteLine(match.Index); 
} 

Cet exemple définit un modèle, la chaîne de caractères vni. Ensuite, on fait appel à la méthode statique Matches de la classe Regex en passant comme arguments la chaîne originale et le schéma à retrouver, et en spécifiant l’option RegexOptions.IgnoreCase, permettant...

Les options de recherche

L’énumération RegexOptions est marquée avec l’attribut Flags. Cela signifie que ses valeurs peuvent être combinées avec des opérateurs de bits :

RegexOptions searchOptions = RegexOptions.IgnoreCase | 
                             RegexOptions.Multiline; 

La liste suivante présente les différentes valeurs de l’énumération RegexOptions :

Les caractères d’échappement

Les expressions régulières contiennent des caractères permettant de spécifier des parties de modèles. Ils doivent être précédés par un antislash \ de manière à être considérés comme un caractère réel. Par exemple, le caractère ? signifie que le caractère précédent peut apparaître zéro ou une fois. Pour faire une recherche sur le point d’interrogation lui-même, il faut le préfixer d’un antislash :

Console.WriteLine(Regex.Match(Original, @"jhu?")); 
Console.WriteLine(Regex.Match(Original, @"jhu\?")); 

Le résultat affiché est le suivant :

jhu_ 
jhu? 

Le résultat n’est pas identique suivant que le caractère ? est échappé ou non. Dans la première instruction, l’expression régulière recherche une suite de caractères pouvant être jh ou jhu alors que pour la seconde, la recherche porte sur la suite exacte jhu?.

Les méthodes statiques Escape et Unescape de la classe Regex permettent de transformer les caractères dans leur équivalent échappé :

Console.WriteLine(Regex.Escape(@"?"));        // \? 
Console.WriteLine(Regex.Unescape(@"\?"));    //...

Les ensembles

Les ensembles de caractères permettent de spécifier une série de caractères possible dans le modèle. Pour avoir une correspondance précise avec un ensemble de caractères, il faut les indiquer entre crochets :

Console.WriteLine(Regex.Match(Original, @"[Aa]hu"));    // ahu 

Le caractère ˆ positionné en premier après le crochet d’ouverture permet de spécifier l’inverse :

Console.WriteLine(Regex.Match(Original, @"[ˆAa]hu"));    // jhu 

Il est possible de spécifier une suite de caractères en séparant le premier du dernier par un tiret. Cela évite de devoir spécifier tous les caractères un par un :

Console.WriteLine(Regex.Match(Original, @"ah[n-z]"));    // ahu 

\d représente un chiffre. Son contraire est \D qui signifie tout caractère sauf un chiffre :

Console.WriteLine(Regex.Match(Original, @"\d\D\d"));    // 2-9 

\w est le diminutif de l’expression [a-zA-Z0-9_]. Il permet de rechercher tout caractère pouvant composer un mot :

Console.WriteLine(Regex.Match(Original, @"\w"));            // L 
Console.WriteLine(Regex.Match(Original, @"[a-zA-Z0-9_]"));  // L 

\s permet de spécifier...

Les groupes

Il est parfois utile de pouvoir séparer une expression régulière en une série de plusieurs sous-expressions appelées des groupes. Pour former un groupe, l’expression doit être entourée de parenthèses :

Match result = Regex.Match(Original, @"(\d\d\d)-(\d\d\d)"); 
Console.WriteLine(result);                        // 022-999 
Console.WriteLine(result.Groups[0]);              // 022-999 
Console.WriteLine(result.Groups[1]);              // 022 
Console.WriteLine(result.Groups[2]);              // 999 

Dans cet exemple, vous pouvez remarquer que le résultat correspond au résultat complet de l’expression régulière tout comme le premier élément de la collection de groupes qui a l’index 0. Les groupes suivants sont ensuite formés par les groupes déterminés par les parenthèses dans leur ordre d’apparition dans l’expression régulière.

En plus de pouvoir séparer les résultats, les groupes peuvent également être...

Console.WriteLine(Regex.Match(Original, @"ˆ\w"));        // L 

Console.WriteLine(Regex.Match(Original, @"(\d{3})-(\d{3})")); 
// 022-999