Functions > String >

StringRegExp

Recherche, dans un texte, des sous-chaînes qui correspondent à un modèle d'expression régulière.

StringRegExp ( $sText, $sPattern [, $iMode = 0 [, $iStart = 1]] )

Paramètres

$sText Texte dans lequel effectuer la recherche
$sPattern Chaîne contenant le critère de recherche, appelé modèle. Voir Remarques.
$iMode [optionnel] Mode de recherche. Voir 'Valeur de retour' pour la description des différents modes et la valeur de retour de la fonction dans chaque mode.
    $STR_REGEXPMATCH (0) - mode par défaut
    $STR_REGEXPARRAYMATCH (1)
    $STR_REGEXPARRAYFULLMATCH (2)
    $STR_REGEXPARRAYGLOBALMATCH (3)
    $STR_REGEXPARRAYGLOBALFULLMATCH (4)

Les constantes sont définies dans StringConstants.au3
$iStart [optionnel] Position dans le texte où démarre la recherche. La valeur par défaut est 1.

Valeur de retour

La valeur de retour dépend du paramètre $iMode qui peut prendre les 5 valeurs ci-dessous.
Les constantes sont définies dans StringConstants.au3

Mode = $STR_REGEXPMATCH (0)
La fonction recherche la première concordance avec le modèle, à partir de la position $iStart, et retourne si oui ou non la recherche a réussi.
Succès: Retourne 1 si une concordance est trouvée, 0 sinon.
Échec: Retourne 0 et @error = 2 si le modèle est erroné. @Extended contient la position de l'erreur dans le modèle.

Mode = $STR_REGEXPARRAYMATCH (1)
La fonction recherche la première concordance à partir de la position $iStart et retourne un tableau contenant les groupes capturés.
Si le modèle ne capture pas de groupe, la première concordance, à partir de la position $iStart, est retournée en position [0] du tableau.
@extended contient la position qui suit la concordance trouvée et qui peut être affectée à $iStart pour la recherche de la concordance suivante (Exemple 3).
Succès: Retourne le tableau des groupes capturés.
Échec: @error = 1 Tableau invalide : aucune concordance trouvée.
@error = 2 Modèle erroné: tableau invalide. @extended contient la position de l'erreur dans le modèle.

Mode = $STR_REGEXPARRAYFULLMATCH (2)
La fonction recherche la première concordance avec le modèle, à partir de la position $iStart, et retourne le tableau du résultat complet en [0] et des groupes de capture en [1], [2], ....
Quand le modèle ne capture pas de groupe, la première concordance est retournée en position [0] du tableau.
@extended contient la position qui suit la concordance trouvée et qui peut être affectée à $iStart pour la rechercher la concordance suivante.
Succès: Retourne un tableau valide
Échec: @error = 1 Tableau invalide : aucune concordance trouvée.
@error = 2 Modèle erroné: tableau invalide. @extended contient la position de l'erreur dans le modèle.

Mode = $STR_REGEXPARRAYGLOBALMATCH (3)
Recherche toutes les concordances et remplit un tableau avec tous les groupes capturés de toutes les concordances trouvées:
Par exemple, si chaque concordance capture deux groupes, le tableau a le format suivant:
    [0]: groupe capturé n°1 dans la concordance n°1
    [1]: groupe capturé n°2 dans la concordance n°1
    [2]: groupe capturé n°1 dans la concordance n°2
    [3]: groupe capturé n°2 dans la concordance n°2
    [4]: groupe capturé n°1 dans la concordance n°3
    [5]: groupe capturé n°2 dans la concordance n°3
etc..., 2 éléments par concordance.
Succès: Retourne un tableau de résultats globaux pour le texte.
Échec: @error = 1 Tableau invalide : aucune concordance trouvée.
@error = 2 Modèle erroné: tableau invalide. @extended contient la position de l'erreur dans le modèle.

Mode = $STR_REGEXPARRAYGLOBALFULLMATCH (4)
Recherche toutes les concordances avec le modèle et retourne un tableau avec autant d'éléments que de concordances. Chaque élément est lui-même un tableau qui contient la concordance complète en [0] et les groupes capturés en [1], [2], ... (style Perl / PHP).
    [0] Tableau de résultats relatifs à la concordance d'index 0
        [0]: concordance complète
        [1]: groupe de capture n°1
        [2]: groupe de capture n°2
        ....
    [1]: Tableau de résultats relatifs à la concordance d'index 1
        [0]: concordance complète
        [1]: groupe de capture n°1
        [2]: groupe de capture n°2
        ....
Succès: Retourne un tableau de tableaux.
Échec: @error = 1 Tableau invalide : aucune concordance trouvée.
@error = 2 Modèle erroné: tableau invalide. @extended contient la position de l'erreur dans le modèle.

Remarques

La notation d'expression régulière est une façon compacte de définir un critère de recherche codé dans une chaîne appelée 'modèle' et à partir duquel des portions spécifiques de chaîne peuvent être extraites avec StringRegExp() ou remplacées par StringRegExpReplace().

Plus précisément, le moteur des expressions régulières s'efforce de trouver une ou des concordances entre le modèle et la chaîne texte, de la gauche vers la droite. Si une différence apparaît lors d'une comparaison en cours, le moteur tente de faire marche arrière (retour à des états précédents successifs) autant que nécessaire, espérant que le reste du modèle concordera ainsi.

Le retour arrière ('backtracking') est un aspect fondamental des moteurs d'expressions régulères et même le programmeur novice utilise ce mécanisme tous les jours. Il consiste à laisser une marque spécifique à chaque embranchement du chemin qu'on parcourt et de revenir à l'embranchement précédent pour explorer l'autre voie lorsque le chemin choisi se révèle être une impasse: vous faites marche arrière (backtrack) au besoin jusqu'à trouver le but du parcours (concordance trouvée) ou avoir exploré toutes les voies sans atteindre l'objectif (concordance non trouvée). Ce principe d'exploration est utilisé lors de la recherche d'un nom de fichier donné avec jokers facultatifs à l'intérieur d'une arborescence de répertoires.

AutoIt utilise le moteur PCRE ("Perl-Compatible Regular Expressions"). C'est le plus complet des moteurs open-source disponibles. Cette implémentation inclut le support Unicode Category Properties (UCP), qui permet un traitement fin de la plupart des langages humains.
Cependant, pour maintenir la compatibilité avec les versions précédentes et optimiser la vitesse d'exécution, le support UCP n'est pas activé par défaut. Vous pouvez l'activer en insérant la chaîne (*UCP) en tête du modèle. Lorsqu'il est activé, le réglage UCP change l'étendue d'un certain nombre d'éléments d'expressions régulières, comme documenté ci-dessous, le cas échéant.

Cette page est un résumé des éléments de modèle les plus utilisés. Pour une documentation complète et approfondie des expressions régulières implémentées dans AutoIt, reportez-vous à la description complète des modèles PCRE.
Sauf si vous êtes déjà familier avec les expressions régulières, vous aurez probablement besoin de lire plusieurs parties de ce résumé plus d'une fois pour comprendre comment elles fonctionnent et sont reliées entre elles.

Attention: des expressions régulières mal conçues peuvent entraîner une boucle quasi-infinie mobilisant le processeur, entraînant même un dépassement de la pile utilisable.

Paramètres globaux


Ces paramètres ne sont pris en compte qu'au début du modèle et l'affectent globalement.

Conventions de retour à la ligne

Les séquences de saut de ligne affectent la sémantique des ancrages ^ et $, ainsi que des éléments \N et '.' . Par défaut, les séquences de saut de ligne reconnues sont soit @CRLF, soit @CR ou @LF isolés.
La valeur par défaut peut être modifiée en ajoutant l'une des séquences suivantes au début d'un modèle :
(*CR) Carriage return (@CR).
(*LF) Line feed (@LF).
(*CRLF) Carriage return immédiatement suivi de linefeed (@CRLF).
(*ANYCRLF) Toute séquence @CRLF, @CR ou @LF. Ceci est la convention de saut de ligne par défaut.
(*ANY) Une des séquences de saut de ligne Unicode : @CRLF, @LF, VT, FF, @CR ou \x85.

Signification de \R

(*BSR_ANYCRLF) Par défaut \R représente @CRLF, @CR ou @LF.
(*BSR_UNICODE) Change la signification de \R pour concorder avec toute séquence de saut de ligne Unicode : @CRLF, @LF, VT, FF, @CR ou \x85.

Options


Les modèles PCRE peuvent contenir des options, qui sont entourées par des séquences (? ). Les options peuvent être regroupés : "(?imx)". Les options suivant un tiret sont annulées : "(?im-sx)".
Les options apparaissant en dehors d'un groupe affectent la suite du modèle. Les options apparaissant à l'intérieur d'un groupe influent sur ce groupe seulement et à partir de leur point d'apparition. Les options perdent leur signification spéciale à l'intérieur d'une classe de caractères, où elles sont traitées littéralement.

(?i) Insensibilité à la casse : les comparaisons deviennent insensibles à la casse à partir de ce point. Par défaut, les comparaisons sont sensibles à la casse. Quand l'option UCP est activée elle s'applique à l'ensemble du plan Unicode 0, sinon elle s'applique par défaut seulement aux lettres ASCII A-Z et a-z.
(?m) Multiligne : ^ et $ concordent soit au début (resp. à la fin) du texte, soit à la position précédant (resp. suivant) une séquence de saut de ligne. Par défaut, l'option multiligne est désactivée.
(?s) Mono-ligne ou DotAll: . concorde à tout caractère, y compris une séquence de saut de ligne. L'option DotAll est désactivée par défaut, ainsi . ne concorde pas à une séquence de saut de ligne.
(?U) Paresseux : les quantificateurs deviennent paresseux (non gourmands) à partir de ce point. Par défaut, la recherche est gourmande - voir ci-dessous pour plus de détails.
(?x) Étendu : les espaces blancs à l'extérieur des classes de caractères sont ignorés et # démarre un commentaire jusqu'au prochain caractère Newline dans le modèle. L'espacement des éléments rend les expressions régulières beaucoup plus lisibles. Par défaut, les espaces blancs et # sont interprétés littéralement.

Caractères, méta-caractères et echappement (escaping ou quoting)


Caractères

Les modèles d'expressions régulières se composent de littéraux Unicode (portions de texte qui concordent avec elles-mêmes), entremêlées d'éléments ou d'options d'expression régulière. Les éléments et les options utilisent quelques méta-caractères qui ont eux-même une signification particulière ou qui marquent le début d'éléments plus complexes décrits dans les tableaux ci-dessous.
Dans les portions littérales, les caractères alphanumériques concordent avec eux-mêmes : le modèle "partie littérale avec 中国文字" correspond exactement à la chaîne "partie littérale avec 中国文字" ("中国文字" signifie "texte chinois".)
Certains caractères non-alphanumériques appelés métacaractères ont un comportement particulier, discuté par la suite.

Représentation de quelques caractères littéraux

Les séquences spéciales ci-dessous sont utilisés pour représenter certains caractères littéralement.

\a Représente "alarm", le caractère BEL (Chr(7)).
\cX Représente "contrôle-X", où X représente tout caractère ASCII 7 bits. Par exemple, "\cM" représente ctrl-M, aussi représentable par \x0D ou \r (Chr(13)).
\e Représente le caractère de contrôle "échappement" (Chr(27)). Ne pas confondre avec l'échappement (escaping) d'un caractère!
\f Représente "formfeed" (Chr(12)).
\n Représente "linefeed" (@LF, Chr(10)).
\r Représente "carriage return" (@CR, Chr(13)).
\t Représente "tab" (@TAB, Chr(9)).
\ddd Représente un caractère de code octal ddd, OU une référence arrière au groupe capturant numéro ddd (en décimal). Par exemple, ([a-z])\1 représente une minuscule doublée.
À éviter soigneusement à cause de cette ambiguité ! Utiliser de préférence les représentations hexadécimales ci-dessous.
\xhh Représente un caractère Unicode en hexadécimal hh : "\x7E" représente un tilde, "~".
\x{hhhh} Représente un caractère Unicode en héxadécimal hhhh : "\x{20AC}" représente le symbole de l'Euro, "€" (ChrW(0x20AC)).
\x où x est non-alphanumérique, représente un caractère x littéral. C'est l'échappement du caractère x. Utilisé pour représenter les méta-caractères littéraux : "\.\[" représente un point suivi d'un crochet ouvrant, ".[".
\Q ... \E Séquence verbatim : les méta-caractères perdent leur signification spéciale entre \Q et \E : "\Q(.)\E" recherche la chaîne "(.)" et est bien plus lisible que le modèle équivalent "\(\.\)" .

Méta-caractères

Les méta-caractères PCRE sont \ . ^ $ | [ ( { * + ? # ils ont une ou plusieurs significations, selon le contexte.
Pour insérer un méta-caractère littéral, faites-le précéder par une barre oblique inverse ('backslash') (c'est l'échappement de ce caractère) : "\$" signifie le caractère dollar.
Les méta-caractères seront abordés dans des sections distinctes qui traitent de leur comportement et de leur signification.

Types de caractères


Par défaut, les caractères concernés par \s sont HT(9), LF(10), VT(11), FF(12), CR(13), et Space (32), qui sont considérés comme des espaces blancs dans la localisation "C". Cette liste peut varier si l'appariement spécifique à la localisation est active. Par exemple, dans certaines localisations le caractère Espace Insécable (\xA0) est reconnu comme 'espace blanc', et dans d'autres le caractère VT ne l'est pas. Note - Il est déconseillé d'utiliser les localisations dans les regexp.
. Représente tout caractère Unicode excepté une séquence de saut de ligne. Représente tout caractère Unicode lorsque l'option (?s) est active.
\d Représente tout chiffre décimal (n'importe quel chiffre décimal Unicode de n'importe quel langage quand UCP est activé).
\D Représente tout caractère qui n'est pas un chiffre.
\h Représente à tout caractère d'espacement horizontal (voir tableau ci-dessous).
\H Représente à tout caractère hors espacements horizontal.
\N Représente à tout caractère sauf à une séquence de saut de ligne, indépendamment de l'option (?s).
\p{ppp} Seulement quand l'option UCP est activée : représente tout caractère Unicode possédant la propriété ppp. Par exemple, "\b\p{Cyrillic}+" représente tout mot cyrillique ; "\p{Sc}" représente tout symbole monétaire. Consultez la documentation de référence pour plus de détails.
\P{ppp} Seulement quand l'option UCP est activée : représente tout caractère Unicode ne possédant pas la propriété ppp.
\R Représente toute séquence 'newline' Unicode par défaut, ou avec le paramètre (*BSR_...) actif. Par défaut \R équivaut à "(?>\r\n|\n|\r)" où "(?>...)" est un groupe atomique, entité qui rend la séquence "\r\n" (@CRLF) indivisible.
\s Représente tout caractère d'espacement (voir tableau ci-dessous).
\S Représente tout caractère hors espacements.
\v Représente tout caractère d'espacement vertical (voir tableau ci-dessous).
\V Représente tout caractère hors espacement vertical.
\w Représente tout caractère 'mot' : tout chiffre, lettre ou soulignement (underscore "_"). Tout chiffre, lettre Unicode de tout langage ou soulignement (underscore "_") quand UCP est activé.
\W Représente tout caractère qui n'est pas 'mot'.
\X Seulement quand UCP est activé : représente tout graphème étendu Unicode - une séquence indivisible de codes qui représente un seul caractère pour l'utilisateur. En conséquence, \X peut retrésenter plus d'un caractère dans la chaîne d'origine, contrairement à tous les autres éléments de ce tableau.

Classification des caractères d'espacement


Caractères d'espacement horizontal concernés par \h

\h Les caractères d'espacement horizontal concernés par \h sont:
U+0009 Horizontal Tabulation (HT)
U+0020 Space
U+00A0 Non-break space
U+1680 Ogham space mark (marque d'espace Ogham)
U+180E Mongolian vowel separator (séparateur de voyelles Mongolien)
U+2000 En quad (demi-quadratin)
U+2001 Em quad (cadratin - unité de mesure d'espace)
U+2002 En space (espace demi-cadratin)
U+2003 Em space (espace cadratin)
U+2004 Three-per-em space (tiers de cadratin)
U+2005 Four-per-em space (quart de cadratin)
U+2006 Six-per-em space (sixième de cadratin)
U+2007 Figure space (espace tabulaire)
U+2008 Punctuation space (espace de ponctuation)
U+2009 Thin space (espace fin)
U+200A Hair space (espace ultra fin)
U+202F Narrow no-break space (espace insécable fin)
U+205F Medium mathematical space (espace mathématique moyen)
U+3000 Ideographic space (espace idéographique)

Caractères d'espacement vertical concernés par \v

\v Les caractères d'espacement vertical concernés par \v sont:
U+000A Linefeed (LF)
U+000D Carriage return (CR)
U+000B Vertical tab (VT)
U+000C Form feed (FF)
U+0085 Next line (NEL)
U+2028 Line separator
U+2029 Paragraph separator
Caractères d'espacement correspondant à [[:space:]] (voir cette classe POSIX ci-dessous)

[[:space:]] est équivalent à "\s".
Cet ensemble comprend tous les caractères de \s plus Vertical tab (VT).

Classes de caractère et classes POSIX


Classes de caractère

Les classes de caractère définissent un ensemble de caractères permis (resp. interdits), auquel le prochain caractère de la chaîne sujet doit appartenir (resp. ne doit pas appartenir).
Dans les classes de caractère, la plupart des méta-caractères perdent leur signification spéciale (comme $ . ou *) et sont interprétés littéralement; certains revêtent une autre signification (comme ^).

[ ... ] Représente tout caractère d'un ensemble explicite : "[aeiouy]" représente toute voyelle minuscule. Un ensemble contigu (en Unicode le code définit un ordre) peut être défini en plaçant un trait d'union entre les caractères de départ et de fin : "[a-z]" représente toute lettre ASCII minuscule. Pour inclure un tiret (-) dans l'ensemble, placez-le au début ou à la fin de l'ensemble, ou utilisez l'échappement (\-).
Notez que le modèle "[A-z]" est distinct de "[A-Za-z]" : ce dernier équivaut à "[A-Z\[\\\]^_`a-z]".
Pour inclure un crochet fermant dans l'ensemble, placez-le en première position de l'ensemble ou utilisez l'échappement : "[][]" ou encore "[\[\]]" correspond à "[" ou "]".
Notez que dans une classe de caractère, seules les séquences \d, \D, \h, \H, \p{}, \P{}, \s, \Q...\E, \S, \v, \V, \w, \W, et \x conservent leur signification spéciale, tandis que \b désigne le caractère retour arrière (Chr(8)).
[^ ... ] Complémentation d'une classe : représente tout caractère qui n'est pas dans l'ensemble : "[^0-9]" représente tout caractère qui n'est pas un chiffre décimal ASCII. Pour inclure un caret (^) dans un ensemble, placez-le ailleurs qu'en première position de l'ensemble ou utilisez l'échappement (\^).

Les classes POSIX

Ce sont des spécifications d'ensembles prédéfinis destinés à être utilisées elles-mêmes dans une classe de caractère : "[z[:digit:]w-y]" est le même modèle que "[w-z0-9]". Pour complémenter une classe POSIX, placez un caret (^) devant son nom : "[[:^digit:]]".
Quand UCP est activé, certaines classes POSIX s'étendent à des sous-ensembles de caractères Unicode, sinon elles sont par défaut restreintes à des caractères ASCII 7 bits.

[:alnum:] Lettres et chiffres ASCII 7 bits (équivaut à [^\W_] ou encore [A-Za-z0-9]).
Quand UCP est activé : lettres et chiffres Unicode (équivaut à [^\W_] ou \p{Xan}).
[:alpha:] Lettres ASCII (équivaut à [^\W\d_] ou [A-Za-z]).
Quand UCP est activé : lettres Unicode (équivaut à [^\W\d_] ou \p{L}).
[:ascii:] Caractères ASCII 7 bits (équivaut à [\x00-\x7F]).
[:blank:] Espacement horizontal (équivaut à \h ou [\x09\x20]).
Quand UCP est activé : espacement horizontal Unicode (équivaut à \h).
[:cntrl:] Caractères de contrôle ASCII (équivaut à Chr(0) ... Chr(31) et Chr(127)).
[:digit:] Chiffres décimaux ASCII (équivaut à \d ou [0-9]).
Quand UCP est activé : chiffres décimaux Unicode (équivaut à \d or \p{Nd}).
[:graph:] Caractères ASCII imprimables hors espacements (équivaut à Chr(33) ... Chr(126)).
[:lower:] Lettres minuscules ASCII 7 bits (équivaut à [a-z]).
Quand UCP est activé : lettres minuscules Unicode (équivaut à \p{Ll}).
[:print:] Caractères ASCII imprimables ASCII 7 bits, y compris espacements (équivaut à Chr(32) ... Chr(126)).
[:punct:] Caractères de ponctuation ASCII, [:print:] sauf [:alnum:] et Espace, (33-47, 58-64, 91-96, 123-126).
[:space:] Espacements ASCII (équivaut à [\h\x0A-\x0D]). [:space:] n'est pas tout à fait équivalant à \s car il inclut VT, Chr(11)).
[:upper:] Lettres majuscules ASCII 7 bits (équivaut à [A-Z]).
Quand UCP est activé : lettres majuscules Unicode (équivaut à \p{Lu}).
[:word:] Caractères 'mot' ASCII 7 bits (équivaut à \w or [[:alnum:]_]).
Quand UCP est activé : caractères 'mot' Unicode (équivaut à \w ou [[:alnum:]_] ou \p{Xwd}).
[:xdigit:] Chiffres hexadécimaux (équivaut à [0-9A-Fa-f]).

Groupes


Les Groupes sont utilisés pour délimiter des sous-modèles et sont les blocs de construction d'expressions puissantes. Les groupes peuvent capturer ou pas et peuvent être imbriqués quelle que soit leur nature, à l'exception des groupes de commentaire. Une expression régulière peut contenir jusqu'à 65535 groupes de capture.
Les lettres d'option (ci-dessus) peuvent être insérés entre "?" et ":" des groupes non-capturants : "(?-i:[aeiouy]{5})" représente 5 voyelles minuscules. Dans ce cas, les options sont locales au groupe.

( ... ) Groupe capturant. Les éléments d'un groupe sont traités dans l'ordre et peuvent être répétés comme un bloc. Par exemple, "(ab)+c" trouvera "abc" or "ababc", mais pas "abac".
Un groupe capturant enregistre le texte auquel il a concordé et ce contenu est utilisable par référence arrière. Ce contenu se retrouve dans le tableau renvoyé dans certains modes. Les groupes capturant sont numérotés à partir de 1 dans l'ordre d'apparition de leur parenthèse ouvrante.
Les groupes capturant peuvent également être considérés comme des sous-routines, référençables ailleurs dans le modèle, éventuellement de manière récursive.
(?<nom> ... ) Groupe de capture nommé. Peut être appelé plus tard par son nom aussi bien que par son numéro. Évitez d'utiliser le nom "DEFINE" (voir "Modèles conditionnels").
(?: ... ) Groupe non-capturant. N'enregistre pas le texte auquel il a concordé et n'est pas numéroté ; ne peut donc pas être réutilisé par référencence arrière.
(?| ... ) Groupe non-capturant avec réemploi. Affecte le même numéro à tous les groupes capturant de premier niveau figurant dans les alternatives de ce groupe : "(?|(Lu)ndi|(Ma)rdi|(Me)rcredi|(Je)udi|(Ve)ndredi|(Sa)medi|(Di)manche)" représente un nom de jour de la semaine et capture son abréviation dans le groupe numéro 1.
(?> ... ) Groupe atomique non-capturant : traite le contenu auquel il concorde comme une entité indivisible (voir aussi Quantificateurs et gourmandise ci-dessous). Les groupes atomiques, comme les quantifications possessives, sont toujours gourmands.
(?# ... ) Groupe commentaire : toujours ignoré (mais ne peut pas contenir une parenthèse fermante donc les commentaires de groupes ne sont pas emboîtables).

Quantificateurs et gourmandise


Les Quantificateurs (ou spécificateurs de répétition) spécifient combien de ce qui précède, caractère, classe, référence ou groupe devraient concorder. Les qualificatifs optionnels de gourmandise indiquent avec quelle agressivité la répétition se comportera. Par exemple "\d{3,5}" représente au moins 3 et au plus de 5 chiffres décimaux.
Par défaut, les modèles sont "gourmands", ce qui signifie que les quantificateurs * + ? {...} concorderont à la chaîne la plus longue qui ne fera pas échouer le reste du modèle. La gourmandise peut être inversée pour l'ensemble du motif par l'option (?U) en tête du modèle, ou localement en plaçant un point d'interrogation après un quantificateur.
Les répétitions non-gourmandes (frugales) concorderont à la plus petite chaîne qui permettra au reste du modèle de réaliser la concordance. Par exemple étant donné le texte "aaab", le modèle "(a*)([ab]+)" capturera "aaa" puis "b", mais "(?U)(a*)([ab]+)" capturera "" puis "a": en effet, la capture d'une chaîne vide satisfait l'élément frugal "(a*)" et la capture de "a" concorde au sous-modèle frugal "([ab]+)".
Les quantificateurs possessifs sont atomiques et gourmands. En fait, ils sont une notation abrégée pour les groupes atomiques simples. "\d++" est une notation abrégée pour "(?>\d+)" et son comportement est "faire concorder une séquence indivisible d'un ou plusieurs chiffres décimaux, sans possibilité d'en restituer seulement une partie par retour arrière". En conséquence "\d++(\d)" est un modèle voué à l'échec du fait que le dernier chiffre (en gras) fait forcément partie du groupe indivisible "\d++" qui le précède. Par contraste, la gourmandise simple "\d+(\d)" fera d'abord concorder une séquence complète de chiffres pour satisfaire l'élément "\d+", mais entraînera un retour arrière et la restitution du dernier chiffre de la séquence pour satisfaire sa capture par "(\d)".
Il y a deux raisons principales qui amènent à employer un groupe atomique ou un quantificateur possessif : pour la concordance avec une séquence de caractères qui peuvent aussi apparaître individuellement (e.g. "\r\n" dans la définition de \R), ou pour forcer rapidement l'échec dans certaines situations utilisant des répétitions non bornées qui amèneraient le moteur à tester un nombre gigantesque de combinaisons de groupements avant de finalement échouer.

? 0 ou 1, gourmand.
?+ 0 ou 1, possessif.
?? 0 ou 1, frugal.
* 0 ou plus, gourmand.
*+ 0 ou plus, possessif.
*? 0 ou plus, frugal.
+ 1 ou plus, gourmand.
++ 1 ou plus, possessif.
+? 1 ou plus, frugal.
{x} exactement x.
{x,y} au moins x et au plus y, gourmand.
{x,y}+ au moins x et au plus y, possessif.
{x,y}? au moins x et au plus y, frugal.
{x,} x ou plus, gourmand.
{x,}+ x ou plus, possessif.
{x,}? x ou plus, frugal.

Alternative


X|Y Représente l'une des alternatives X ou Y: "ac|dc|ground" représente "ac" ou "dc" ou "ground".

Références arrières et références à des sous-programmes


Les références arrières permettent la réutilisation du contenu d'un groupe précédemment capturé.

\n Référence au numéro absolu d'un groupe précédemment capturé. ATTENTION: si aucun groupe numéroté n n'existe, cet élément est évalué comme le caractère de valeur n si n est une valeur octale valide, sinon d'autres erreurs apparaissent.
        En raison de cette ambiguïté, cette formulation est à utiliser avec précaution. Favorisez les formes suivantes pour une meilleure sécurité sémantique.
\gn Référence au numéro absolu d'un groupe précédemment capturé.
\g{n} Référence au numéro absolu d'un groupe précédemment capturé. Similaire au précédent mais délimite clairement n : impérative lorsque les caractères qui suivent sont des chiffres.
\g-n Référence au numéro relatif d'un groupe précédemment capturé.
\k<nom> Référence au nom d'un groupe précédemment capturé.

Référence à un sous-programme

Les groupes capturant peuvent être invoqués (éventuellement de manière récursive) exactement comme des sous-programmes dans un langage de programmation. Le sous-modèle est tout simplement ré-exécuté au point courant dans le sujet. Voir la documentation de référence pour des détails et des exemples.

(?R) ou (?0) Récursivité vers l'expression régulière entière.
(?n) Appelle un sous-modèle par son numéro absolu.
(?+n) Appelle un sous-modèle par son numéro relatif.
(?-n) Appelle un sous-modèle par son numéro relatif.
(?&nom) Appelle un sous-modèle par son nom.

Ancrages et assertions


Les ancrages et les assertions sont des contraintes, des tests qui ne changent pas la position dans le texte et donc ne consomment ni ne capturent quoi que ce soit.

Un ancrage teste la position courante dans le sujet.

^ En dehors d'une classe de caractère, ce test est satisfait si la position courante est le début du sujet, mais également après une séquence de saut de ligne non-finale si l'option (?m) est active. Par défaut, la séquence de saut de ligne est soit @CRLF, soit @CR ou @LF isolés.
        Dans une classe de caractères, un caret ^ complémente la classe (exclut les caractères qu'elle représente) s'il figure en première position, concorde littéralement s'il se trouve dans une autre position.
$ En dehors d'une classe de caractères, ce test est satisfait si la position courante est à la fin du texte, mais également avant une séquence de saut de ligne si l'option (?m) est active.
Dans une classe de caractères, $ représente le signe dollar lui-même.
\A Test satisfait si la position courante est le début du texte, indépendamment de l'option multiligne (?m). Échoue forcément si $iStart n'est pas 1.
\G Test satisfait si la position courante est la première concordance trouvée dans le texte.
\z Test satisfait si la position courante est à la fin du texte, indépendamment de l'option multiligne (?m).
\Z Test satisfait si la position courante est à la fin du texte ou avant une séquence de saut de ligne, indépendamment de l'option multiligne (?m).

Une assertions teste les caractères qui précédent (look-behind), une frontière de mot (\b) ou qui suivent (look-ahead) le point courant dans le texte.

\b Test satisfait si la position courante est à la limite d'un 'mot', soit entre des caractères non tous deux \w ou \W. Voir \w pour la signification de 'mot'. Dans une classe de caractères, \b est le caractère de contrôle retour arrière (Chr(8)).
\B Test satisfait si la position courante n'est pas à la limite d'un 'mot'.
(?=X) Look-ahead positif : test satisfait si le sous-modèle X concorde à partir de la position courante.
(?!X) Look-ahead négatif : test satisfait si le sous-modèle X ne concorde pas à partir de la position courante.
(?<=X) Look-behind positif : test satisfait si le sous-modèle X concorde avec les caractères qui précèdent la position courante. Le modèle X doit concorder avec une chaîne de longueur bornée, c'est-à-dire ne pas utiliser de quantificateurs indéfinis * + ou ? ou leurs équivalents.
(?<!X) Look-behind négatif : test satisfait si le sous-modèle X ne concorde pas aux caractères qui précédent la position courante. Le modèle X doit concorder avec une chaîne de longueur bornée, c'est-à-dire ne pas utiliser de quantificateurs indéfinis * + ou ? ou leurs équivalents.

Ré-initialisation de la concordance


Il y a des situations où il est nécessaire "d'oublier" qu'une concordance a été trouvée jusqu'à présent, afin de trouver une concordance plus pertinente plus loin dans le texte.

\K Ré-initialise le démarrage de la recherche au point courant du sujet. Notez que les groupes déjà capturés sont conservés dans le tableau renvoyé ; il est donc toujours possible d'y faire référence plus tard. L'action de \K est similaire mais non identique à un look-behind, en ce que \K permet de travailler avec un sous-modèle de longueur non bornée.

Blocs conditionnels


Ces constructions sont similaires aux blocs If...EndIf et If...Else...EndIf.

(?(condition)modèle_si_vrai) Permet une exécution conditionnelle de modèle_si_vrai.
(?(condition)modèle_si_vrai|modèle_si_faux) Applique l'un des modèles suivant le résultat de (condition).
    où (condition) peut être de la forme suivante :
(n) Teste si le groupe de capture de numéro absolu n permet la concordance.
(+n) Teste si le groupe de capture de numéro relatif +n permet la concordance.
(-n) Teste si le groupe de capture de numéro relatif -n permet la concordance.
(<nom>) Teste si le groupe de capture nommé nom permet la concordance.
(R) Teste si une quelconque récurrence s'est produite.
(Rn) Teste si la plus récente récurrence portait sur la capture par le groupe de numéro absolu n.
(R&name) Teste si la plus récente récurrence portait sur la capture par le groupe de nom name.
(DEFINE) Utilisée sans modèle_si_faux : permet la définition d'un sous-programme nommé utilisable par ailleurs. "(?x) (?(DEFINE) (?<octet> 2[0-4]\d | 25[0-5] | 1\d\d | [1-9]?\d) )" définit un sous-programme nommé "octet" qui permet une concordance avec un composant numérique d'adresse IPv4. Ensuite, une adresse réelle peut être recherchée par "\b (?&byte) (\.(?&byte)){3} \b".
(assertion) Ici assertion est une assertion positive ou negative, look-ahead ou look-behind.

Fonctionnalités avancées diverses


Les options, les escapes et les constructions sont simplement mentionnés ici ; voir la documentation de référence pour comprendre pourquoi, quand et comment les utiliser, voire pas du tout.

Paramètres et options peu fréquents

            
(?J) Permet d'assigner un même nom à plusieurs groupes ou sous-programme (non détaillé ici).
(?X) Les éléments hors contexte provoquent une erreur, au lieu d'être ignorés.
(*J) Autorise une compatibilité partielle avec les expressions régulières Javascript (non détaillé ici).
(*LIMIT_MATCH=n) Limite à n le nombre de concordances trouvées.
(*LIMIT_RECURSION=n) Limite la récursion à n niveaux.
(*NO_START_OPT) Désactive plusieurs optimisations (non détaillé ici).

Contrôle du retour arrière (backtracking)

(*ACCEPT) Force le succès immédiat de la concordance dans le sous-programme en cours ou dans le modèle de premier niveau.
(*FAIL) ou (*F) Force l'échec immédiat de la recherche.
(*MARK:nom) or (*:nom) (Voir la documentation de référence.)
(*COMMIT) (Voir la documentation de référence.)
(*PRUNE) (Voir la documentation de référence.)
(*PRUNE:name) (Voir la documentation de référence.)
(*SKIP) (Voir la documentation de référence.)
(*SKIP:name) (Voir la documentation de référence.)
(*THEN) (Voir la documentation de référence.)
(*THEN:name) (Voir la documentation de référence.)

Commentaires généraux sur les expressions régulières AutoIt


    1. Lorsque UCP est actif, la sensibilité à la casse s'applique sur le plan 0 du jeu Unicode. Il y a aussi un petit nombre de 'many-to-one mappings' dans Unicode, comme la lettre minuscule Grèque sigma; elles sont supportées par PCRE avec l'option UCP installée.

    2. D'autres syntaxes existent dans d'autres dialectes tels Perl, Ruby, Python, JavaScript, .NET et d'autres moteurs. Ne pas utiliser de constructions non énumérées ici : certaines ne fonctionneront simplement pas, certaines fourniront des résultats erronés, d'autres provoqueront des problèmes graves ou simplement un crash.

    3. La convention de saut de ligne par défaut est une séquence indivisible @CRLF ou un caractère isolé @CR ou @LF. De façon similaire \R cherche la concordance avec le même ensemble. Analysez vos données ! Si vous savez que votre texte utilise les caractères séparés @LF ou @CR pour indiquer quelque chose d'autre qu'un saut de ligne, vous pourriez avoir à modifier la convention de saut de ligne et/ou la recherche d'une concordance par \R (voir "Paramètres").

Voir aussi le tutoriel Expression Régulière, dans lequel vous pouvez exécuter un script pour tester vos expressions régulières.

En relation

StringInStr, StringRegExpReplace

Exemples

Exemple 1

; == Mode 0: REGEXPMATCH
; Retourne 1 si une première concordance a été trouvée, sinon 0

#include <MsgBoxConstants.au3>
#include <StringConstants.au3>

Global $sujet, $regex, $iResult

$sujet = "Aujourd'hui, on est Dimanche"
$regex = "\bDi" ; Critère: mot commençant par "Di"   
    
$iResult = StringRegExp($sujet, $regex, $STR_REGEXPMATCH)
MsgBox($MB_SYSTEMMODAL, "Mode 0", ($iResult = 1 ? "Trouvé" : "Non trouvé"))

Exemple 2

; == Mode 1: REGEXPARRAYMATCH
; Retourne le tableau des groupes capturés pour la première concordance
; Si aucun groupe n'est capturé, retourne le résultat complet de la concordance en [0]

#include <MsgBoxConstants.au3>
#include <StringConstants.au3>
#include <Array.au3>

Global $sujet, $regex, $aArray  

$sujet = "Dimanche Lundi Mardi Mercredi"
$regex = "\b\w+di\b" ; Mot se terminant par 'di' et aucun groupe capturé
$aArray = StringRegExp($sujet, $regex, $STR_REGEXPARRAYMATCH)
_ArrayDisplay($aArray, "Mode 1 - sans capture")     

$regex = "\b(\w+)(di)\b" ; Mot se terminant par 'di'  et deux groupes capturés
$aArray = StringRegExp($sujet, $regex, $STR_RegExpArrayMatch)
_ArrayDisplay($aArray, "Mode 1 - deux captures")

Exemple 3

; == Mode 1: REGEXPARRAYMATCH
; Utilisation du paramètre $iStart pour boucler sur les concordances

#include <MsgBoxConstants.au3>
#include <StringConstants.au3>
#include <Array.au3>

Global $sujet, $regex, $aArray, $iStart 

$sujet = "Dimanche Lundi Mardi Mercredi"
$regex = "(\b\w+)(di)\b" ; Mot se terminant par 'di' et deux groupes capturés
    
$aArray = StringRegExp($sujet, $regex, $STR_REGEXPARRAYMATCH)
While @error = 0
    $iStart = @extended
    _ArrayDisplay($aArray, "Mode 1")
    $aArray = StringRegExp($sujet, $regex, $STR_REGEXPARRAYMATCH, $iStart)
WEnd

Exemple 4

; == Mode 2: REGEXPARRAYFULLMATCH  (retour simple, style php/preg_match())
; Cherche la première concordance et retourne un tableau avec le résultat complet en [0]
; suivi des groupes de capture en [1], [2], ...

#include <MsgBoxConstants.au3>
#include <StringConstants.au3>
#include <Array.au3>

Global $sujet, $regex, $aArray
 
$sujet = "Dimanche Lundi Mardi Mercredi"
$regex = "\b(\w+)(di)\b"
$aArray = StringRegExp($sujet, $regex, $STR_REGEXPARRAYFULLMATCH)
    
_ArrayDisplay($aArray, "Mode 2")

Exemple 5

; == Mode 3 : REGEXPARRAYGLOBALMATCH  (retour global, style ancien AutoIt)
; Retourne le tableau des groupes capturés de TOUTES les concordances

#include <Array.au3>
#include <StringConstants.au3>
#include <Array.au3>

Global $sujet, $regex, $aArray

$sujet = "Dimanche Lundi Mardi Mercredi"
$regex = "\b(\w+)(di)\b"
$aArray = StringRegExp($sujet, $regex, $STR_REGEXPARRAYGLOBALMATCH)

_ArrayDisplay($aArray, "Mode 3")

Exemple 6

; == Mode 4 : REGEXPARRAYGLOBALFULLMATCH (retour global, style php/preg_match_all())
; Retourne un tableau avec autant d'éléments que de concordances
; Chaque élément est lui-même un tableau contenant la concordance complète ainsi que les groupes capturés.

#include <Array.au3>
#include <StringConstants.au3>
#include <Array.au3>

Global $sujet, $regex, $aConcordance, $aArray

$sujet = "Dimanche Lundi Mardi Mercredi"
$regex = "\b(\w+)(di)\b"

$aConcordance = StringRegExp($sujet, $regex, $STR_REGEXPARRAYGLOBALFULLMATCH)

for $i=0 to UBound($aConcordance)-1
    $aArray = $aConcordance[$i]
    _ArrayDisplay($aArray, "Mode 4 - retour global")    
Next