Partager via

Expressions régulières (C++)

  • Article

La bibliothèque standard C++ prend en charge plusieurs grammaires d’expression régulière. Cette rubrique décrit les variations de grammaire disponibles lors de l’utilisation d’expressions régulières.

Grammaire d’expression régulière

La grammaire d’expression régulière à utiliser est spécifiée par l’utilisation de l’une std::regex_constants::syntax_option_type des valeurs d’énumération. Ces grammaires d’expression régulière sont définies dans std::regex_constants:

  • ECMAScript: ceci est le plus proche de la grammaire utilisée par JavaScript et les langages .NET.
  • basic: expressions régulières POSIX basic ou BRE.
  • extended: expressions régulières POSIX extended ou ERE.
  • awk: Il s’agit extended, mais il a plus d’échappements pour les caractères non imprimables.
  • grep: Il s’agit basic, mais il permet également aux caractères newline (\n) de séparer les altercations.
  • egrep: C’est extended, mais il permet également aux caractères de ligne de séparer les altercations.

Par défaut, si aucune grammaire n’est spécifiée, ECMAScript elle est supposée. Une seule grammaire peut être spécifiée.

Plusieurs indicateurs peuvent également être appliqués :

  • icase: ignorer la casse lors de la correspondance.
  • nosubs: Ignorer les correspondances marquées (autrement dit, les expressions entre parenthèses) ; aucune substitution n’est stockée.
  • optimize: Rendre la correspondance plus rapide, au détriment possible d’une plus grande durée de construction.
  • collate: utilisez des séquences de classement sensibles aux paramètres régionaux (par exemple, des plages du formulaire [a-z]).

Zéro ou plusieurs indicateurs peuvent être combinés avec la grammaire pour spécifier le comportement du moteur d’expression régulière. Si seuls les indicateurs sont spécifiés, ECMAScript est considéré comme la grammaire.

Élément

Un élément peut être l’un des éléments suivants :

  • Caractère ordinaire qui correspond au même caractère dans la séquence cible.

  • Caractère générique '.' qui correspond à n’importe quel caractère de la séquence cible, à l’exception d’une nouvelle ligne.

  • Expression de crochet du formulaire [expr], qui correspond à un caractère ou à un élément de classement dans la séquence cible qui se trouve également dans l’ensemble défini par l’expression expr, ou du formulaire [^expr], qui correspond à un caractère ou un élément de classement dans la séquence cible qui n’est pas dans le jeu défini par l’expression expr.

    L’expression expr peut contenir n’importe quelle combinaison des éléments suivants :

    • Un caractère individuel. Ajoute le caractère au jeu défini par expr.

    • Plage de caractères du formulaire ch1-ch2. Ajoute les caractères représentés par les valeurs de la plage [ch1, ch2] fermée au jeu défini par expr.

    • Classe de caractères du formulaire [:name:]. Ajoute les caractères de la classe nommée au jeu défini par expr.

    • Classe d’équivalence du formulaire [=elt=]. Ajoute les éléments de classement qui sont équivalents à elt au jeu défini par expr.

    • Symbole de classement du formulaire [.elt.]. Ajoute l'élément de classement elt au jeu défini par expr.

  • Une ancre. L’ancre ^ correspond au début de la séquence cible. L’ancre $ correspond à la fin de la séquence cible.

Groupe de capture du formulaire (sous-expression), ou \(subexpression\) dans basic et grep, qui correspond à la séquence de caractères dans la séquence cible qui est mise en correspondance par le modèle entre les délimiteurs.

  • Échappement d’identité du formulaire\k, qui correspond au caractère k de la séquence cible.

Exemples :

  • a correspond à la séquence "a" cible, mais ne correspond pas aux séquences "B"cibles , "b"ou "c".

  • .correspond à toutes les séquences "a"cibles, , "B""b"et "c".

  • [b-z] correspond aux séquences "b" cibles et "c" ne correspond pas aux séquences "a" cibles ou "B".

  • [:lower:] correspond aux séquences "a"cibles, "b"et "c" ne correspond pas à la séquence "B"cible.

  • (a) correspond à la séquence cible et associe le groupe de capture 1 à la sous-séquence "a" "a", mais ne correspond pas aux séquences "B"cibles , "b"ou "c".

Dans ECMAScript, basicet , et grep, un élément peut également être une référence arrière du formulaire \dd, où dd représente une valeur décimale N qui correspond à une séquence de caractères dans la séquence cible qui est identique à la séquence de caractères qui est mise en correspondance par le groupe de capture Nth.

Par exemple, (a)\1 correspond à la séquence "aa" cible, car le premier (et seul) groupe de capture correspond à la séquence "a" initiale, puis correspond \1 à la séquence "a"finale.

Dans ECMAScript, un élément peut également être l’un des éléments suivants :

  • Groupe non capturé du formulaire ( ?: sous-expression). Correspond à la séquence de caractères de la séquence cible qui correspond au modèle situé entre les délimiteurs.

  • Une séquence d’échappement de format de fichier limitée du formulaire \f, , \r\n, \tou \v. Ces derniers correspondent, respectivement, à un saut de page, un saut de ligne, un retour chariot, une tabulation horizontale et une tabulation verticale, dans la séquence cible.

  • Assertion positive du formulaire (= sous-expression). Correspond à la séquence de caractères de la séquence cible qui correspond au modèle entre les délimiteurs, mais ne modifie pas la position de correspondance dans la séquence cible.

  • Une affirmation négative de la forme ( ! sous-expression). Correspond à n’importe quelle séquence de caractères de la séquence cible qui ne correspond pas au modèle entre les délimiteurs et ne modifie pas la position de correspondance dans la séquence cible.

  • Séquence d’échappement hexadécimale du formulaire \xhh. Correspond à un caractère de la séquence cible qui est représenté par les deux chiffres hexadécimaux hh.

  • Séquence d’échappement Unicode du formulaire \uhhhh. Correspond à un caractère de la séquence cible qui est représenté par les quatre chiffres hexadécimaux hhhh.

  • Séquence d’échappement de contrôle du formulaire \ck. Correspond au caractère de contrôle nommé par le caractère k.

  • Assertion de limite de mot du formulaire\b. Correspond à la position actuelle dans la séquence cible qui est située immédiatement après une limite de mot.

  • Assertion de limite de mot négative de la forme \B. Correspond lorsque la position actuelle dans la séquence cible n’est pas immédiatement après une limite de mot.

  • Échappement de caractère dsw du formulaire \d, , \D\s\S, , \w, \W. Fournit un nom court pour une classe de caractères.

Exemples :

  • (?:a) correspond à la séquence "a"cible, mais "(?:a)\1" n’est pas valide, car il n’y a pas de groupe de capture 1.

  • (=a)a correspond à la séquence "a"cible . L’assertion positive correspond à la séquence "a" initiale de la séquence cible et la dernière "a" dans l’expression régulière correspond à la séquence "a" initiale de la séquence cible.

  • (!a)a ne correspond pas à la séquence "a"cible .

  • a\b. correspond à la séquence "a~"cible, mais ne correspond pas à la séquence "ab"cible.

  • a\B. correspond à la séquence "ab"cible, mais ne correspond pas à la séquence "a~"cible.

Dans awk, un élément peut également être l’un des éléments suivants :

  • Échappement de format de fichier du formulaire \\ , , \a, \f\b\n, \r, , \t, ou \v. Ces derniers correspondent, respectivement, à une barre oblique inverse, une alerte, un retour arrière, un saut de page, un saut de ligne, un retour chariot, une tabulation horizontale et une tabulation verticale, dans la séquence cible.

  • Séquence d’échappement octale du formulaire \ooo. Correspond à un caractère de la séquence cible qui est représenté par la valeur ooo d'un, deux ou trois chiffres octaux.

Répétition

Tous les éléments autres qu’une assertion positive, une assertion négative ou une ancre peuvent être suivis par un nombre de répétitions. Le type de répétition le plus général prend la forme {min,max}, ou \{min,max\} dans basic et grep. Un élément suivi de cette forme de nombre de répétitions correspond à au moins un minimum d’occurrences successives et pas plus d’occurrences successives maximales d’une séquence qui correspond à l’élément.

Par exemple, a{2,3} correspond à la séquence "aa" cible et à la séquence "aaa"cible, mais pas à la séquence "a" cible ou à la séquence "aaaa"cible.

Un nombre de répétitions peut également prendre l'une des formes suivantes :

  • {min} ou \{min} dans basic et grep. Équivalent à {min,min}.

  • {min,} ou \{min,\} dans basic et grep. Équivalent à {min,unbounded}.

  • *équivaut à {0,unbounded}.

Exemples :

  • a{2} correspond à la séquence "aa" cible, mais pas à la séquence "a" cible ou à la séquence "aaa"cible.

  • a{2,} correspond à la séquence "aa"cible, à la séquence "aaa"cible, et ainsi de suite, mais ne correspond pas à la séquence "a"cible.

  • a* correspond à la séquence ""cible, à la séquence "a"cible, à la séquence "aa"cible, et ainsi de suite.

Pour toutes les grammaires, sauf basic et grep, un nombre de répétitions peut également prendre l'une des formes suivantes :

  • ? est équivalent à {0,1}.

  • +équivaut à {1,unbounded}.

Exemples :

  • a? correspond à la séquence "" cible et à la séquence "a"cible, mais pas à la séquence "aa"cible.

  • a+ correspond à la séquence "a"cible, à la séquence "aa"cible, et ainsi de suite, mais pas à la séquence ""cible.

Dans ECMAScript, toutes les formes de nombre de répétitions peuvent être suivies par le caractère ? qui désigne une répétition non gourmande.

Concaténation

Les éléments d’expression régulière, avec ou sans nombre de répétitions, peuvent être concaténés pour former de plus longues expressions régulières. L'expression résultante correspond à une séquence cible qui est une concaténation des séquences auxquelles correspondent les éléments.

Par exemple, a{2,3}b correspond à la séquence "aab" cible et à la séquence "aaab"cible, mais ne correspond pas à la séquence "ab" cible ou à la séquence "aaaab"cible.

Alternative

Dans toutes les grammaires d’expression régulière sauf basic et grep, une expression régulière concaténée peut être suivie du caractère | (canal) et d’une autre expression régulière concaténée. Le nombre d'expressions régulières concaténées pouvant être combinées de cette manière est illimité. L'expression résultante correspond à n'importe quelle séquence cible qui correspond à une ou plusieurs expressions régulières concaténées.

Lorsque plusieurs expressions régulières concaténées correspondent à la séquence cible, ECMAScript choisissez la première des expressions régulières concaténées qui correspondent à la séquence comme correspondance, qui sera appelée première correspondance. Les autres grammaires d’expression régulière choisissent celle qui obtient la correspondance la plus longue.

Par exemple, ab|cd correspond à la séquence "ab" cible et à la séquence "cd"cible, mais ne correspond pas à la séquence "abd" cible ou à la séquence "acd"cible.

Dans grep et egrep, un caractère de nouvelle ligne (\n) peut être utilisé pour séparer les altercations.

Sous-expression

Dans basic et grep, une sous-expression est une concaténation. Dans les autres grammaires d'expressions régulières, une sous-expression est une alternative.

Résumé de grammaire

Le tableau suivant résume les fonctionnalités disponibles dans les différentes grammaires d’expressions régulières :

Élément basic extended ECMAScript grep egrep awk
alternation à l’aide de | + + + +
alternation à l’aide de \n + +
ancre + + + + + +
référence arrière + + +
expression entre crochets + + + + + +
groupe de capture à l’aide de () + + + +
groupe de capture à l’aide de \(\) + +
séquence Contrôle Échap +
caractère d'échappement dsw +
échappement de format de fichier + +
séquence d'échappement hexadécimale +
échappement d'identité + + + + + +
assertion négative +
assertion négative de limite de mot +
groupe de non capture +
répétition non gourmande +
séquence d'échappement octale +
caractère ordinaire + + + + + +
assertion positive +
répétition à l’aide de {} + + + +
répétition à l’aide de \{\} + +
répétition à l’aide de * + + + + + +
répétition à l’aide ? et + + + + +
séquence d'échappement Unicode +
caractère générique + + + + + +
assertion de limite de mot +

Détails sémantiques

Ancre

Une ancre correspond à une position dans la chaîne cible, et non à un caractère. Correspond ^ au début de la chaîne cible et $ correspond à la fin de la chaîne cible.

Référence de retour

Une référence arrière est une barre oblique inverse suivie par une valeur décimale N. Elle correspond au contenu du Nième groupe de capture. La valeur N ne doit pas dépasser le nombre de groupes de capture qui précèdent la référence arrière. Dans basic et grep, la valeur N est déterminée par le chiffre décimal qui suit la barre oblique inverse. Dans ECMAScript, la valeur N est déterminée par le nombre total de chiffres décimaux qui suivent immédiatement la barre oblique inverse. Par conséquent, dans basic et grep, la valeur N n'est jamais supérieure à 9, même si l'expression régulière contient plus de neuf groupes de capture. Dans ECMAScript, la valeur N est illimitée.

Exemples :

  • ((a+)(b+))(c+)\3 correspond à la séquence "aabbbcbbb"cible . La référence \3 arrière correspond au texte du troisième groupe de capture, c’est-à-dire le "(b+)". Elle ne correspond pas à la séquence "aabbbcbb"cible.

  • (a)\2 n’est pas valide.

  • (b(((((((((a))))))))))\10 a des significations différentes dans basic et en ECMAScript. Dans basic, la référence arrière est \1. La référence arrière correspond au contenu du premier groupe de captures (c’est-à-dire celui qui commence (b par et se termine par le final ) et arrive avant la référence arrière), et le final 0 correspond au caractère 0ordinaire. Dans ECMAScript, la référence arrière est \10. Elle correspond au dixième groupe de capture, c'est-à-dire, le plus profond.

Expression entre crochets

Une expression entre crochets définit un jeu de caractères et des éléments de classement. Lorsque l’expression de crochet commence par le caractère ^ , la correspondance réussit si aucun élément du jeu ne correspond au caractère actuel dans la séquence cible. Sinon, la correspondance aboutit si l'un des éléments du jeu correspond au caractère actuel de la séquence cible.

Le jeu de caractères peut être défini en spécifiant une combinaison de caractères individuels, de plages de caractères, de classes de caractères, de classes d’équivalence et de symboles de classement.

Groupe de capture

Un groupe de capture marque son contenu en tant qu'unité dans la grammaire d'expressions régulières, et étiquette le texte cible qui correspond à son contenu. Le nom associé à chaque groupe de capture est un nombre, qui est déterminé par le nombre de parenthèses ouvrantes qui marquent les groupes de capture jusqu'à la parenthèse ouvrante (incluse) qui marque le groupe de capture actuel. Dans cette implémentation, le nombre maximal de groupes de capture est 31.

Exemples :

  • ab+ correspond à la séquence "abb"cible, mais ne correspond pas à la séquence "abab"cible.

  • (ab)+ ne correspond pas à la séquence "abb"cible, mais correspond à la séquence "abab"cible .

  • ((a+)(b+))(c+) correspond à la séquence "aabbbc" cible et associe le groupe de capture 1 au sous-file d’attente "aabbb", le groupe de capture 2 avec la sous-séquence "aa", le groupe de capture 3 et "bbb"le groupe de capture 4 avec la sous-séquence "c".

Classe de caractères

Dans une expression entre crochets, une classe de caractères ajoute tous les caractères de la classe nommée au jeu de caractères défini par l'expression entre crochets. Pour créer une classe de caractères, utilisez [: le nom de la classe, suivi de :].

En interne, les noms des classes de caractères sont identifiés par l'appel à id = traits.lookup_classname. Un caractère ch appartient à une telle classe si traits.isctype(ch, id) retourne true. Le modèle regex_traits par défaut prend en charge les noms de classes répertoriés dans le tableau suivant.

Nom de la classe Description
alnum minuscules, majuscules et chiffres
alpha minuscules et majuscules
blank espace ou tabulation
cntrl caractères d’échappement de format de fichier
digit chiffres
graph minuscules, majuscules, chiffres et ponctuation
lower minuscules
print minuscules, majuscules, chiffres, ponctuation et espaces
punct ponctuation
space espace
upper majuscules
xdigit chiffres, , a, bc, , dfDBEeAC,F
d identique à digit
s identique à space
w identique à alnum

Plage de caractères

Dans une expression entre crochets, une plage de caractères ajoute tous les caractères de la plage au jeu de caractères défini par l'expression entre crochets. Pour créer une plage de caractères, placez le caractère '-' entre les premiers et les derniers caractères de la plage. Une plage de caractères place tous les caractères dont la valeur numérique est supérieure ou égale à la valeur numérique du premier caractère, et inférieure ou égale à la valeur numérique du dernier caractère, dans l’ensemble. Notez que ce jeu de caractères ajoutés dépend de la représentation de caractères spécifique à la plateforme. Si le caractère '-' se produit au début ou à la fin d’une expression de crochet, ou en tant que premier ou dernier caractère d’une plage de caractères, il se représente lui-même.

Exemples :

  • [0-7]représente l’ensemble de caractères { 0, , 34251, 6, } . 7 Il correspond aux séquences "0"cibles, "1"et ainsi de suite, mais pas "a".

  • Sur les systèmes qui utilisent l’encodage de caractères ASCII, [h-k] représente l’ensemble de caractères { h, i, jk } . Il correspond aux séquences "h"cibles, "i"et ainsi de suite, mais pas "\x8A" ou "0".

  • Sur les systèmes qui utilisent l’encodage de caractères EBCDIC, [h-k] représente l’ensemble de caractères { h, , '\x8F''\x8D''\x8A''\x8C''\x8B''\x8E'i, '\x90', , j, k } (h est encodé en tant que et k encodé en tant que ).0x88 0x92 Il correspond aux séquences "h"cibles , "i", "\x8A"et ainsi de suite, mais pas "0".

  • [-0-24] représente l’ensemble de caractères { -, 0, 1, 2} 4 .

  • [0-2-] représente l’ensemble de caractères { 0, 1, 2} - .

  • Sur les systèmes qui utilisent l’encodage de caractères ASCII, [+--] représente l’ensemble de caractères { + , - }.

Toutefois, lorsque des plages respectant les paramètres régionaux sont utilisées, les caractères d'une plage sont déterminés par les règles de classement des paramètres régionaux. Les caractères qui sont classés après le premier caractère de la définition de la plage et avant le dernier caractère de la définition de la plage se trouvent dans le jeu. Les deux caractères de fin sont également dans le jeu.

Élément de classement

Un élément de classement est une séquence de plusieurs caractères qui est traitée comme un caractère unique.

Symbole de classement

Un symbole de classement d’une expression entre crochets ajoute un élément de classement au jeu défini par l’expression entre crochets. Pour créer un symbole de classement, utilisez [. l’élément de classement, suivi de l’élément de classement, puis .]

Séquence d’échappement de contrôle

Une séquence d’échappement de contrôle est une barre oblique inverse suivie de la lettre 'c' suivie de l’une des lettres 'a' à travers 'z' ou 'A' à travers 'Z'. Correspond au caractère de contrôle ASCII nommé par la lettre. Par exemple, "\ci" correspond à la séquence "\x09"cible, car Ctrl+I a la valeur 0x09.

Échappement de caractères DSW

Un caractère d'échappement dsw est un nom court donné à une plage de caractères, comme indiqué dans le tableau suivant.

Séquence d'échappement Classe nommée équivalente Classe nommée par défaut
\d [[:d:]] [[:digit:]]
\D [^[:d:]] [^[:digit:]]
\s [[:s:]] [[:space:]]
\S [^[:s:]] [^[:space:]]
\w [[:w:]] [a-zA-Z0-9_]*
\W [^[:w:]] [^a-zA-Z0-9_]*

* jeu de caractères ASCII

Classe d’équivalence

Dans une expression entre crochets, une classe d’équivalence ajoute au jeu défini par l’expression entre crochets, tous les caractères et éléments de classement équivalents à l’élément de classement dans la définition de classe d’équivalence.

Pour créer une classe d’équivalence, utilisez [= suivi d’un élément de classement suivi de =]. En interne, les deux éléments de classement elt1 et elt2 sont équivalents si traits.transform_primary(elt1.begin(), elt1.end()) == traits.transform_primary(elt2.begin(), elt2.end()).

Échappement au format de fichier

Une échappement au format de fichier se compose des séquences d’échappement de caractères de langage C habituelles, , \\, \a, \b, \f, \n, \r, \t, . \v Ils ont les significations habituelles, c’est-à-dire, barre oblique inverse, alerte, arrière-plan, flux de formulaire, nouvelle ligne, retour chariot, onglet horizontal et onglet vertical, respectivement. Dans ECMAScript, \a et \b ne sont pas autorisés. (\\ est autorisé, mais il s’agit d’une échappement d’identité, et non d’une échappement au format de fichier).

Séquence d’échappement hexadécimale

Une séquence d’échappement hexadécimale est une barre oblique inverse suivie de la lettre x suivie de deux chiffres hexadécimaux (0-9a-fA-F). Elle correspond à un caractère dans la séquence cible dont la valeur est spécifiée par les deux chiffres.

Par exemple, "\x41" correspond à la séquence "a" cible lorsque l’encodage de caractères ASCII est utilisé.

Échappement d’identité

Un échappement d'identité est une barre oblique inverse suivie d'un caractère unique. Elle correspond à ce caractère. Il est nécessaire lorsque le caractère a une signification particulière. L’utilisation de l’échappement d’identité supprime la signification spéciale. Par exemple :

  • a* correspond à la séquence "aaa"cible, mais ne correspond pas à la séquence "a*"cible.

  • a\* ne correspond pas à la séquence "aaa"cible, mais correspond à la séquence "a*"cible .

Le jeu de caractères autorisés dans un échappement d'identité dépend de la grammaire d'expression régulière, comme indiqué dans le tableau suivant.

Grammaire Caractères autorisés d'échappement d'identité
basic, grep { ( $ ^ * [ } \ ) { . }
extended, egrep { ( | ? + $ ^ \ . * ) { [ }
awk, extended plus { } " /
ECMAScript Tous les caractères à l'exception de ceux pouvant faire partie d'un identificateur. En règle générale, cela inclut des lettres, des chiffres, $_des séquences d’échappement Unicode et des séquences d’échappement Unicode. Pour plus d’informations, consultez la ECMAScript spécification du langage.

Caractère individuel

Dans une expression entre crochets, un caractère individuel ajoute ce caractère au jeu de caractères défini par l'expression entre crochets. N’importe où dans une expression entre crochets, sauf au début, un ^ représente lui-même.

Exemples :

  • [abc] correspond aux séquences "a"cibles , "b"et "c", mais pas à la séquence "d".

  • [^abc] correspond à la séquence "d"cible, mais pas aux séquences "a"cibles , "b"ou "c".

  • [a^bc] correspond aux séquences "a"cibles , "b", "c"et "^", mais pas à la séquence "d"cible .

Dans toutes les grammaires d’expression régulière, sauf ECMAScriptsi un ] caractère est le premier caractère qui suit l’ouverture [ ou est le premier caractère qui suit un initial ^, il se représente lui-même.

Exemples :

  • []a n’est pas valide, car il n’y a pas ] de fin d’expression entre crochets.

  • []abc] correspond aux séquences "a"cibles , "b", "c"et "]", mais pas à la séquence "d"cible .

  • [^]abc]correspond à la séquence "d"cible, mais pas aux séquences "a"cibles , "b"ou "c""]".

Dans ECMAScript, utilisez \] pour représenter le caractère ] d’une expression entre crochets.

Exemples :

  • []a correspond à la séquence "a" cible, car l’expression de crochet est vide.

  • [\]abc] correspond aux séquences "a"cibles , "b", "c"et "]" pas à la séquence "d"cible .

Assertion négative

Une assertion négative peut représenter n'importe quel élément, à l'exception de son contenu. Elle ne consomme aucun caractère dans la séquence cible.

Par exemple, (!aa)(a*) correspond à la séquence cible et associe le groupe de capture 1 à la sous-file "a" d’attente "a". Elle ne correspond pas à la séquence "aa" cible ou à la séquence "aaa"cible.

Assertion de limite de mot négative

Une assertion de limite de mot négative correspond si la position actuelle dans la chaîne cible n’est pas immédiatement après une limite de mot.

Groupe de non-capture

Un groupe non capturé marque son contenu comme une seule unité dans la grammaire d’expression régulière, mais n’étiquette pas le texte cible.

Par exemple, (a)(?:b)*(c) correspond au texte "abbc" cible et associe le groupe de capture 1 au sous-file d’attente "a" et le groupe de capture 2 avec la sous-séquence "c".

Répétition non gourmande

Une répétition non gourmande consomme la sous-séquence la plus courte de la séquence cible qui correspond au modèle. Une répétition gourmande consomme la sous-séquence la plus longue. Par exemple, (a+)(a*b) correspond à la séquence "aaab"cible .

Lorsqu’une répétition non gourmande est utilisée, elle associe le groupe de capture 1 à la sous-séquence "a" au début de la séquence cible et le groupe de capture 2 avec la sous-séquence "aab" à la fin de la séquence cible.

Lorsqu’une correspondance gourmande est utilisée, elle associe le groupe de capture 1 à la sous-séquence "aaa" et le groupe de capture 2 à la sous-séquence "b".

Séquence d’échappement octal

Une séquence d'échappement octale est une barre oblique inverse suivie de un, deux ou trois chiffres octaux (0-7). Elle correspond à un caractère dans la séquence cible dont la valeur est spécifiée par ces chiffres. Si tous les chiffres sont 0, la séquence n’est pas valide.

Par exemple, \101 correspond à la séquence "a" cible lorsque l’encodage de caractères ASCII est utilisé.

Caractère ordinaire

Un caractère ordinaire est un caractère valide qui n’a pas de signification particulière dans la grammaire actuelle.

Dans ECMAScript, les caractères suivants ont une signification particulière :

  • ^ $ \ . * + ? ( ) [ ] { } |

Dans basic et grep, les caractères suivants ont une signification particulière :

  • . [ \

basic En outre, les grepcaractères suivants ont des significations spéciales lorsqu’ils sont utilisés dans un contexte particulier :

  • * a une signification spéciale dans tous les cas, sauf lorsqu’il s’agit du premier caractère d’une expression régulière ou du premier caractère qui suit un initial ^ dans une expression régulière, ou lorsqu’il s’agit du premier caractère d’un groupe de capture ou du premier caractère qui suit un initial ^ dans un groupe de capture.

  • ^ a une signification spéciale lorsqu’il s’agit du premier caractère d’une expression régulière.

  • $ a une signification spéciale lorsqu’il s’agit du dernier caractère d’une expression régulière.

Dans extended, egrep et awk, les caractères suivants ont une signification particulière :

  • . [ \ ( * + ? { |

En outre, dans extended, egrepet , les awkcaractères suivants ont des significations spéciales lorsqu’ils sont utilisés dans un contexte particulier.

  • ) a une signification spéciale lorsqu’il correspond à un précédent (

  • ^ a une signification spéciale lorsqu’il s’agit du premier caractère d’une expression régulière.

  • $ a une signification spéciale lorsqu’il s’agit du dernier caractère d’une expression régulière.

Un caractère ordinaire correspond au même caractère situé dans la séquence cible. Par défaut, cela signifie que la correspondance aboutit si les deux caractères sont représentés par la même valeur. Dans une correspondance respectant la casse, les deux caractères ch0 et ch1 correspondent si traits.translate_nocase(ch0) == traits.translate_nocase(ch1). Dans une correspondance respectant les paramètres régionaux, les deux caractères ch0 et ch1 correspondent si traits.translate(ch0) == traits.translate(ch1).

Assertion positive

Une assertion positive correspond à son contenu, mais ne consomme aucun caractère dans la séquence cible.

Exemples :

  • (=aa)(a*) correspond à la séquence "aaaa" cible et associe le groupe de capture 1 au sous-séquence "aaaa".

  • (aa)(a*) correspond à la séquence "aaaa" cible et associe le groupe de capture 1 au sous-séquence "aa" au début de la séquence cible et le groupe de capture 2 avec la sous-séquence "aa" à la fin de la séquence cible.

  • (=aa)(a)|(a) correspond à la séquence "a" cible et associe le groupe de capture 1 à une séquence vide (car l’assertion positive a échoué) et le groupe de capture 2 avec la sous-séquence "a". Il correspond également à la séquence cible et associe le groupe de capture 1 avec la sous-séquence "aa" "aa" et le groupe de capture 2 avec une séquence vide.

Séquence d’échappement Unicode

Une séquence d’échappement Unicode est une barre oblique inverse suivie de la lettre 'u' suivie de quatre chiffres hexadécimaux (0-9a-fA-F). Elle correspond à un caractère dans la séquence cible dont la valeur est spécifiée par les quatre chiffres. Par exemple, \u0041 correspond à la séquence "a" cible lorsque l’encodage de caractères ASCII est utilisé.

Caractère générique

Un caractère générique correspond à n'importe quel caractère de l'expression cible, à l'exception du saut de ligne.

Limite word

Une limite de mot apparaît dans les situations suivantes :

  • Le caractère actuel se situe au début de la séquence cible, et fait partie des caractères alphabétiques A-Za-z0-9_

  • Le caractère actuel se situe après la fin de la séquence cible, et le dernier caractère de la séquence cible est l'un des caractères alphabétiques.

  • Le caractère actuel est l’un des caractères de mot et le caractère précédent n’est pas.

  • Le caractère actuel n’est pas l’un des caractères du mot et le caractère précédent est.

Assertion de limite word

Une assertion de limite de mot aboutit si la position actuelle dans la chaîne cible est située immédiatement après une limite de mot.

Correspondance et recherche

Pour qu'une expression régulière corresponde à une séquence cible, l'expression régulière dans son intégralité doit correspondre à la séquence cible dans son intégralité. Par exemple, l’expression bcd régulière correspond à la séquence "bcd" cible, mais ne correspond pas à la séquence "abcd" cible ni à la séquence "bcde"cible.

Pour qu'une recherche d'expression régulière aboutisse, la séquence cible doit contenir une sous-séquence qui corresponde à l'expression régulière. En général, la recherche trouve la sous-séquence correspondante située la plus à gauche.

Exemples :

  • Une recherche de l’expression bcd régulière dans la séquence "bcd" cible réussit et correspond à l’intégralité de la séquence. La même recherche dans la séquence "abcd" cible réussit également et correspond aux trois derniers caractères. La même recherche dans la séquence "bcde" cible réussit également et correspond aux trois premiers caractères.

  • Une recherche de l’expression bcd régulière dans la séquence "bcdbcd" cible réussit et correspond aux trois premiers caractères.

S’il existe plusieurs sous-séquences qui correspondent à un emplacement quelconque dans la séquence cible, il existe deux façons de choisir le modèle correspondant.

La première correspondance choisit la sous-séquence qui a été trouvée en premier parmi les correspondances avec l’expression régulière.

La correspondance la plus longue choisit la sous-séquence la plus longue parmi les correspondances trouvées à cet emplacement. S’il y a plusieurs sous-séquences qui ont la longueur maximale, la correspondance la plus longue choisit celle qui a été trouvée en premier.

Par exemple, lorsque la première correspondance est utilisée, une recherche de l’expression b|bc régulière dans la séquence "abcd" cible correspond à la sous-séquence "b" , car le terme de gauche de l’alternation correspond à cette sous-séquence ; par conséquent, la première correspondance n’essaie pas le terme de droite de l’alternation. Lorsque la correspondance la plus longue est utilisée, la même recherche correspond "bc" parce qu’elle "bc" est plus longue que "b".

Une correspondance partielle réussit si la correspondance atteint la fin de la séquence cible sans échouer, même si elle n’a pas atteint la fin de l’expression régulière. Par conséquent, après la réussite d'une correspondance partielle, l'ajout de caractères à la séquence cible peut entraîner l'échec de la prochaine correspondance partielle. Toutefois, après l’échec d’une correspondance partielle, l’ajout de caractères à la séquence cible ne peut pas entraîner la réussite d’une correspondance partielle ultérieure. Par exemple, avec une correspondance partielle, ab correspond à la séquence "a" cible, mais pas "ac".

Indicateurs de format

ECMAScript Règles de format Règles de format sed Texte de remplacement
$& & Séquence de caractères qui correspond à l’expression régulière entière : [match[0].first, match[0].second)
$$ $
\& &
$`" (signe dollar suivi de guillemets précédents) Séquence de caractères qui précède la sous-séquence qui correspond à l’expression régulière : [match.prefix().first, match.prefix().second)
$'" (signe dollar suivi d’une citation à l’avance) Séquence de caractères qui suit la sous-séquence qui correspond à l’expression régulière : [match.suffix().first, match.suffix().second)
$n \n Séquence de caractères qui correspond au groupe de capture à la position n, où n est un nombre compris entre 0 et 9 : [match[n].first, match[n].second)
\\n \n
$nn Séquence de caractères qui correspond au groupe de capture à la position nn, où nn est un nombre compris entre 10 et 99 : [match[nn].first, match[nn].second)

Voir aussi

Vue d’ensemble de la bibliothèque standard C++