Éléments du langage des expressions régulières
Une expression régulière est un modèle que le moteur des expressions régulières tente de faire correspondre dans le texte d'entrée. Un modèle se compose d'un ou de plusieurs littéraux de caractère, opérateurs ou constructions. Pour obtenir une brève présentation, consultez Expressions régulières du .NET Framework.
Chaque section dans cette référence rapide répertorie une catégorie particulière de caractères, d'opérateurs et de constructions que vous pouvez utiliser pour définir des expressions régulières :
Caractères d'échappement
Classes de caractères
Ancres
Constructions de regroupement
Quantificateurs
Constructions de backreference
Constructions d'alternative
Substitutions
Constructions diverses
Caractères d'échappement
La barre oblique inverse (\) dans une expression régulière indique que le caractère qui le suit est un caractère spécial (comme indiqué dans le tableau suivant), ou qu'il doit être interprété littéralement. Pour plus d'informations, consultez Caractères d'échappement.
Caractère d'échappement |
Description |
Modèle |
Correspondance |
|---|---|---|---|
\a |
Correspond à un caractère de cloche, \u0007. |
\a |
"\u0007" dans "Erreur !" + '\u0007' |
\b |
Dans une classe de caractères, correspond à un retour arrière, \u0008. |
[\b]{3,} |
"\b\b\b\b" dans "\b\b\b\b" |
\t |
Correspond à une tabulation, \u0009. |
(\w+)\t |
"item1\t", "item2\t" dans "item1\titem2\t" |
\r |
Correspond à un retour chariot, \u000D. (\r n'est pas équivalent au caractère de saut de ligne, \n.) |
\r\n(\w+) |
"\r\nCe" dans "\r\nCe sont\ndeux lignes." |
\v |
Correspond à une tabulation verticale, \u000B. |
[\v]{2,} |
"\v\v\v" dans "\v\v\v" |
\f |
Correspond à un saut de page, \u000C. |
[\f]{2,} |
"\f\f\f" dans "\f\f\f" |
\n |
Correspond à une nouvelle ligne, \u000A. |
\r\n(\w+) |
"\r\nCe" dans "\r\nCe sont\ndeux lignes." |
\e |
Correspond à un caractère d'échappement, \u001B. |
\e |
"\x001B" dans "\x001B" |
\nnn |
Utilise la représentation octale pour spécifier un caractère (nnn se compose au maximum de trois chiffres). |
\w\040\w |
"a b", "c d" dans "a bc d" |
\xnn |
Utilise une représentation hexadécimale pour spécifier un caractère (nn se compose de deux chiffres exactement). |
\w\x20\w |
"a b", "c d" dans "a bc d" |
\cX \cx |
Correspond au caractère de commande ANSI spécifié par X ou x, où X ou x représente la lettre du caractère de contrôle. |
\cC |
"\x0003" dans "\x0003" (Ctrl-C) |
\unnnn |
Correspond à un caractère Unicode en utilisant la représentation hexadécimale (quatre chiffres exactement, représentés par nnnn). |
\w\u0020\w |
"a b", "c d" dans "a bc d" |
\ |
Lorsque ce caractère d'échappement est suivi d'un caractère non identifié comme caractère d'échappement, correspond au caractère lui-même. Par exemple, \* est identique à \x2A. Cela permet au moteur des expressions régulières de lever l'ambiguïté d'éléments de langage (tels que * ou ?) et de caractères littéraux (représentés par \* or \?). |
\d+[\+-x\*]\d+\d+[\+-x\*\d+ |
"2+2" et "3*9" dans "(2+2) * 3*9" |
Retour au début
Classes de caractères
Une classe de caractères fait correspondre tout caractère d'un jeu de caractères. Les classes de caractères incluent les éléments de langage répertoriés dans le tableau suivant. Pour plus d'informations, consultez Classes de caractères.
Classe de caractères |
Description |
Modèle |
Correspondance |
|---|---|---|---|
[groupe_caractères] |
Correspond à tout caractère unique se trouvant dans groupe_caractères. Par défaut, la correspondance respecte la casse. |
[ae] |
"a" dans "gras" "a", "e" dans "laine" |
[^groupe_caractères] |
Négation : correspond à tout caractère unique qui ne se trouve pas dans groupe_caractères. Par défaut, les caractères dans groupe_caractères respectent la casse. |
[^aei] |
"r", "g", "n" dans "règne" |
[premier-dernier] |
Plage de caractères : correspond à tout caractère unique dans la plage comprise entre premier et dernier. |
[A-Z] |
"A", "B" dans "AB123" |
. |
Caractère générique : correspond à tout caractère à l'exception de \n. |
a.e |
"ave" dans "navet" "ate" dans "plate" |
\p{name} |
Correspond à tout caractère unique de la catégorie générale Unicode ou du bloc nommé spécifié par nom. |
\p{Lu} \p{IsCyrillic} |
"M", "G" dans "Mardi Gras" "Д", "Ж" dans "ДЖem" |
\P{name} |
Correspond à tout caractère unique qui ne se trouve pas dans la catégorie générale Unicode ou le bloc nommé spécifié par nom. |
\P{Lu} \P{IsCyrillic} |
"a", "r", "d", "i" dans "Mardi" "e", "m" dans "ДЖem" |
\w |
Correspond à n'importe quel caractère alphabétique. |
\w |
"I", "D", "A", "1", "3" dans "ID A1.3" |
\W |
Correspond à tout caractère autre qu'un caractère de mot. |
\W |
" ", "." dans "ID A1.3" |
\s |
Correspond à tout caractère espace blanc. |
\w\s |
"D " dans "ID A1.3" |
\S |
Correspond à tout caractère autre qu'un espace blanc. |
\s\S |
" _" dans "int __ctr" |
\d |
Correspond à n'importe quel chiffre décimal. |
\d |
"4" dans "4 = IV" |
\D |
Correspond à n'importe quel caractère qui n'est pas un chiffre décimal. |
\D |
" ", "=", " ", "I", "V" dans "4 = IV" |
Retour au début
Ancres
Les ancres, ou assertions de largeur nulle atomiques, entraînent le succès ou l'échec d'une correspondance en fonction de la position actuelle dans la chaîne, mais elles n'entraînent pas l'avancement du moteur à travers la chaîne ou la consommation de caractères. Les métacaractères répertoriés dans le tableau suivant sont des ancres. Pour plus d'informations, consultez Ancres dans les expressions régulières.
Assertion |
Description |
Modèle |
Correspondance |
|---|---|---|---|
^ |
La correspondance doit commencer au début de la chaîne ou de la ligne. |
^\d{3} |
"901-" dans "901-333-" |
$ |
La correspondance doit se produire à la fin de la chaîne ou avant \n à la fin de la ligne ou de la chaîne. |
-\d{3}$ |
"-333" dans "-901-333" |
\A |
La correspondance doit se produire au début de la chaîne. |
\A\d{3} |
"901" dans "901-333-" |
\Z |
La correspondance doit se produire à la fin de la chaîne ou avant \n à la fin de la chaîne. |
-\d{3}\Z |
"-333" dans "-901-333" |
\z |
La correspondance doit se produire à la fin de la chaîne. |
-\d{3}\z |
"-333" dans "-901-333" |
\G |
La correspondance doit se produire à l'emplacement où la correspondance précédente s'est terminée. |
\G\(\d\) |
"(1)", "(3)", "(5)" dans "(1)(3)(5)[7](9)" |
\b |
La correspondance doit se produire sur une limite entre un caractère \w (alphanumérique) et un caractère \W (non alphanumériques). |
\b\w+\s\w+\b |
"thèm thèm" dans "thèm thème thèm thèm" |
\B |
La correspondance ne doit pas se produire sur une limite \b. |
\Bend\w*\b |
"ends", "ender" dans "end sends endure lender" |
Retour au début
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. Les constructions de regroupement incluent les éléments de langage répertoriés dans le tableau suivant. Pour plus d'informations, consultez Constructions de regroupement.
Construction de regroupement |
Description |
Modèle |
Correspondance |
|---|---|---|---|
(sous-expression) |
Capture la sous-expression mise en correspondance et lui assigne un nombre ordinal de base zéro. |
(\w)\1 |
"oo" dans "boot" |
(?<nom> sous-expression) |
Capture la sous-expression mise en correspondance dans un groupe nommé. |
(?<double>\w)\k<double> |
"oo" dans "boot" |
(?<nom1-nom2> sous-expression) |
Définit un équilibre de définition de groupe. Pour plus d'informations, consultez la section « Équilibre de définition de groupe » dans Constructions de regroupement. |
(((?'Open'\()[^\(\)]*)+((?'Close-Open'\))[^\(\)]*)+)*(?(Open)(?!))$ |
"((1-3)*(3-1))" dans "3+2^((1-3)*(3-1))" |
(?: sous-expression) |
Définit un groupe sans capture. |
Write(?:Line)? |
"WriteLine" dans "Console.WriteLine()" |
(?imnsx-imnsx: sous-expression) |
Active ou désactive les options spécifiées au sein de sous-expression. Pour plus d'informations, consultez Options des expressions régulières. |
A\d{2}(?i:\w+)\b |
"A12xl", "A12XL" dans "A12xl A12XL a12xl" |
(?= sous-expression) |
Assertion de préanalyse positive de largeur nulle. |
\w+(?=\.) |
"est", "courait", et "couché" dans "Il est. Le chien courait. Le soleil est couché." |
(?! sous-expression) |
Assertion de préanalyse négative de largeur nulle. |
\b(?!un)\w+\b |
"retourner", "utilisée" dans "retourner une unité utilisée" |
(?<= sous-expression) |
Assertion de postanalyse positive de largeur nulle. |
(?<=19)\d{2}\b |
"99", "50", "05" dans "1851 1999 1950 1905 2003" |
(?<! sous-expression) |
Assertion de postanalyse négative de largeur nulle. |
(?<!19)\d{2}\b |
"51", "03" dans "1851 1999 1950 1905 2003" |
(?> sous-expression) |
Sous-expressions de recherche non rétroactive (ou « gourmandes »). |
[13579](?>A+B+) |
"1ABB", "3ABB" et "5AB" dans "1ABB 3ABBC 5AB 5AC" |
Retour au début
Quantificateurs
Un quantificateur indique combien d'instances de l'élément précédent (qui peut être un caractère, un groupe ou une classe de caractères) doivent être présentes dans la chaîne d'entrée pour qu'il y ait correspondance. Les quantificateurs incluent les éléments de langage répertoriés dans le tableau suivant. Pour plus d'informations, consultez Quantificateurs.
Quantifieur |
Description |
Modèle |
Correspondance |
|---|---|---|---|
* |
Correspond zéro, une ou plusieurs fois à l'élément précédent. |
\d*\. \d |
".0", "19.9", "219.9" |
+ |
Correspond une ou plusieurs fois à l'élément précédent. |
"be+" |
"bee" dans "beefsteak", "be" dans "besoin" |
? |
Correspond zéro ou une fois à l'élément précédent. |
"rai? n" |
"rang", "train" |
{n} |
Correspond à l'élément précédent exactement n fois. |
",\d{3}" |
",043" dans "1,043.6", ",876", ",543" et ",210" dans "9,876,543,210" |
{n,} |
Correspond à l'élément précédent au moins n fois. |
"\d{2,}" |
"166", "29", "1930" |
{n,m} |
Correspond à l'élément précédent au moins n fois, mais pas plus de m fois. |
"\d{3,5}" |
"166", "17668" "19302" dans "193024" |
*? |
Correspond zéro fois ou plus à l'élément précédent, mais le moins de fois possible. |
\d*? \. \d |
".0", "19.9", "219.9" |
+? |
Correspond une ou plusieurs fois à l'élément précédent, mais le moins de fois possible. |
"be+?" |
"bee" dans "beefsteak", "be" dans "besoin" |
?? |
Correspond zéro ou une fois à l'élément précédent, mais le moins de fois possible. |
"rai?? n" |
"rang", "train" |
{n}? |
Correspond exactement n fois à l'élément précédent. |
",\d{3}?" |
",043" dans "1,043.6", ",876", ",543" et ",210" dans "9,876,543,210" |
{n,}? |
Correspond au moins n fois à l'élément précédent, mais le moins de fois possible. |
"\d{2,}?" |
"166", "29", "1930" |
{n,m}? |
Correspond entre n et m fois à l'élément précédent, mais le moins de fois possible. |
"\d{3,5}?" |
"166", "17668" "193", "024" dans "193024" |
Retour au début
Constructions de backreference
Une backreference permet qu'une sous-expression précédemment mise en correspondance soit ensuite identifiée dans la même expression régulière. Le tableau suivant répertorie les constructions de backreference prises en charge par les expressions régulières dans le .NET Framework. Pour plus d'informations, consultez Constructions de backreference.
Construction de backreference |
Description |
Modèle |
Correspondance |
|---|---|---|---|
\number |
Backreference. Correspond à la valeur d'une sous-expression numérotée. |
(\w)\1 |
"ee" dans "seek" |
\k<name> |
Backreference nommée. Correspond à la valeur d'une expression nommée. |
(?<char>\w)\k<char> |
"ee" dans "seek" |
Retour au début
Constructions d'alternative
Les constructions d'alternative modifient une expression régulière pour permettre la correspondance de type inclusif/exclusif. Ces constructions incluent les éléments de langage répertoriés dans le tableau suivant. Pour plus d'informations, consultez Constructions d'alternative.
Construction d'alternative |
Description |
Modèle |
Correspondance |
|---|---|---|---|
| |
Correspond à tout élément séparé par le caractère barre verticale (|). |
th(e|is|at) |
"the", "this" dans "this is the day. " |
(?(expression)oui|non) |
Correspond à oui si expression est mise en correspondance ; sinon, correspond à la partie non facultative. expression est interprétée comme une assertion de largeur nulle. |
(?(A)A\d{2}\b|\b\d{3}\b) |
"A10", "910" dans "A10 C103 910" |
(?(name)oui|non) |
Correspond à oui si le nom de capture nommé a une correspondance ; sinon, correspond au non facultatif. |
(?<quoted>")?(?(quoted).+?"|\S+\s) |
Dogs.jpg, "Yiska playing.jpg" dans "Dogs.jpg "Yiska playing.jpg"" |
Retour au début
Substitutions
Les substitutions sont des éléments de langage d'expression régulière pris en charge dans les modèles de remplacement. Pour plus d'informations, consultez Substitutions. Les métacaractères répertoriés dans le tableau suivant sont des assertions de largeur nulle atomiques.
Caractère |
Description |
Modèle |
Modèle de remplacement |
Chaîne d'entrée |
Chaîne de résultat |
|---|---|---|---|---|---|
$nombre |
Remplace la sous-chaîne mise en correspondance par le groupe nombre. |
\b(\w+)(\s)(\w+)\b |
$3$2$1 |
"un deux" |
"deux un" |
${name} |
Remplace la sous-chaîne mise en correspondance par le groupe nommé nom. |
\b(?<word1>\w+)(\s)(?<word2>\w+)\b |
${word2} ${word1} |
"un deux" |
"deux un" |
$$ |
Remplace un "$" littéral. |
\b(\d+)\s?USD |
$$$1 |
"103 USD" |
"$103" |
$& |
Remplace une copie de la totalité de la correspondance. |
(\$*(\d*(\.+\d+)?){1}) |
**$& |
"$1.30" |
"**$1.30**" |
$` |
Remplace tout le texte de la chaîne d'entrée avant la correspondance. |
B+ |
$` |
"AABBCC" |
"AAAACC" |
$' |
Remplace tout le texte de la chaîne d'entrée après la correspondance. |
B+ |
$' |
"AABBCC" |
"AACCCC" |
$+ |
Remplace le dernier groupe qui a été capturé. |
B+(C+) |
$+ |
"AABBCCDD" |
AACCDD |
$_ |
Remplace la chaîne d'entrée entière. |
B+ |
$_ |
"AABBCC" |
"AAAABBCCCC" |
Retour au début
Constructions diverses
Diverses constructions modifient un modèle d'expression régulière ou fournissent des informations le concernant. Le tableau suivant répertorie les diverses constructions prises en charge par le .NET Framework. Pour plus d'informations, consultez Constructions diverses.
Construction |
Définition |
Exemple |
|---|---|---|
(?imnsx-imnsx) |
Active ou désactive des options telles que le non-respect de la casse au milieu d'un modèle. Pour plus d'informations, consultez Options des expressions régulières. |
\bA(?i)b\w+\b correspond à "ABA", "Able" dans "ABA Able Act" |
(?# commentaire) |
Commentaire inline. Le commentaire se termine à la première parenthèse fermante. |
\bA(?#Matches words starting with A)\w+\b |
# [to end of line] |
Commentaire en mode X. Le commentaire commence au caractère # sans séquence d'échappement et se poursuit jusqu'à la fin de la ligne. |
(?x)\bA\w+\b#Matches words starting with A |
Retour au début
Voir aussi
Référence
System.Text.RegularExpressions
Concepts
Expressions régulières du .NET Framework
Classes d'expressions régulières
Autres ressources
Meilleures pratiques des expressions régulières dans le .NET Framework