Référence Fonctions

StringRegExp

Vérifie si une chaîne de caractères correspond à un modèle d'expression régulière.

StringRegExp ( "sujet", "modèle" [, mode = 0 [, début = 1]] )

Paramètres

sujet	La chaîne à vérifier
modèle	L'expression régulière à utiliser.
mode	[optionnel] Valeur qui conditionne le comportement de la fonction. Voir plus bas pour plus de détails. La valeur par défaut est $STR_REGEXPMATCH.
début	[optionnel] La position dans la chaîne du début de la recherche (commence à 1). La valeur par défaut est 1.

Mode	Valeurs
$STR_REGEXPMATCH (0)	Retourne 1 (correspondance trouvée) ou 0 (aucune correspondance trouvée)
$STR_REGEXPARRAYMATCH (1)	Retourne le tableau des occurrences.
$STR_REGEXPARRAYFULLMATCH (2)	Retourne un tableau de résultats incluant le résultat complet (style Perl / PHP).
$STR_REGEXPARRAYGLOBALMATCH (3)	Retourne un tableau de résultats globaux.
$STR_REGEXPARRAYGLOBALFULLMATCH (4)	Retourne un tableau de tableaux contenant les résultats globaux incluant le résultat complet (style Perl / PHP).

Ces constantes sont définies dans StringConstants.au3

Valeur de retour

Mode = $STR_REGEXPMATCH (0) :

:	@error 2 Modèle erroné. @Extended = position de l'erreur dans le modèle.

Mode = $STR_REGEXPARRAYMATCH (1) ou $STR_REGEXPARRAYFULLMATCH (2) :

:	@error 0 Tableau valide. @extended = position suivante dans le sujet 1 Tableau invalide : aucune correspondance. 2 Modèle erroné : tableau invalide. @extended = position de l'erreur dans le modèle.

Mode = $STR_REGEXPARRAYGLOBALMATCH (3) ou $STR_REGEXPARRAYGLOBALFULLMATCH (4) :

:	@error 0 Tableau valide. 1 Tableau invalide : aucune correspondance. 2 Modèle erroné : tableau invalide. @extended = position de l'erreur dans le modèle.

Remarques

Le paramètre flag peut avoir une des 5 valeurs ($STR_REGEXPMATCH (0) à $STR_REGEXPARRAYGLOBALFULLMATCH (4)).

$STR_REGEXPMATCH (0)	retourne 1 (True) ou 0 (False) selon que le modèle a été trouvé ou pas.
$STR_REGEXPARRAYMATCH (1) $STR_REGEXPARRAYFULLMATCH (2)	trouve la première correspondance et retourne les groupes capturés dans un tableau ; quand le modèle n'a pas capturé de groupe, la première correspondance est retournée dans le tableau.
$STR_REGEXPARRAYGLOBALMATCH (3) $STR_REGEXPARRAYGLOBALFULLMATCH (4)	remplit le tableau avec toutes les occurrences des correspondances.

$STR_REGEXPARRAYFULLMATCH (2) et $STR_REGEXPARRAYGLOBALFULLMATCH (4) incluent le texte complet de la correspondance comme le premier élément du tableau retourné, pas seulement les groupes capturés comme avec les flags $STR_REGEXPARRAYMATCH (1) et $STR_REGEXPARRAYGLOBALMATCH (3).

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

Plus précisémment, le moteur des expressions régulières s'efforce de trouver une ou des correspondances entre le modèle (une sorte de format préprogrammé) et la chaîne sujet, de la gauche vers la droite. Si une différence apparaît, 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 correspondra ainsi.

Le retour arrière ('backtracking') est un aspect fondamental des moteurs d'expressions réguliè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 (correspondance trouvée) ou avoir exploré toutes les voies sans atteindre l'objectif (correspondance 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. PCRE signifie "Perl-Compatible Regular Expressions" et 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 faisant 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 correspond à @CRLF, @CR ou @LF.
*(BSR_UNICODE)**	Change la signification de \R pour correspondre à 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ées : "(?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 : la correspondance devient insensible à la casse à partir de ce point. Par défaut, la correspondance est sensible à 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 $ correspondent soit au début (resp. à la fin) du sujet, soit à la position précédent (resp. suivant) une séquence de saut de ligne. Par défaut, l'option multiligne est désactivée.
(?s)	Mono-ligne ou DotAll: . correspond à tout caractère, y compris une séquence de saut de ligne. L'option DotAll est désactivée par défaut, ainsi . ne correspond 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'à la prochaine nouvelle ligne 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 échappement (escaping ou quoting)

Caractères

Les modèles d'expressions régulières se composent de littéraux Unicode (portions de texte qui correspondent à elles-mêmes), entremêlés 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êmes 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 correspondent 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ées 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 le 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 correspond à une minuscule doublée. À éviter soigneusement à cause de cette ambiguïté ! 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

.	Correspond à tout caractère Unicode excepté une séquence de saut de ligne. Correspond à tout caractère Unicode lorsque l'option (?s) est active.
\d	Correspond à tout chiffre décimal (n'importe quel chiffre décimal Unicode de n'importe quel langage quand UCP est activé).
\D	Correspond à tout caractère qui n'est pas un chiffre.
\h	Correspond à tout caractère d'espacement horizontal (voir tableau ci-dessous).
\H	Correspond à tout caractère hors espacements horizontaux.
\N	Correspond à 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 : correspond à tout caractère Unicode possédant la propriété ppp. Par exemple, "\b\p{Cyrillic}+" correspond à tout mot cyrillique ; "\p{Sc}" correspond à 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 : correspond à tout caractère Unicode ne possédant pas la propriété ppp.
\R	Correspond à toute séquence 'newline' Unicode par défaut, ou avec le paramètre (*BSR_...) actif. Par défaut \R correspond à "(?>\r\n\|\n\|\r)" où "(?>...)" est un groupe atomique, entité qui rend la séquence "\r\n" (@CRLF) indivisible.
\s	Correspond à tout caractère d'espacement (voir tableau ci-dessous).
\S	Correspond à tout caractère hors espacements.
\v	Correspond à tout caractère d'espacement vertical (voir tableau ci-dessous).
\V	Correspond à tout caractère hors espacement vertical.
\w	Correspond à 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	Correspond à tout caractère qui n'est pas 'mot'.
\X	Seulement quand UCP est activé : correspond à 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 correspond à 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 correspondant à \h

\h est équivalent à "[\x09 \xA0]" par défaut (ou "[\x09 \xA0\x{1680}\x{180E}\x{2000}-\x{200A}\x{202F}\x{205F}\x{3000}]" quand UCP est activé.)
Cet ensemble se lit aussi : tabulation horizontale (HT), espace, espace insécable (en ajoutant : marque d'espace Ogham, séparateur de voyelle Mongolien, demi-cadratin, cadratin, espace demi-cadratin, espace cadratin, tiers de cadratin, quart de cadratin, sixième de cadratin, espace tabulaire, espace de ponctuation, espace fine, espace ultra-fine, espace insécable fin, espace mathématique moyen, espace idéographique quand UCP est activé.)

Caractères d'espacement vertical correspondant à \v

\v est équivalent à "[\x0A-\x0D]" par défaut (ou "[\x0A-\x0D\x{0085}\x{2028}\x{2029}]" quand UCP est activé.)
Cet ensemble se lit aussi : Linefeed (LF), Vertical tab (VT), Form feed (FF), Carriage return (CR) (en ajoutant : Next line (NEL), Line separator, Paragraph separator quand UCP est activé.)

Caractères d'espacement correspondant à \s

\s est équivalent à "[\h\x0A\x0C\x0D]".
Cet ensemble comprend tous les caractères de \h plus Linefeed (LF), Form feed (FF), Carriage return (CR).

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 ^).

[ ... ]

correspond à tout caractère d'un ensemble explicite : "[aeiouy]" correspond à 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]" correspond à 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 : correspond à tout caractère qui n'est pas dans l'ensemble : "[^0-9]" correspond à 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ère 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})" correspond à 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 correspondu 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 correspondu 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)" correspond à 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 correspond 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 correspondre. Les qualificatifs optionnels de gourmandise indiquent avec quelle agressivité la répétition se comportera. Par exemple "\d{3,5}" correspond à 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 * + ? {...} correspondront à 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) correspondront à la plus petite chaîne qui permettra au reste du modèle de correspondre. Par exemple étant donné le sujet "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" correspond 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 correspondre une séquence indivisible d'un ou plusieurs chiffres décimaux, sans possibilité d'en restituer une partie seulement 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 correspondre 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 correspondance 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	Correspond à l'une des alternatives X ou Y: "ac\|dc\|ground" correspond à "ac" ou "dc" ou "ground".

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

Les références arrière 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 sujet 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, correspond 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 sujet, mais également avant une séquence de saut de ligne si l'option (?m) est active. Dans une classe de caractères, $ correspond au signe dollar lui-même.
\A	Test satisfait si la position courante est le début du sujet, indépendamment de l'option multiligne (?m). Échoue forcément si l'offset n'est pas 1.
\G	Test satisfait si la position courante est la première correspondance trouvée dans le sujet.
\z	Test satisfait si la position courante est à la fin de la chaîne sujet, indépendamment de l'option multiligne (?m).
\Z	Test satisfait si la position courante est à la fin de la chaîne sujet ou avant une séquence de saut de ligne, indépendamment de l'option multiligne (?m).

Une assertion 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 sujet.

\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 correspond à partir de la position courante.
(?!X)	Look-ahead négatif : test satisfait si le sous-modèle X ne correspond pas à partir de la position courante.
(?<=X)	Look-behind positif : test satisfait si le sous-modèle X correspond aux caractères qui précèdent la position courante. Le modèle X doit correspondre à 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 correspond pas aux caractères qui précédent la position courante. Le modèle X doit correspondre à 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 correspondance

Il y a des situations où il est nécessaire "d'oublier" qu'une correspondance a été trouvé jusqu'à présent, afin de trouver une correspondance plus pertinente plus loin dans la chaîne sujet.

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 correspondance.
(+n)	Teste si le groupe de capture de numéro relatif +n permet la correspondance.
(-n)	Teste si le groupe de capture de numéro relatif -n permet la correspondance.
(<nom>)	Teste si le groupe de capture nommé nom permet la correspondance.
(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 correspondance 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 correspondances 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 correspondance 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 correspondances bi-univoques dans Unicode, comme la lettre minuscule Grèque sigma (intermédiaire ou final) ; elles sont supportées par PCRE par l'option UCP.

    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 correspondance du même ensemble. Analysez vos données ! Si vous savez que votre texte sujet 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 correspondance 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.

StringInStr(), StringRegExpReplace()

Example

Option 1, utilisation du paramètre offset


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

Local $aArray = 0, _
        $iOffset = 1
While 1
    $aArray = StringRegExp('<test>a</test> <test>b</test> <test>c</Test>', '(?i)<test>(.*?)</test>', $STR_REGEXPARRAYMATCH, $iOffset)
    If @error Then ExitLoop
    $iOffset = @extended
    For $i = 0 To UBound($aArray) - 1
        MsgBox($MB_SYSTEMMODAL, "RegExp Test with Option 1 - " & $i, $aArray[$i])
    Next
WEnd

Option 2, retour simple, style php/preg_match()


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

Local $aArray = StringRegExp('<test>a</test> <test>b</test> <test>c</Test>', '(?i)<test>(.*?)</test>', $STR_REGEXPARRAYFULLMATCH)
For $i = 0 To UBound($aArray) - 1
    MsgBox($MB_SYSTEMMODAL, "RegExp Test with Option 2 - " & $i, $aArray[$i])
Next

Option 3, retour global, ancien style AutoIt


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

Local $aArray = StringRegExp('<test>a</test> <test>b</test> <test>c</Test>', '(?i)<test>(.*?)</test>', $STR_REGEXPARRAYGLOBALMATCH)
For $i = 0 To UBound($aArray) - 1
    MsgBox($MB_SYSTEMMODAL, "RegExp Test with Option 3 - " & $i, $aArray[$i])
Next

Option 4, retour global, style php/preg_match_all()


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

Local $aArray = StringRegExp('F1oF2oF3o', '(F.o)*?', $STR_REGEXPARRAYGLOBALFULLMATCH)
Local $aMatch = 0
For $i = 0 To UBound($aArray) - 1
    $aMatch = $aArray[$i]
    For $j = 0 To UBound($aMatch) - 1
        MsgBox($MB_SYSTEMMODAL, "RegExp Test with Option 4 - " & $i & ',' & $j, $aMatch[$j])
    Next
Next