Langage des expressions régulières - Aide-mémoireRegular Expression Language - Quick Reference

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.A regular expression is a pattern that the regular expression engine attempts to match in input text. Un modèle se compose d'un ou de plusieurs littéraux de caractère, opérateurs ou constructions.A pattern consists of one or more character literals, operators, or constructs. Pour obtenir une brève présentation, consultez Expressions régulières .NET.For a brief introduction, see .NET Regular Expressions.

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 :Each section in this quick reference lists a particular category of characters, operators, and constructs that you can use to define regular expressions:

Caractères d’échappementCharacter escapes
Classes de caractèresCharacter classes
AncresAnchors
Constructions de regroupementGrouping constructs
QuantificateursQuantifiers
Constructions de référence arrièreBackreference constructs
Constructions d'alternativeAlternation constructs
SubstitutionsSubstitutions
Options des expressions régulièresRegular expression options
Constructions diversesMiscellaneous constructs

Ces informations sont également disponibles dans deux documents de référence, que vous pouvez télécharger et imprimer :We’ve also provided this information in two formats that you can download and print for easy reference:

Télécharger au format Word (.docx)Download in Word (.docx) format
Télécharger au format PDF (.pdf)Download in PDF (.pdf) format

Caractères d'échappementCharacter Escapes

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.The backslash character (\) in a regular expression indicates that the character that follows it either is a special character (as shown in the following table), or should be interpreted literally. Pour plus d’informations, consultez Caractères d’échappement.For more information, see Character Escapes.

Caractère d'échappementEscaped character DescriptionDescription MotifPattern CorrespondancesMatches
\a Correspond à un caractère de cloche, \u0007.Matches a bell character, \u0007. \a "\u0007" dans "Erreur !""\u0007" in "Error!" + ’\u0007’+ '\u0007'
\b Dans une classe de caractères, correspond à un retour arrière, \u0008.In a character class, matches a backspace, \u0008. [\b]{3,} "\b\b\b\b" dans "\b\b\b\b""\b\b\b\b" in "\b\b\b\b"
\t Correspond à une tabulation, \u0009.Matches a tab, \u0009. (\w+)\t "item1\t", "item2\t" dans "item1\titem2\t""item1\t", "item2\t" in "item1\titem2\t"
\r Correspond à un retour chariot, \u000D.Matches a carriage return, \u000D. (\r n'est pas équivalent au caractère de saut de ligne, \n.)(\r is not equivalent to the newline character, \n.) \r\n(\w+) "\r\nCe" dans "\r\nCe sont\ndeux lignes.""\r\nThese" in "\r\nThese are\ntwo lines."
\v Correspond à une tabulation verticale, \u000B.Matches a vertical tab, \u000B. [\v]{2,} "\v\v\v" dans "\v\v\v""\v\v\v" in "\v\v\v"
\f Correspond à un saut de page, \u000C.Matches a form feed, \u000C. [\f]{2,} "\f\f\f" dans "\f\f\f""\f\f\f" in "\f\f\f"
\n Correspond à une nouvelle ligne, \u000A.Matches a new line, \u000A. \r\n(\w+) "\r\nCe" dans "\r\nCe sont\ndeux lignes.""\r\nThese" in "\r\nThese are\ntwo lines."
\e Correspond à un caractère d'échappement, \u001B.Matches an escape, \u001B. \e "\x001B" dans "\x001B""\x001B" in "\x001B"
\ nnn\ nnn Utilise la représentation octale pour spécifier un caractère (nnn se compose de deux ou trois chiffres).Uses octal representation to specify a character (nnn consists of two or three digits). \w\040\w "a b", "c d" dans"a b", "c d" in

"a bc d""a bc d"
\x nn\x nn Utilise une représentation hexadécimale pour spécifier un caractère (nn se compose de deux chiffres exactement).Uses hexadecimal representation to specify a character (nn consists of exactly two digits). \w\x20\w "a b", "c d" dans"a b", "c d" in

"a bc d""a bc d"
\c X\c X

\c x\c x
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.Matches the ASCII control character that is specified by X or x, where X or x is the letter of the control character. \cC "\x0003" dans "\x0003" (Ctrl-C)"\x0003" in "\x0003" (Ctrl-C)
\u nnnn\u nnnn Correspond à un caractère Unicode en utilisant la représentation hexadécimale (quatre chiffres exactement, représentés par nnnn).Matches a Unicode character by using hexadecimal representation (exactly four digits, as represented by nnnn). \w\u0020\w "a b", "c d" dans"a b", "c d" in

"a bc d""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.When followed by a character that is not recognized as an escaped character in this and other tables in this topic, matches that character. Par exemple, \* est identique à \x2Aet \. est identique à \x2E.For example, \* is the same as \x2A, and \. is the same as \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 \?).This allows the regular expression engine to disambiguate language elements (such as * or ?) and character literals (represented by \* or \?). \d+[\+-x\*]\d+ "2+2" et "3*9" dans "(2+2) * 3*9""2+2" and "3*9" in "(2+2) * 3*9"

Retour au débutBack to top

Classes de caractèresCharacter Classes

Une classe de caractères fait correspondre tout caractère d'un jeu de caractères.A character class matches any one of a set of characters. Les classes de caractères incluent les éléments de langage répertoriés dans le tableau suivant.Character classes include the language elements listed in the following table. Pour plus d'informations, consultez Character Classes.For more information, see Character Classes.

Classe de caractèresCharacter class DescriptionDescription MotifPattern CorrespondancesMatches
[ groupe_caractères ][ character_group ] Correspond à n'importe quel caractère unique de groupe_caractères.Matches any single character in character_group. Par défaut, la correspondance respecte la casse.By default, the match is case-sensitive. [ae] "a" dans "gras""a" in "gray"

"a", "e" dans "laine""a", "e" in "lane"
[^ groupe_caractères ][^ character_group ] Négation : correspond à n'importe quel caractère unique qui ne se trouve pas dans groupe_caractères.Negation: Matches any single character that is not in character_group. Par défaut, les caractères de groupe_caractères respectent la casse.By default, characters in character_group are case-sensitive. [^aei] "r", "g", "n" dans "règne""r", "g", "n" in "reign"
[ premier - last ][ first - last ] Plage de caractères : correspond à n'importe quel caractère unique dans la plage comprise entre premier et dernier.Character range: Matches any single character in the range from first to last. [A-Z] "A", "B" dans "AB123""A", "B" in "AB123"
. Caractère générique : correspond à tout caractère à l'exception de \n.Wildcard: Matches any single character except \n.

Pour faire correspondre un caractère littéral « point » (.To match a literal period character (. ou \u002E), vous devez le faire précéder du caractère d'échappement (\.).or \u002E), you must precede it with the escape character (\.).
a.e "ave" dans "navet""ave" in "nave"

"ate" dans "plate""ate" in "water"
\p{ name }\p{ name } Correspond à n'importe quel caractère unique de la catégorie générale Unicode ou du bloc nommé spécifié par name.Matches any single character in the Unicode general category or named block specified by name. \p{Lu}

\p{IsCyrillic}
"M", "G" dans "Mardi Gras""C", "L" in "City Lights"

"Д", "Ж" dans "ДЖem""Д", "Ж" in "ДЖem"
\P{ name }\P{ name } Correspond à n'importe quel caractère unique qui ne se trouve pas dans la catégorie générale Unicode ou le bloc nommé spécifié par name.Matches any single character that is not in the Unicode general category or named block specified by name. \P{Lu}

\P{IsCyrillic}
"a", "r", "d", "i" dans "Mardi""i", "t", "y" in "City"

"e", "m" dans "ДЖem""e", "m" in "ДЖem"
\w Correspond à n'importe quel caractère alphabétique.Matches any word character. \w "I", "D", "A", "1", "3" dans "ID A1.3""I", "D", "A", "1", "3" in "ID A1.3"
\W Correspond à tout caractère autre qu'un caractère de mot.Matches any non-word character. \W " ", "." dans "ID A1.3"" ", "." in "ID A1.3"
\s Correspond à tout caractère espace blanc.Matches any white-space character. \w\s "D " dans "ID A1.3""D " in "ID A1.3"
\S Correspond à tout caractère autre qu'un espace blanc.Matches any non-white-space character. \s\S " " dans "int ___ctr"" " in "int __ctr"
\d Correspond à n'importe quel chiffre décimal.Matches any decimal digit. \d "4" dans "4 = IV""4" in "4 = IV"
\D Correspond à n'importe quel caractère autre qu'un chiffre décimal.Matches any character other than a decimal digit. \D " ", "=", " ", "I", "V" dans "4 = IV"" ", "=", " ", "I", "V" in "4 = IV"

Retour au débutBack to top

AncresAnchors

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.Anchors, or atomic zero-width assertions, cause a match to succeed or fail depending on the current position in the string, but they do not cause the engine to advance through the string or consume characters. Les métacaractères répertoriés dans le tableau suivant sont des ancres.The metacharacters listed in the following table are anchors. Pour plus d'informations, consultez Ancres.For more information, see Anchors.

AssertionAssertion DescriptionDescription MotifPattern CorrespondancesMatches
^ 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.By default, the match must start at the beginning of the string; in multiline mode, it must start at the beginning of the line. ^\d{3} "901" dans"901" in

"901-333-""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.By default, the match must occur at the end of the string or before \n at the end of the string; in multiline mode, it must occur before the end of the line or before \n at the end of the line. -\d{3}$ "-333" dans"-333" in

"-901-333""-901-333"
\A La correspondance doit se produire au début de la chaîne.The match must occur at the start of the string. \A\d{3} "901" dans"901" in

"901-333-""901-333-"
\Z La correspondance doit se produire à la fin de la chaîne ou avant \n à la fin de la chaîne.The match must occur at the end of the string or before \n at the end of the string. -\d{3}\Z "-333" dans"-333" in

"-901-333""-901-333"
\z La correspondance doit se produire à la fin de la chaîne.The match must occur at the end of the string. -\d{3}\z "-333" dans"-333" in

"-901-333""-901-333"
\G La correspondance doit se produire à l'emplacement où la correspondance précédente s'est terminée.The match must occur at the point where the previous match ended. \G\(\d\) « (1) », « (3) », « (5) » dans « (1)(3)(5)[7](9) »"(1)", "(3)", "(5)" in "(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).The match must occur on a boundary between a \w (alphanumeric) and a \W (nonalphanumeric) character. \b\w+\s\w+\b "thèm thème", "thèm thèm" dans "thèm thème thèm thèm""them theme", "them them" in "them theme them them"
\B La correspondance ne doit pas se produire sur une limite \b .The match must not occur on a \b boundary. \Bend\w*\b "ends", "ender" dans "end sends endure lender""ends", "ender" in "end sends endure lender"

Retour au débutBack to top

Constructions de regroupementGrouping Constructs

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.Grouping constructs delineate subexpressions of a regular expression and typically capture substrings of an input string. Les constructions de regroupement incluent les éléments de langage répertoriés dans le tableau suivant.Grouping constructs include the language elements listed in the following table. Pour plus d'informations, consultez Grouping Constructs.For more information, see Grouping Constructs.

Construction de regroupementGrouping construct DescriptionDescription MotifPattern CorrespondancesMatches
( sous-expression )( subexpression ) Capture la sous-expression mise en correspondance et lui assigne un nombre ordinal de base un.Captures the matched subexpression and assigns it a one-based ordinal number. (\w)\1 "oo" dans "boot""ee" in "deep"
(?< name > sous-expression )(?< name > subexpression ) Capture la sous-expression mise en correspondance dans un groupe nommé.Captures the matched subexpression into a named group. (?<double>\w)\k<double> "oo" dans "boot""ee" in "deep"
(?< nom1 - nom2 > sous-expression )(?< name1 - name2 > subexpression ) Définit un équilibre de définition de groupe.Defines a balancing group definition. Pour plus d’informations, consultez la section « Équilibre de définition de groupe » dans Grouping Constructs.For more information, see the "Balancing Group Definition" section in Grouping Constructs. (((?'Open'\()[^\(\)]*)+((?'Close-Open'\))[^\(\)]*)+)*(?(Open)(?!))$ « ((1-3)*(3-1)) » dans « 3+2^((1-3)*(3-1)) »"((1-3)*(3-1))" in "3+2^((1-3)*(3-1))"
(?: sous-expression )(?: subexpression ) Définit un groupe sans capture.Defines a noncapturing group. Write(?:Line)? "WriteLine" dans "Console.WriteLine()""WriteLine" in "Console.WriteLine()"

"Write" dans "Console.Write(value)""Write" in "Console.Write(value)"
(?imnsx-imnsx: sous-expression )(?imnsx-imnsx: subexpression ) Active ou désactive les options spécifiées dans sous-expression.Applies or disables the specified options within subexpression. Pour plus d'informations, consultez Regular Expression Options.For more information, see Regular Expression Options. A\d{2}(?i:\w+)\b "A12xl", "A12XL" dans "A12xl A12XL a12xl""A12xl", "A12XL" in "A12xl A12XL a12xl"
(?= sous-expression )(?= subexpression ) Assertion de préanalyse positive de largeur nulle.Zero-width positive lookahead assertion. \w+(?=\.) "est", "courait", et "couché" dans "Il est."is", "ran", and "out" in "He is. Le chien courait.The dog ran. Le soleil est couché."The sun is out."
(?! sous-expression )(?! subexpression ) Assertion de préanalyse négative de largeur nulle.Zero-width negative lookahead assertion. \b(?!un)\w+\b "retourner", "utilisée" dans "retourner une unité utilisée""sure", "used" in "unsure sure unity used"
(?<= sous-expression )(?<= subexpression ) Assertion de postanalyse positive de largeur nulle.Zero-width positive lookbehind assertion. (?<=19)\d{2}\b "99", "50", "05" dans "1851 1999 1950 1905 2003""99", "50", "05" in "1851 1999 1950 1905 2003"
(?<! sous-expression )(?<! subexpression ) Assertion de postanalyse négative de largeur nulle.Zero-width negative lookbehind assertion. (?<!19)\d{2}\b "51", "03" dans "1851 1999 1950 1905 2003""51", "03" in "1851 1999 1950 1905 2003"
(?> sous-expression )(?> subexpression ) Sous-expressions de recherche non rétroactive (ou « gourmandes »).Nonbacktracking (or "greedy") subexpression. [13579](?>A+B+) "1ABB", "3ABB" et "5AB" dans "1ABB 3ABBC 5AB 5AC""1ABB", "3ABB", and "5AB" in "1ABB 3ABBC 5AB 5AC"

Retour au débutBack to top

QuantificateursQuantifiers

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.A quantifier specifies how many instances of the previous element (which can be a character, a group, or a character class) must be present in the input string for a match to occur. Les quantificateurs incluent les éléments de langage répertoriés dans le tableau suivant.Quantifiers include the language elements listed in the following table. Pour plus d'informations, consultez Quantifiers.For more information, see Quantifiers.

QuantifieurQuantifier DescriptionDescription MotifPattern CorrespondancesMatches
* Correspond zéro, une ou plusieurs fois à l'élément précédent.Matches the previous element zero or more times. \d*\.\d ".0", "19.9", "219.9"".0", "19.9", "219.9"
+ Correspond une ou plusieurs fois à l'élément précédent.Matches the previous element one or more times. "be+" "bee" dans "beefsteak", "be" dans "besoin""bee" in "been", "be" in "bent"
? Correspond zéro ou une fois à l'élément précédent.Matches the previous element zero or one time. "rai?n" "rang", "train""ran", "rain"
{ n }{ n } Correspond à l'élément précédent exactement n fois.Matches the previous element exactly n times. ",\d{3}" ",043" dans "1,043.6", ",876", ",543" et ",210" dans "9,876,543,210"",043" in "1,043.6", ",876", ",543", and ",210" in "9,876,543,210"
{ n ,}{ n ,} Correspond à l'élément précédent au moins n fois.Matches the previous element at least n times. "\d{2,}" "166", "29", "1930""166", "29", "1930"
{ n , m }{ n , m } Correspond à l'élément précédent au moins n fois, mais pas plus de m fois.Matches the previous element at least n times, but no more than m times. "\d{3,5}" "166", "17668""166", "17668"

"19302" dans "193024""19302" in "193024"
*? Correspond zéro fois ou plus à l'élément précédent, mais le moins de fois possible.Matches the previous element zero or more times, but as few times as possible. \d*?\.\d ".0", "19.9", "219.9"".0", "19.9", "219.9"
+? Correspond une ou plusieurs fois à l'élément précédent, mais le moins de fois possible.Matches the previous element one or more times, but as few times as possible. "be+?" "bee" dans "beefsteak", "be" dans "besoin""be" in "been", "be" in "bent"
?? Correspond zéro ou une fois à l'élément précédent, mais le moins de fois possible.Matches the previous element zero or one time, but as few times as possible. "rai??n" "rang", "train""ran", "rain"
{ n }?{ n }? Correspond exactement n fois à l'élément précédent.Matches the preceding element exactly n times. ",\d{3}?" ",043" dans "1,043.6", ",876", ",543" et ",210" dans "9,876,543,210"",043" in "1,043.6", ",876", ",543", and ",210" in "9,876,543,210"
{ n ,}?{ n ,}? Correspond au moins n fois à l'élément précédent, mais le moins de fois possible.Matches the previous element at least n times, but as few times as possible. "\d{2,}?" "166", "29", "1930""166", "29", "1930"
{ n , m }?{ n , m }? Correspond entre n et m fois à l'élément précédent, mais le moins de fois possible.Matches the previous element between n and m times, but as few times as possible. "\d{3,5}?" "166", "17668""166", "17668"

"193", "024" dans "193024""193", "024" in "193024"

Retour au débutBack to top

Constructions de référence arrièreBackreference Constructs

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.A backreference allows a previously matched subexpression to be identified subsequently in the same regular expression. Le tableau suivant répertorie les constructions de backreference prises en charge par les expressions régulières dans .NET.The following table lists the backreference constructs supported by regular expressions in .NET. Pour plus d'informations, consultez Backreference Constructs.For more information, see Backreference Constructs.

Construction de backreferenceBackreference construct DescriptionDescription MotifPattern CorrespondancesMatches
\ nombre\ number Backreference.Backreference. Correspond à la valeur d'une sous-expression numérotée.Matches the value of a numbered subexpression. (\w)\1 "ee" dans "seek""ee" in "seek"
\k< name >\k< name > Backreference nommée.Named backreference. Correspond à la valeur d'une expression nommée.Matches the value of a named expression. (?<char>\w)\k<char> "ee" dans "seek""ee" in "seek"

Retour au débutBack to top

Constructions d’alternativeAlternation Constructs

Les constructions d'alternative modifient une expression régulière pour permettre la correspondance de type inclusif/exclusif.Alternation constructs modify a regular expression to enable either/or matching. Ces constructions incluent les éléments de langage répertoriés dans le tableau suivant.These constructs include the language elements listed in the following table. Pour plus d'informations, consultez Alternation Constructs.For more information, see Alternation Constructs.

Construction d'alternativeAlternation construct DescriptionDescription MotifPattern CorrespondancesMatches
| Correspond à tout élément séparé par le caractère barre verticale (|).Matches any one element separated by the vertical bar (|) character. th(e|is|at) "the", "this" dans "this is the day. ""the", "this" in "this is the day. ""
(?( expression ) oui | non )(?( expression ) yes | no ) Correspond à oui si le modèle d'expression régulière indiqué par expression correspond ; sinon, correspond à no (facultatif).Matches yes if the regular expression pattern designated by expression matches; otherwise, matches the optional no part. expression est interprétée comme une assertion de largeur nulle.expression is interpreted as a zero-width assertion. (?(A)A\d{2}\b|\b\d{3}\b) "A10", "910" dans "A10 C103 910""A10", "910" in "A10 C103 910"
(?( nom ) oui | non )(?( name ) yes | no ) Correspond à oui si nom, un groupe de capture nommé ou numéroté, a une correspondance ; sinon, correspond à non(facultatif).Matches yes if name, a named or numbered capturing group, has a match; otherwise, matches the optional no. (?<quoted>")?(?(quoted).+?"|\S+\s) Dogs.jpg, "Yiska playing.jpg" dans "Dogs.jpg "Yiska playing.jpg""Dogs.jpg, "Yiska playing.jpg" in "Dogs.jpg "Yiska playing.jpg""

Retour au débutBack to top

SubstitutionsSubstitutions

Les substitutions sont des éléments de langage d'expression régulière pris en charge dans les modèles de remplacement.Substitutions are regular expression language elements that are supported in replacement patterns. Pour plus d'informations, consultez Substitutions.For more information, see Substitutions. Les métacaractères répertoriés dans le tableau suivant sont des assertions de largeur nulle atomiques.The metacharacters listed in the following table are atomic zero-width assertions.

CaractèreCharacter DescriptionDescription MotifPattern Modèle de remplacementReplacement pattern Chaîne d'entréeInput string Chaîne de résultatResult string
$ nombre$ number Remplace la sous-chaîne mise en correspondance par le groupe nombre.Substitutes the substring matched by group number. \b(\w+)(\s)(\w+)\b $3$2$1 "un deux""one two" "deux un""two one"
${ name }${ name } Remplace la sous-chaîne mise en correspondance par le groupe nommé nom.Substitutes the substring matched by the named group name. \b(?<word1>\w+)(\s)(?<word2>\w+)\b ${word2} ${word1} "un deux""one two" "deux un""two one"
$$ Remplace un "$" littéral.Substitutes a literal "$". \b(\d+)\s?USD $$$1 "103 USD""103 USD" "$103""$103"
$& Remplace une copie de la totalité de la correspondance.Substitutes a copy of the whole match. \$?\d*\.?\d+ **$&** "$1.30""$1.30" "**$1.30**""**$1.30**"
$` Remplace tout le texte de la chaîne d'entrée avant la correspondance.Substitutes all the text of the input string before the match. B+ $` "AABBCC""AABBCC" "AAAACC""AAAACC"
$' Remplace tout le texte de la chaîne d'entrée après la correspondance.Substitutes all the text of the input string after the match. B+ $' "AABBCC""AABBCC" "AACCCC""AACCCC"
$+ Remplace le dernier groupe qui a été capturé.Substitutes the last group that was captured. B+(C+) $+ "AABBCCDD""AABBCCDD" AACCDDAACCDD
$_ Remplace la chaîne d'entrée entière.Substitutes the entire input string. B+ $_ "AABBCC""AABBCC" "AAAABBCCCC""AAAABBCCCC"

Retour au débutBack to top

Options des expressions régulièresRegular Expression Options

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.You can specify options that control how the regular expression engine interprets a regular expression pattern. 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 .Many of these options can be specified either inline (in the regular expression pattern) or as one or more RegexOptions constants. Cette référence rapide répertorie uniquement les options inline.This quick reference lists only inline options. Pour plus d’informations sur les options inline et RegexOptions , consultez l’article Regular Expression Options.For more information about inline and RegexOptions options, see the article Regular Expression Options.

Vous pouvez spécifier une option inline de deux façons :You can specify an inline option in two ways:

  • À l’aide d’une construction diverse (?imnsx-imnsx), où un signe moins (-) devant une option ou un jeu d’options désactive ces options.By using the miscellaneous construct (?imnsx-imnsx), where a minus sign (-) before an option or set of options turns those options off. 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).For example, (?i-mn) turns case-insensitive matching (i) on, turns multiline mode (m) off, and turns unnamed group captures (n) off. 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.The option applies to the regular expression pattern from the point at which the option is defined, and is effective either to the end of the pattern or to the point where another construct reverses the option.

  • À l’aide d’une grouping construct(?imnsx-imnsx:sous-expression), qui définit des options uniquement pour le groupe spécifié.By using the grouping construct(?imnsx-imnsx:subexpression), which defines options for the specified group only.

Le moteur d’expression régulière de .NET prend en charge les options inline suivantes.The .NET regular expression engine supports the following inline options.

OptionOption DescriptionDescription MotifPattern CorrespondancesMatches
i Utilise la correspondance qui ne respecte pas la casse.Use case-insensitive matching. \b(?i)a(?-i)a\w+\b « aardvark », « aaaAuto » dans « aardvark AAAuto aaaAuto Adam breakfast »"aardvark", "aaaAuto" in "aardvark AAAuto aaaAuto Adam breakfast"
m Utilise le mode multiligne.Use multiline mode. ^ et $ correspondent au début et à la fin d'une ligne, au lieu du début et de la fin d'une chaîne.^ and $ match the beginning and end of a line, instead of the beginning and end of a string. Pour obtenir un exemple, consultez la section « Mode multiligne » dans Regular Expression Options.For an example, see the "Multiline Mode" section in Regular Expression Options.
n Ne capture aucun groupe sans nom.Do not capture unnamed groups. Pour obtenir un exemple, consultez la section « Captures explicites uniquement » dans Regular Expression Options.For an example, see the "Explicit Captures Only" section in Regular Expression Options.
s Utilise le mode à ligne simple.Use single-line mode. Pour obtenir un exemple, consultez la section « Mode à ligne simple » dans Regular Expression Options.For an example, see the "Single-line Mode" section in Regular Expression Options.
x Ignore l'espace blanc sans séquence d'échappement dans le modèle d'expression régulière.Ignore unescaped white space in the regular expression pattern. \b(?x) \d+ \s \w+ « 1 aardvark », « 2 cats » dans « 1 aardvark 2 cats IV centurions »"1 aardvark", "2 cats" in "1 aardvark 2 cats IV centurions"

Retour au débutBack to top

Constructions diversesMiscellaneous Constructs

Diverses constructions modifient un modèle d'expression régulière ou fournissent des informations le concernant.Miscellaneous constructs either modify a regular expression pattern or provide information about it. Le tableau suivant répertorie les diverses constructions prises en charge par .NET.The following table lists the miscellaneous constructs supported by .NET. Pour plus d'informations, consultez Miscellaneous Constructs.For more information, see Miscellaneous Constructs.

ConstructionConstruct DéfinitionDefinition ExempleExample
(?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.Sets or disables options such as case insensitivity in the middle of a pattern.For more information, see Regular Expression Options. \bA(?i)b\w+\b correspond à "ABA", "Able" dans "ABA Able Act"\bA(?i)b\w+\b matches "ABA", "Able" in "ABA Able Act"
(?# commentaire )(?# comment ) Commentaire inline.Inline comment. Le commentaire se termine à la première parenthèse fermante.The comment ends at the first closing parenthesis. \bA(?#Matches words starting with A)\w+\b
# [to end of line]# [to end of line] Commentaire en mode X.X-mode comment. Le commentaire commence au caractère # sans séquence d'échappement et se poursuit jusqu'à la fin de la ligne.The comment starts at an unescaped # and continues to the end of the line. (?x)\bA\w+\b#Matches words starting with A

Voir aussiSee Also

System.Text.RegularExpressions
Regex
Expressions régulièresRegular Expressions
Classes d'expressions régulièresRegular Expression Classes
Exemples d'expressions régulièresRegular Expression Examples
Expressions régulières - Aide-mémoire (téléchargement au format Word)Regular Expressions - Quick Reference (download in Word format)
Expressions régulières - Aide-mémoire (téléchargement au format PDF)Regular Expressions - Quick Reference (download in PDF format)