Passer au contenu principal

Caractères génériques Windows et expressions régulières Windows

Caractères génériques Windows vous permet de spécifier un fichier ou un groupe de fichiers en tapant un nom de fichier partiel. Le répertoire approprié est analysé pour trouver tous les fichiers correspondant au nom partiel. Vous pouvez aussi utiliser expressions régulières pour spécifier des fichiers lors de l'utilisation TCC (voir ci-dessous).

Les caractères génériques sont généralement utilisés pour spécifier quels fichiers devrait être traité par une commande. Si vous devez spécifier quels fichiers doivent ne sauraient être traité, voir Plages d'exclusion de fichiers (Pour TCC commandes internes), ou SAUF (pour les commandes externes).

La plupart des commandes internes dans TCC ou CMD accepte les noms de fichiers avec des caractères génériques partout où un nom de fichier complet peut être utilisé. Il y a deux caractères génériques, l'astérisque * et le point d'interrogation ?. De plus, dans TCC vous pouvez spécifier un jeu de caractères (voir ci-dessous).

AVERTISSEMENT: Lorsque vous utilisez une recherche générique pour les fichiers à traiter dans une commande telle que POUR or DO, et que vous créez de nouveaux noms de fichiers (que ce soit en renommant des fichiers existants ou en créant de nouveaux fichiers), les nouveaux noms de fichiers peuvent correspondre au caractère générique de votre sélection et vous obliger à les traiter à nouveau.

Astérisque * caractère générique

An astérisque * dans une spécification de fichier, cela signifie "un ensemble de caractères quelconques ou aucun caractère à cette position". Par exemple, la commande suivante affichera une liste de tous les fichiers (y compris les répertoires, mais excluant les fichiers et répertoires avec au moins un des attributs caché et combustion propre) dans le répertoire courant :

    rép *

Si vous souhaitez voir tous les fichiers avec un .TXT extension:

    dir * .txt

Si vous savez que le fichier que vous recherchez a un nom de base qui commence par ST et une extension qui commence par .D, vous pouvez le trouver de cette façon. Les noms de fichiers tels que ETAT.DAT, STEVEN.DOC, et ST.D seront tous affichés :

    dir st*.d*

TCC vous permet également d'utiliser l'astérisque pour faire correspondre les noms de fichiers avec des lettres spécifiques quelque part dans le nom. L'exemple suivant affichera n'importe quel fichier avec un .TXT extension qui a les lettres AM ensemble n'importe où à l'intérieur de son nom de base. Il affichera par exemple AMPLE.TXT, TIMBRE.TXT, CLAM.TXTet AM.TXT, mais il ignorera RÉCLAMATION.TXT:

    répertoire *am*.txt

Point d'interrogation ? caractère générique

A point d'interrogation ? correspond à n’importe quel caractère du nom de fichier. Vous pouvez placer le point d'interrogation n'importe où dans un nom de fichier et utiliser autant de points d'interrogation que nécessaire. L'exemple suivant affichera des fichiers avec des noms comme LETTRE.DOC, DERNIER.DAT, et LITTER.DU:

    dir l?tter.d??

L'utilisation d'un caractère générique astérisque avant d'autres caractères et des plages de caractères décrites ci-dessous constituent des améliorations de la syntaxe standard des caractères génériques Microsoft et ne fonctionneront probablement pas correctement avec des logiciels autres que TCC.

Les points d'interrogation "supplémentaires" dans votre spécification générique sont ignorés si le nom de fichier est plus court que la spécification générique. Par exemple, si vous avez des fichiers appelés LETTRE.DOC, LETTRE1.DOCet LETTRE.DOC, cette commande affichera les trois noms :

  lettre dir?.doc

Le fichier LETTRE.DOC est inclus dans l'affichage car le point d'interrogation "extra" à la fin de LETTRE? est ignoré lors de la correspondance avec le nom le plus court LETTRE.

Caractères génériques de jeu de caractères

Dans certains cas, ? le caractère générique est peut-être trop général. TCC (mais pas CMD) vous permet également de spécifier l'ensemble exact des caractères que vous souhaitez accepter (ou exclure) à une position particulière dans le nom de fichier en utilisant des crochets []. À l’intérieur des parenthèses, vous pouvez mettre les caractères individuels acceptables ou les plages de caractères. Par exemple, si vous vouliez faire correspondre LETTRE0.DOC à travers LETTRE9.DOC, vous pouvez utiliser cette commande :

  dir lettre[0-9].doc

Vous pouvez ainsi trouver tous les fichiers dont le nom contient une voyelle comme deuxième lettre. Cet exemple montre également comment mélanger les caractères génériques :

  dir ?[aeiouy]*

Vous pouvez exclure un groupe de caractères ou une plage de caractères en utilisant un point d'exclamation [!] comme premier caractère entre parenthèses. Cet exemple affiche tous les noms de fichiers comportant au moins 2 caractères, à l'exception de ceux dont la deuxième lettre est une voyelle :

  dir ?[!aeiouy]*

L'exemple suivant, qui sélectionne des fichiers tels que AIP, BIPet ASTUCE mais pas PIN, montre comment vous pouvez utiliser plusieurs plages entre crochets. Il acceptera un fichier commençant par un A, B, C, D, T, Uou V:

  rép [a-dt-v]ip

Vous pouvez utiliser un point d'interrogation entre crochets, mais sa signification est légèrement différente d'un caractère générique de point d'interrogation normal (sans crochets). Un caractère générique de point d'interrogation normal correspond à n'importe quel caractère, mais sera ignoré lors de la correspondance avec un nom plus court que la spécification du caractère générique, comme décrit ci-dessus. Un point d'interrogation entre parenthèses correspondra à n'importe quel caractère, mais ne sauraient être ignoré lors de la correspondance avec des noms de fichiers plus courts. Par exemple:

  dir lettre[?].doc

Affichera LETTRE1.DOC et LETTRE.DOC, Mais pas LETTRE.DOC.

Vous pouvez répéter n'importe lequel des caractères génériques dans n'importe quelle combinaison souhaitée dans un seul nom de fichier. Par exemple, la commande suivante répertorie tous les fichiers qui ont un A, Bou C comme troisième caractère, suivi de zéro ou plusieurs caractères supplémentaires, suivis d'un D, Eou F, suivi éventuellement de quelques caractères supplémentaires, et d'une extension commençant par P or Q. Vous n'aurez probablement pas besoin de faire quelque chose d'aussi complexe, mais nous l'avons inclus pour vous montrer la flexibilité des caractères génériques étendus :

  rép ??[abc]*[def]*.[pq]*

Vous pouvez également utiliser la syntaxe des caractères génériques entre crochets pour contourner un conflit entre des noms de fichiers longs contenant des points-virgules [;], et l'utilisation d'un point-virgule pour indiquer un inclure la liste. Par exemple, si vous avez un fichier sur un lecteur LFN nommé C:\DONNÉES\LETTRE1;V2 et tu tapes cette commande :

  del \data\letter1;v2

vous n'obtiendrez pas les résultats escomptés. Au lieu de supprimer le fichier nommé, TCC va tenter de supprimer LETTRE1 et alors V2, car le point-virgule indique un inclure la liste. Cependant, si vous utilisez des crochets autour du point-virgule, celui-ci sera interprété comme un caractère de nom de fichier et non comme un séparateur de liste d'inclusion. Par exemple, cette commande supprimerait le fichier nommé ci-dessus :

  del \data\letter1[;]v2

Correspondance des noms de fichiers courts (SFN)

Si l'option de configuration Rechercher les SFN est définie, dans TCC Les recherches par caractères génériques acceptent une correspondance soit sur le LFN or le SFN pour correspondre au comportement de CMD. Cela peut entraîner la recherche de certains fichiers uniquement en raison d'une correspondance SFN. Dans la plupart des situations, cela n'est pas réellement souhaitable et peut être évité en désactivant l'option (le défaut).

Remarque: Le joker le processus d'expansion tentera de permettre à la fois CMD-style "extension" correspondant (une seule extension, à la fin du mot) et avancé TCC correspondance de nom de fichier (permettant des choses comme *.*.abc) lorsqu'un astérisque est rencontré dans la destination d'un  COPY, MOVE or REN / RENOMMER commander.

Caractères génériques dans les noms de répertoires

TCC (mais pas CMD) prend en charge les caractères génériques dans les noms de répertoire (mais pas dans le nom du lecteur), pour les TCC commandes et fonctions. Ces types de caractères génériques sont courants sous Linux, mais ne sont pas pris en charge dans CMD ou dans la plupart des applications Windows.

Vous pouvez contrôler la récursion du sous-répertoire en spécifiant * or ** Sur le chemin. A * correspondra à un seul niveau de sous-répertoire ; un ** correspondra à tous les niveaux de sous-répertoire pour ce nom de chemin. Les caractères génériques de répertoire prennent également en charge les expressions régulières. Les caractères génériques de répertoire ne peuvent pas être utilisés avec l'option /O:... (qui trie les entrées avant d'exécuter la commande). Et réfléchissez bien avant d'utiliser des caractères génériques de répertoire avec une option /S (sous-répertoires récursifs), car cela renverra presque certainement des résultats inattendus !

Par exemple, pour supprimer le fichier Foobar dans n'importe quel sous-répertoire de c:\test\test2 (mais pas dans aucun de leurs sous-répertoires) :

    del c:\test\test2\*\foobar

Pour supprimer le fichier Foobar dans n'importe quel sous-répertoire sous c:\test (et tous leurs sous-répertoires) dont le nom contient "foo" :

    del c:\test\**\*foo*\foobar

Pour supprimer le fichier Foobar dans n'importe quel sous-répertoire de c:\test commençant par un t et se termine par un 2:

    del c:\test\t*2\foobar

Certaines commandes ne prennent pas en charge les caractères génériques de répertoire, car ils seraient dénués de sens ou destructeurs (par exemple, TREE, @FILEOPEN, @FILEDATE, etc.).

Expressions régulières Windows dans TCC

En plus de l'extension Caractères génériques Windows (*, ?, et [...]), TCC soutient l'utilisation de caractères génériques d'expression régulière pour la correspondance et le remplacement du nom de fichier dans les commandes internes de gestion de fichiers (COPY, DEL, DIR, MOVE, REN, etc.). Vous pouvez choisir la syntaxe d'expression régulière que vous souhaitez utiliser - TCC prend en charge les expressions régulières Perl, Ruby, Java, grep, POSIX, gnu, Python et Emacs.

La syntaxe est:

    ::expression régulière

Par exemple :

    rép ::ca[td]

Notez que l'utilisation Expressions régulières Windows ralentira légèrement vos recherches dans l'annuaire : étant donné que Windows ne les prend pas en charge de manière native, le TCC l'analyseur doit convertir le nom du fichier en *, récupérez tous les noms de fichiers, puis faites-les correspondre à l'expression régulière.

Si vous avez des caractères spéciaux (espaces, caractères de redirection, caractères d'échappement, etc.) dans votre expression régulière, vous devrez les mettre entre guillemets. Par exemple:

    rép "::^\w{1,8}\.btm$"

Pour plus d'informations sur caractère générique d'expression régulière syntaxe, voir Syntaxe des expressions régulières dans l' Take Command aider.

Pour simplifier la création et le test de vos expressions régulières, Take Commande et TCC inclure une boîte de dialogue d'analyseur d'expressions régulières (Ctrl-F7 depuis le TCC ligne de commande, ou sous le menu Outils dans Take Command.) Il existe deux zones d'édition :

  1. La première consiste à tester l'expression régulière. Si l'expression régulière est valide, la boîte de dialogue affichera une coche verte à droite de la zone d'édition de l'expression. Si l'expression régulière n'est pas valide, la boîte de dialogue affichera un X rouge.
  2. La deuxième zone d'édition concerne le texte que vous souhaitez faire correspondre à l'expression régulière. Si le texte correspond à l'expression régulière, la boîte de dialogue affichera une coche verte à droite de la zone d'édition du test. Si le texte ne correspond pas, la boîte de dialogue affichera un X rouge.

TCC Analyseur d'expressions régulières Windows/analyseur de caractères génériques Windows

Syntaxe des expressions régulières Onigmo (version 6.2.0) dans Take Command / TCC

Cette section couvre la syntaxe par défaut des expressions régulières Ruby. Pour plus d'informations sur d'autres syntaxes d'expressions régulières (Perl, Python, Java, etc.), consultez la documentation appropriée de ce produit.

Éléments de syntaxe

\ escape (activer ou désactiver la signification des méta-caractères)
| alternance
(...) groupe
[...] classe de caractères  

Personnages

\t onglet horizontal (0x09)
\v onglet vertical   (0x0B)
\n nouvelle ligne        (0x0A)
\r retourner         (0x0D)
\b espace arrière     (0x08)
\f flux de formulaire      (0x0C)
\a cloche           (0x07)
\e échapper         (0x1B)
\nnn caractère octal            (valeur d'octet codée)
\xHH Caractère hexadécimal      (valeur d'octet codée)
\x{7HHHHHHH} caractère hexadécimal large (valeur du point de code du caractère)
\cx char de contrôle          (valeur du point de code du caractère)
\Cx char de contrôle          (valeur du point de code du caractère)
\Mx méta  (x|0x80)        (valeur du point de code du caractère)
\M-\Cx méta-contrôle char     (valeur du point de code du caractère)
(* \b est efficace dans la classe de caractères [...] uniquement)

Types de caractères

. n'importe quel caractère (sauf nouvelle ligne)
\w caractère de mot
Pas Unicode :
            alphanumérique, "_" et caractère multi-octets. 
Unicode:
Catégorie_générale -- (Lettre|Marque|Nombre|Connecteur_Punctuation)
\W       caractères non-mots
\s caractères d'espacement
Pas Unicode :
\t, \n, \v, \f, \r, \x20
Unicode:
0009, 000A, 000B, 000C, 000D, 0085(NEL), 
Catégorie_générale – Line_Separator
                     --Paragraphe_Séparateur
                      -- Space_Separator
\S caractère non blanc
\d caractère décimal
Unicode : Catégorie_générale – Numéro_décimal
\D caractère à chiffres non décimaux
\h Caractère à chiffres hexadécimaux   [0-9a-fA-F]
\H caractère à chiffres non hexadécimaux
Propriété de caractère
* \p{nom-propriété}
* \p{^property-name}    (négatif)
* \P{property-name}     (négatif)
nom de la propriété:
+ fonctionne sur tous les encodages
Alnum, Alpha, Vide, Cntrl, Chiffre, Graphique, Inférieur, Impression, Ponctuel, Espace, Supérieur, XDigit, Word, ASCII,
     + fonctionne sur UTF8, UTF16, UTF32
  \R       Saut de ligne
           Unicode:
             (?>\x0D\x0A|[\x0A-\x0D\x{85}\x{2028}\x{2029}])
           Pas Unicode :
             (?>\x0D\x0A|[\x0A-\x0D])
  \X       Cluster de graphèmes étendu
           Unicode:
             (?>\P{M}\p{M}*)
           Pas Unicode :
             (?m:.)

Quantificateur

avide
? 1 ou 0 fois
*       0 fois ou plus
+       1 fois ou plus
{n,m}   au moins n mais pas plus de m fois
{n,}    au moins n fois
{,n}    au moins 0 mais pas plus de n fois ({0,n})
{n}     n fois
réticent
?? 1 ou 0 fois
*? 0 fois ou plus
+? 1 ou plusieurs fois
{n,m} ? au moins n mais pas plus de m fois  
{n,} ? au moins n fois
{,n} ? au moins 0 mais pas plus de n fois (== {0,n} ?)
possessif (gourmand et ne revient pas en arrière après avoir répété)
?+      1 ou 0 fois
*+      0 fois ou plus
++      1 fois ou plus
({n,m}+, {n,}+, {n}+ sont des opérations possessives dans ONIG_SYNTAX_JAVA uniquement)
ex. /a*+/ === /(?>a*)/

Ancres

^ début de la ligne
$ fin de la ligne
\b limite de mot
\B pas de limite de mot
\A début de chaîne
\Z fin de chaîne, ou avant la nouvelle ligne à la fin
\z fin de chaîne
\G position de départ correspondante (*)

Classe de personnage

^... classe négative (opérateur de priorité la plus basse)
xy va de x à y
[...] set (classe de caractères dans la classe de caractères)
..&&.. intersection (faible priorité au prochain de ^)
          
ex. [aw&&[^cg]z] ==> ([aw] AND ([^cg] OR z)) ==> [abh-w]
* Si vous souhaitez utiliser '[', '-', ']' comme caractère normal dans une classe de caractères, vous devez échapper ces caractères par '\'.
Support POSIX ([:xxxxx:], annuler [:^xxxxx:])
Pas de cas Unicode :
numéro d'album caractère alphabet ou chiffre
Alpha alphabet
ascii valeur du code : [0 - 127]
vide \t, \x20
ctrl
chiffre 0-9
graphique inclure tous les caractères codés sur plusieurs octets
baisser
impression inclure tous les caractères codés sur plusieurs octets
point
espace \t, \n, \v, \f, \r, \x20
supérieur
mot caractères alphanumériques, "_" et multi-octets
xchiffre 0-9, af, af
Cas Unicode :
numéro d'album Lettre | Marque | Nombre décimal
Alpha Lettre | Marque
ascii 0000 - 007F
vide Espace_Séparateur | 0009
ctrl Contrôle | Formater | Non attribué | Utilisation_privée | Substitut
chiffre Nombre décimal
graphique [[:^espace :]] && ^Contrôle && ^Non attribué && ^Surrogate
baisser Lettre minuscule
impression [[:graphique:]] | [[:espace:]]
point Connecteur_Punctuation | Tiret_Punctuation | Fermer_Punctuation | Ponctuation_Finale | Ponctuation_initiale | Autre_Ponctuation | Ouvrir_Punctuation
espace Espace_Séparateur | Séparateur_ligne | Séparateur_paragraphe | 0009 | 000A | 000B | 000C | 000D | 0085
supérieur Lettre majuscule
mot Lettre | Marque | Nombre_décimal | Connecteur_Punctuation
xchiffre 0030 - 0039 | 0041 - 0046 | 0061 - 0066 (0-9, a-f, A-F)

Groupes étendus

(?#...) commentaire
(?imxdau-imx)      option activée/désactivée
je : ignore la casse
m : multiligne (point (.) correspond à la nouvelle ligne)
x : forme étendue
option de jeu de caractères (option de plage de caractères)
d : par défaut (compatible avec Ruby 1.9.3)
\w, \d et \s ne correspondent pas aux caractères non-ASCII.
Les parenthèses \b, \B et POSIX utilisent les règles de chaque encodage.
a : ASCII
L'option ONIG_OPTION_ASCII_RANGE est activée.
 Les crochets \w, \d, \s et POSIX ne correspondent pas aux caractères non-ASCII.
\b et \B utilisent les règles ASCII.
 vous : Unicode
L'option ONIG_OPTION_ASCII_RANGE est désactivée.
 \w (\W), \d (\D), \s (\S), \b (\B) et les crochets POSIX utilisent les règles de chaque encodage.
(?imxdau-imx:subexp) option marche/arrêt pour la sous-exp
(?: sous-exp) groupe non capturé
(sous-expression) groupe capturé
(?=sous-exp) anticiper
(?!subexp) prévision négative
(?<=sous-exp) regarde derrière
(? regard négatif
La sous-expression de look-behind doit avoir une longueur de caractère fixe. Mais des longueurs de caractères différentes ne sont autorisées que dans les alternatives de niveau supérieur.
ex. (?<=a|bc) est OK. (?<=aaa(?:b|cd)) n'est pas autorisé.
En mode négatif, le groupe capturé n'est pas autorisé, mais le groupe timide (?:) est autorisé.
\K garder
Une autre expression du regard derrière. Conservez les éléments restants du \K, ne les incluez pas dans le résultat.
(?>sous-exp) groupe atomique
ne revenez pas en arrière dans la sous-exp.
(?sous-expression) définir un groupe nommé
(Tous les caractères du nom doivent être des caractères de mot. Et le premier caractère ne doit pas être un chiffre ou une majuscule)
Non seulement un nom mais un numéro est attribué comme un groupe capturé.
L'attribution du même nom à deux sous-expressions ou plus est autorisée. Dans ce cas, un appel subexp ne peut pas être effectué bien que la référence arrière soit possible.
  (?(cond)oui-subexp), (?(cond)oui-subexp|no-subexp)
                    expression conditionnelle
                    Correspond à yes-subexp si (cond) donne une valeur vraie, correspond à no-subexp sinon.
                    Ce qui suit (cond) peut être utilisé :
                    (n)  (n >= 1)
                        Vérifie si le groupe de capture numéroté correspond à quelque chose.
                    (), ('nom')
                        Vérifie si un groupe avec le nom donné correspond à quelque chose.

Référence arrière

\n référence arrière par numéro de groupe (n >= 1)
\k référence arrière par numéro de groupe (n >= 1)
\k'n' référence arrière par numéro de groupe (n >= 1)
\k référence arrière par numéro de groupe relatif (n >= 1)
\k'-n' référence arrière par numéro de groupe relatif (n >= 1)
\k référence arrière par nom de groupe
\k'nom' référence arrière par nom de groupe
Dans la référence arrière par le nom de la définition du multiplex, une sous-expression avec un grand nombre est référencée préférentiellement. (En cas de non-correspondance, un groupe du petit nombre est mentionné.)
* La référence arrière par numéro de groupe est interdite si le groupe nommé est défini dans le modèle et que ONIG_OPTION_CAPTURE_GROUP n'est pas défini.

Référence arrière avec niveau de nidification
niveau : 0, 1, 2, ...
\k     (n >= 1)
\k     (n >= 1)
\k'n+niveau'     (n >= 1)
\k'n-level'    ​​ (n >= 1)
\k    (n >= 1)
\k    (n >= 1)
\k'-n+niveau'    (n >= 1)
\k'-n-level'    ​​(n >= 1)
\k
\k
\k'nom+niveau'
\k'niveau-nom'
Destination du niveau de nidification relatif à partir de la position de référence arrière.  
Exemple 1.
/\A(?|.|(?:(?.)\g\k))\z/.match("reer")
Exemple 2.
r = Regexp.compile(<<'__REGEXP__'.strip, Regexp::EXTENDED)
(? \g \g* \g ){0}
(? \s* > ){0}
(? [a-zA-Z_:]+ ){0}
(? [^ | [^<&]+)* ){0}
(? >){1}
\g
__REGEXP__
p r.match('fbbbf').captures

Appel Subexp ("Spécial Tanaka Akira")

\g appeler par nom de groupe
\g'nom' appeler par nom de groupe
\g appel par numéro de groupe (n >= 1)
\g'n' appel par numéro de groupe (n >= 1)
\g       appeler le modèle entier de manière récursive
\g'0'       appeler le modèle entier de manière récursive
\g      appel par numéro de groupe relatif (n >= 1)
\g'-n'      appel par numéro de groupe relatif (n >= 1)
\g      appel par numéro de groupe relatif (n >= 1)
\g'+n'      appel par numéro de groupe relatif (n >= 1)
* L'appel récursif le plus à gauche n'est pas autorisé.
ex. (?a|\gb)   => erreur
(?a|b\gc)  => OK
* L'appel par numéro de groupe est interdit si le groupe nommé est défini dans le modèle et que ONIG_OPTION_CAPTURE_GROUP n'est pas défini.
* Si le statut de l'option du groupe appelé est différent de la position de l'appelant, alors l'option du groupe est effective.
ex. (?-i:\g)(?i:(?a)){0}  correspond à "A"
Syntaxe Perl : utilisez plutôt (?&name), (?n), (?-n), (?+n), (?R) ou (?0).

Groupe capturé

Le comportement du groupe non nommé (...) change avec les conditions suivantes. (Mais le groupe nommé n'est pas modifié.)
cas 1. /.../    (le groupe nommé n'est pas utilisé, aucune option)
(...) est traité comme un groupe capturé.
cas 2. /.../g    (le groupe nommé n'est pas utilisé, option 'g')
(...) est traité comme un groupe non capturé (?:...).
cas 3. /..(?...)../    (le groupe nommé est utilisé, aucune option)
(...) est traité comme un groupe non capturé (?:...).
la référence/appel numéroté n'est pas autorisé.
cas 4. /..(?...)../G    (le groupe nommé est utilisé, option 'G')
(...) est traité comme un groupe capturé.
la référence/appel numéroté est autorisé.
De
g : ONIG_OPTION_DONT_CAPTURE_GROUP
G : ONIG_OPTION_CAPTURE_GROUP

Options dépendantes de la syntaxe

+ RUBIS
(?m): point(.) correspond à la nouvelle ligne
+ PERL, JAVA et Python
(?s): point(.) correspond à la nouvelle ligne
(?m) : ^ correspondance après la nouvelle ligne, $ correspondance avant la nouvelle ligne
+PERL
(?d), (?l) : identique à (?u)

Extensions originales

+ Type de caractère à chiffres hexadécimaux  \h, \H
+ groupe nommé              (?...)
+ backref nommé            \k
+ appel de sous-exp                  \g, \g