Langage des expressions régulières - Aide-mémoire

  • Article

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 .NET.

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.

Ces informations sont également disponibles dans deux formats, que vous pouvez télécharger et imprimer pour référence :

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 Correspondances
\a Correspond à un caractère de cloche, \u0007. \a "\u0007" dans "Error!" + '\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\nThese" dans "\r\nThese are\ntwo lines."
\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\nThese" dans "\r\nThese are\ntwo lines."
\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 de deux ou 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 contrôle ASCII 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 à \x2Aet \. est identique à \x2E. 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 \* ou \?). \d+[\+-x\*]\d+ "2+2" et "3*9" dans "(2+2) * 3*9"

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 Correspondances
[ character_group ] Correspond à n’importe quel caractère de groupe_caractères. Par défaut, la correspondance respecte la casse. [ae] "a" dans "gray"

"a", "e" dans "lane"
[^ character_group ] Négation : correspond à n’importe quel caractère qui ne se trouve pas dans groupe_caractères. Par défaut, les caractères de groupe_caractères respectent la casse. [^aei] "r", "g", "n" dans "reign"
[premier - dernier ] Plage de caractères : correspond à n’importe quel caractère qui se trouve dans la plage comprise entre premier et dernier. [A-Z] "A", "B" dans "AB123"
. Caractère générique : correspond à n’importe quel caractère à l’exception de \n.

Pour trouver un caractère de point littéral (. ou \u002E), vous devez le faire précéder du caractère d’échappement (\.).		 a.e "ave" dans "nave"

"ate" dans "water"
\p{nom } Correspond à n’importe quel caractère de la catégorie générale Unicode ou du bloc nommé spécifié par nom. \p{Lu}

\p{IsCyrillic}		 "C", "L" dans "City Lights"

"Д", "Ж" dans "ДЖem"
\P{nom } Correspond à n’importe quel caractère qui ne se trouve pas dans la catégorie générale Unicode ni dans le bloc nommé spécifié par nom. \P{Lu}

\P{IsCyrillic}		 "i", "t", "y" dans "City"

"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 à n’importe quel caractère non alphabétique. \W " ", "." dans "ID A1.3"
\s Correspond à n’importe quel espace blanc. \w\s "D " dans "ID A1.3"
\S Correspond à n’importe quel 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 autre qu’un chiffre décimal. \D " ", "=", " ", "I", "V" dans "4 = IV"

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.

Assertion Description Modèle Correspondances
^ Par défaut, la correspondance doit commencer au début de la chaîne ; en mode multiligne, elle doit commencer au début de la ligne. ^\d{3} "901" dans "901-333-"
$ Par défaut, la correspondance doit se produire à la fin de la chaîne ou avant \n à la fin de la chaîne ; en mode multiligne, elle doit se produire avant la fin de la ligne ou avant \n à la fin de la ligne. -\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 au point où la correspondance précédente s’est terminée ou, en l’absence de correspondance précédente, à la position dans la chaîne où la correspondance a commencé. \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 "them theme", "them them" dans "them theme them them"
\B La correspondance ne doit pas se produire sur une limite \b. \Bend\w*\b "ends", "ender" dans "end sends endure lender"

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 Correspondances
(Sous-expression ) Capture la sous-expression mise en correspondance et lui assigne un nombre ordinal de base un. (\w)\1 "ee" dans "deep"
(?<nom > Sous-expression )
ou
(?'nom ' Sous-expression )		 Capture la sous-expression mise en correspondance dans un groupe nommé. (?<double>\w)\k<double> "ee" dans "deep"
(?<name1 - name2 > Sous-expression )
ou
(?'name1 - name2 ' 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()"

"Write" dans "Console.Write(value)"
(?imnsx-imnsx:Sous-expression ) Active ou désactive les options spécifiées dans 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. \b\w+\b(?=.+and.+) "cats", "dogs"
in
"cats, dogs and some mice."
(?!Sous-expression ) Assertion de préanalyse négative de largeur nulle. \b\w+\b(?!.+and.+) "and", , "some""mice"
in
"cats, dogs and some mice."
(?<=Sous-expression ) Assertion de postanalyse positive de largeur nulle. \b\w+\b(?<=.+and.+)

———————————

\b\w+\b(?<=.+and.*)		 "some", "mice"
in
"cats, dogs and some mice."
————————————
"and", , "some""mice"
in
"cats, dogs and some mice."
(?<!Sous-expression ) Assertion de postanalyse négative de largeur nulle. \b\w+\b(?<!.+and.+)

———————————

\b\w+\b(?<!.+and.*)		 "cats", , "dogs""and"
in
"cats, dogs and some mice."
————————————
"cats", "dogs"
in
"cats, dogs and some mice."
(?>Sous-expression ) Groupe atomique. '(?>a|ab)c "ac" dans "ac"

rien dans "abc"

Présentation rapide des lookarounds

Lorsque le moteur d’expression régulière atteint une expression lookaround, il prend une sous-chaîne partant de la position actuelle au début (assertion arrière) ou à la fin (assertion avant) de la chaîne d’origine, puis exécute Regex.IsMatch sur cette sous-chaîne à l’aide du modèle lookaround. Le succès du résultat de cette sous-expression dépend alors de la nature positive ou négative de l’assertion.

Lookaround Nom Fonction
(?=check) Assertion avant positive Affirme que ce qui suit immédiatement la position actuelle dans la chaîne est « check ».
(?<=check) Assertion arrière positive Affirme que ce qui précède immédiatement la position actuelle dans la chaîne est « check ».
(?!check) Assertion avant négative Affirme que ce qui suit immédiatement la position actuelle dans la chaîne n’est pas « check ».
(?<!check) Assertion arrière négative Affirme que ce qui précède immédiatement la position actuelle dans la chaîne n’est pas « check ».

Une fois qu’ils ont été mis en correspondance, les groupes atomiques ne sont plus réévalués, même en cas d’échec du reste du modèle en raison de la correspondance. Ce mode de fonctionnement peut considérablement améliorer les performances lorsque des quantificateurs se produisent au sein du groupe atomique ou du reste du modèle.

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.

Quantificateur Description Modèle Correspondances
* Correspond zéro, une ou plusieurs fois à l’élément précédent. a.*c "abcbc" dans "abcbc"
+ Correspond une ou plusieurs fois à l’élément précédent. "be+" "bee" dans "been", "be" dans "bent"
? Correspond zéro ou une fois à l’élément précédent. "rai?" "rai" dans "rain"
{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. a.*?c "abc" dans "abcbc"
+? Correspond une ou plusieurs fois à l’élément précédent, mais le moins de fois possible. "be+?" "be" dans "been", "be" dans "bent"
?? Correspond zéro ou une fois à l’élément précédent, mais le moins de fois possible. "rai??" "ra" dans "rain"
{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"

Constructions de référence arrière

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 .NET. Pour plus d'informations, consultez Backreference Constructs.

Construction de backreference Description Modèle Correspondances
\nombre Backreference. Correspond à la valeur d’une sous-expression numérotée. (\w)\1 "ee" dans "seek"
\k<nom > Backreference nommée. Correspond à la valeur d’une expression nommée. (?<char>\w)\k<char> "ee" dans "seek"

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 Correspondances
| 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 )
ou
(?(expression ) oui )		 Correspond à oui si le modèle d’expression régulière indiqué par expression correspond ; sinon, correspond à no (facultatif). expression est interprétée comme une assertion de largeur nulle.

Pour éviter toute ambiguïté avec un groupe de capture nommé ou numéroté, vous pouvez éventuellement utiliser une assertion explicite :
(?( (?=expression ) ) oui | Non )		 (?(A)A\d{2}\b|\b\d{3}\b) "A10", "910" dans "A10 C103 910"
(?(nom ) oui | Non )
ou
(?(nom ) oui )		 Correspond à oui si nom, un groupe de capture nommé ou numéroté, a une correspondance ; sinon, correspond à non (facultatif). (?<quoted>")?(?(quoted).+?"|\S+\s) "Dogs.jpg ", "\"Yiska playing.jpg\"" dans "Dogs.jpg \"Yiska playing.jpg\""

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 "one two" "two one"
${nom } Remplace la sous-chaîne mise en correspondance par le groupe nommé nom. \b(?<word1>\w+)(\s)(?<word2>\w+)\b ${word2} ${word1} "one two" "two one"
$$ Remplace un "$" littéral. \b(\d+)\s?USD $$$1 "103 USD" "$103"
$& Remplace une copie de la totalité de la correspondance. \$?\d*\.?\d+ **$&** "$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"

Options des expressions régulières

Vous pouvez définir des options qui contrôlent comment le moteur des expressions régulières interprète un modèle d’expression régulière. Bon nombre de ces options peuvent être spécifiées inline (dans le modèle d’expression régulière) ou sous la forme d’une ou de plusieurs constantes RegexOptions. Cette référence rapide répertorie uniquement les options inline. Pour plus d’informations sur les options inline et RegexOptions, consultez l’article Options des expressions régulières.

Vous pouvez spécifier une option inline de deux façons :

  • À l’aide de la construction (?imnsx-imnsx)divers, où un signe moins (-) avant une option ou un ensemble d’options désactive ces options. Par exemple, (?i-mn) active la correspondance qui ne respecte pas la casse (i), désactive le mode multiligne (m) et désactive les captures de groupe sans nom (n). L’option s’applique au modèle d’expression régulière depuis le point au niveau duquel l’option est définie et est effective jusqu’à la fin du modèle ou jusqu’au point au niveau duquel une autre construction inverse l’option.
  • À l’aide d’une construction de regroupement(?imnsx-imnsx:sous-expression), qui définit des options uniquement pour le groupe spécifié.

Le moteur d’expression régulière de .NET prend en charge les options inline suivantes :

Option Description Modèle Correspondances
i Utilise la correspondance qui ne respecte pas la casse. \b(?i)a(?-i)a\w+\b "aardvark", "aaaAuto" dans "aardvark AAAuto aaaAuto Adam breakfast"
m Utilise le mode multiligne. ^ et $ correspondent au début et à la fin d’une ligne, au lieu du début et de la fin d’une chaîne. Pour obtenir un exemple, consultez la section « Mode multiligne » dans Options des expressions régulières.
n Ne capture aucun groupe sans nom. Pour obtenir un exemple, consultez la section « Captures explicites uniquement » dans Options des expressions régulières.
s Utilise le mode à ligne simple. Pour obtenir un exemple, consultez la section « Mode à ligne simple » dans Options des expressions régulières.
x Ignore l’espace blanc sans séquence d’échappement dans le modèle d’expression régulière. \b(?x) \d+ \s \w+ "1 aardvark", "2 cats" dans "1 aardvark 2 cats IV centurions"

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 .NET. Pour plus d'informations, consultez Miscellaneous Constructs.

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

Voir aussi