Référence Fonctions

StringRegExp

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

StringRegExp ( "test", "pattern" [, flag = 0 [, offset = 1]] )

Paramètres

test	La chaîne à vérifier
pattern	L'expression régulière à comparer.
flag	[optionnel] Nombre qui indique comment la fonction se comporte. Voir plus bas pour plus de détails. La valeur par défaut est 0.
offset	[optionnel] La position dans la chaîne pour commencer la recherche (commence à 1). La valeur par défaut est 1.

Flag	Valeurs
$STR_REGEXPMATCH (0)	Retourne 1 (trouvé) ou 0 (non trouvé)
$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).

Les constantes sont définies dans StringConstants.au3

Valeur de retour

Flag = $STR_REGEXPMATCH (0) :

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

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

:	@error 0 Tableau valide. @extended = position suivante 1 Tableau invalide. Aucune correspondance. 2 Mauvais modèle, tableau invalide. @extended = position de l'erreur dans le modèle.

Flag = $STR_REGEXPARRAYGLOBALMATCH (3) or $STR_REGEXPARRAYGLOBALFULLMATCH (4) :

:	@error 0 Tableau valide. @extended = position suivante 1 Tableau invalide. Aucune correspondance. 2 Mauvais modèle, 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 parties spécifiques peuvent être extraites avec StringRegExp() ou remplacées en utilisant StringRegExpReplace().

Plus précisemment, le moteur des expressions régulières essaie de trouver des correspondances du modèle (une sorte de format préprogrammé) dans une chaîne donnée, de la gauche vers la droite. Si une différence apparait, 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 'backtracking' est un aspect fondamental des moteurs d'expressions régulères et le programmeur qui comprend ce mécanisme l'utilise tous les jours. Il consiste à laisser une marque spécifique sur chaque noeud de l'arbre et de revenir au dernier noeud du parcours lorsque le chemin choisi se révèle être une impasse: vous faites marche arrière (backtrack) au besoin jusqu'à ce que vous trouviez le bon noeud (correspondance trouvée) ou que vous exploriez chaque chemin sans atteindre votre objectif (correspondance non trouvée). La recherche d'un nom de fichier donné avec jokers facultatifs à l'intérieur d'une arborescence nest pas différente.

AutoIt utilise le moteure PCRE. PCRE signifie "Perl-Compatible Regular Expressions" et il 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 garder une vitesse de recherche meilleure, le support UCP n'est pas activé par défaut. Vous pouvez l'activer en faisant précéder la chaîne de (*UCP) au tout début de votre modèle. Lorsqu'il est activée, 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 uniquement un résumé des éléments les plus utilisés de modèle. Pour une documentation complète et approfondie des expressions régulières comme mis en œuvre 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: de mauvaises expressions régulières peuvent entraîner une boucle quasi-infinie mobilisant le processeur, entraînant même un crash.

Paramètres globaux

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

Conventions retour à la ligne

Les séquences de saut de ligne affectent où les ancres ^ et $ correspondent et quoi \N et . ne correspondent pas. Par défaut, la séquence de saut de ligne est @CRLF comme une séquence insécable ou @CR seul ou @LF seul.
La valeur par défaut peut être modifiée en faisant précéder l'une des séquences suivantes au début d'un motif.

*(CR)**	Carriage return (@CR).
*(LF)**	Line feed (@LF).
*(CRLF)**	Carriage return immédiatement suivi de linefeed (@CRLF).
*(ANYCRLF)**	Un de ceux là: @CRLF, @CR or @LF. Ceci est la convention par défaut de newline.
*(ANY)**	Une des séquence unicode newline: @CRLF, @LF, VT, FF, @CR or \x85.

Ce que \R recherche

*(BSR_ANYCRLF)**	Par défaut \R recherche seulement @CRLF, @CR or @LF.
*(BSR_UNICODE)**	Change \R pour rechercher une séquence Unicode newline: @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 trait d'union sont annulées : "(?im-sx)".
Les options apparaissant en dehors d'un groupe affectent le reste du modèle à partir de là. Les options apparaissant à l'intérieur d'un groupe influent sur ce groupe seulement. Les options perdent leur signification spéciale à l'intérieur d'une classe de caractères , où ils sont traités littéralement.

(?i)	Caseless: la recherche devient insensible à la casse à partir de là. Par défaut, la recherche est sensible à la casse. Quand UCP est activée il s'applique à l'ensemble du plan d'Unicode 0, sinon il s'applique par défaut seulement aux lettres ASCII A-Z et a-z.
(?m)	multiligne: ^ et $ recherche des séquences de sauts de ligne avec des données entre. Par défaut, multiligne est désactivé.
(?s)	Mono-ligne ou DotAll: . recherche tout, y compris une séquence de saut de ligne. Par défaut, DotAll est désactivé donc . ne recherche pas une séquence de saut de ligne.
(?U)	Paresseux: les quantificateurs deviennent paresseux (non gourmands) à partir de là. Par défaut, la recherche est gourmande - voir ci-dessous pour plus de détails.
(?x)	eXtended: les espaces blancs à l'extérieur des classes de caractères sont ignorés et # démarre un commentaire jusqu'à la prochaine nouvelle ligne solide dans le modèle. Les espaces blancs dénués de sens entre les éléments rendent les expressions régulières beaucoup plus lisibles. Par défaut, les espaces blancs se correspondent et # est un caractère littéral.

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

Caractères

Les modèles d'expressions régulières se composent de littéraux Unicode parties de texte qui se correspondent, entremêlées avec les prescripteurs ou les options des expressions régulières. Les prescripteurs et les options utilisent un peu les méta-caractères qui ont une signification particulière par eux-mêmes ou qui introduisent, dans le modèle, des éléments spéciaux décrits dans les tableaux ci-dessous.
Dans certaines parties littérales, les caractères alphanumériques restent 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 "control-X", où X est n'importe quel caractère ASCII 7-bit. Par exemple, "\cM" représente ctrl-M, de même que \x0D ou \r (Chr(13)).
\e	Représente le caractère de contrôle "escape" (Chr(27)). Ne pas confondre avec l'échappement 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 avec le code octal ddd, OU une référence arrière pour capturer un groupe de chiffres ddd en décimal. Par exemple, ([a-z])\1 recherche une lettre doublé. Conseil: comme il peut être ambiguë! Favorisez les représentations hexadécimales ci-dessous.
\xhh	Représente un caractère Unicode en hexadécimal hh: "\x7E" représenté un tilda, "~".
\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, reste un littéral x. Utilisé pour représenter les méta-caractères littéraux: "\.\[" représente un point suivi d'un crochet ouvrant, ".[".
\Q ... \E	Verbatim sequence: les métacaractères perdent leur signification spéciale entre \Q et \E: "\Q(.)\E" recherche "(.)" et est équivalent à "$\.$" mais plus lisible.

Méta-caractères

Les méta-caractères PCRE sont \ . ^ $ | [ ( { * + ? # ils ont une oou plusieurs signification, selon le contexte.
Pour insérer un méta-caractère littéral, faites le précéder par une barre oblique inverse ('backslash') (ceci est appelé 'escaping (or quoting) un 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

.	Cherche tout caractère simple excepté, par défaut, une séquence 'newline'. Cherche aussi 'newline' quand l'option (?s) est active.
\d	Cherche tout chiffre décimal (n'importe quel chiffre décimal unicode dans n'importe quel langage quand UCP est activé).
\D	Cherche tout caractère qui n'est pas un chiffre.
\h	Cherche tout caractère 'blanc horizontal' (voir tableau ci-dessous).
\H	Cherche tout caractère qui n'est pas un 'blanc horizontal'.
\N	Cherche tout caractère sauf une séquence 'newline' peu importe l'option (?s).
\p{ppp}	Seulement quand UCP est activé: cherche tout caractère Unicode avec la propriété ppp. Par exemple, "\b\p{Cyrillic}+" cherche tous les mots cyrilliques; "\p{Sc}" cherche tout symbole monétaire. Consultez la documentation de référence pour plus de détails.
\P{ppp}	Seulement quand UCP est activé: cherche un caractère Unicode qui n'a pas la propriété ppp.
\R	Cherche toute séquence 'newline' Unicode par défaut, ou avec le paramètre (*BSR_...) actif. Par défaut \R cherche "(?>\r\n\|\n\|\r)" où "(?>...)" est une entité, qui rend la séquence "\r\n" (@CRLF) insécable.
\s	Cherche tout caractère 'blanc' (voir tableau ci-dessous).
\S	Cherche tout caractère qui n'est pas 'blanc'.
\v	Cherche tout caractère 'blanc vertical' (voir tableeu ci-dessous).
\V	Cherche tout caractère qui n'est pas 'blanc vertical'.
\w	Cherche tout caractère 'mot': tout chiffre, toute lettre ou l'underscore "_" (tout chiffre Unicode, toute lettre Unicode dans tout langage ou l'underscore "_" quand UCP est activé).
\W	Cherche tout caractère qui n'est pas 'mot'.
\X	Seulement quand UCP est activé: cherche tout Unicode étendu qui est un élément graphème - une séquence insécable de codes qui représente un simple caractère pour l'utilisateur. En conséquence \X peut chercher plus d'un caractère dans la chaîne d'origine, contrairement à toutes les autres séquences de ce tableau.

Ensemble des caractères 'blancs'

Caractères de type 'blanc horizontal' cherchés par \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 est: Horizontal tab (HT), Space, Non-break space (en ajoutant: Ogham space mark, Mongolian vowel separator, En quad, Em quad, En space, Em space, Three-per-em space, Four-per-em space, Six-per-em space, Figure space, Punctuation space, Thin space, Hair space, Narrow no-break space, Medium mathematical space, Ideographic space quand UCP est activé.)

Caractères de type 'blanc vertical' cherchés par \v

\v est équivalent à "[\x0A-\x0D]" par défaut (ou "[\x0A-\x0D\x{0085}\x{2028}\x{2029}]" quand UCP est activé.)
Cet ensemble est: 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 de type 'blanc' cherchés par \s

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

Caractères de type 'blanc' cherchés par [[:space:]]

[[:space:]] est équivalent à "\s".
Cet ensemble est: 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), which the next character in subject is expected to match (resp. not to match).
Dans les classes de caractère, la plupart des méta-caractères perdent leur signification (comme $ . ou *) ou signifie autre chose (comme ^).

[ ... ]

cherche tout caractère d'un ensemble explicite: "[aeiou]" cherche 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]" cherche toute lettre ASCII minuscule. Pour inclure un tiret (-) dans l'ensemble, placez-le au début ou à la fin de l'ensemble, ou faires-en un caractère d'échappement (\-).
Notez que le modèle "[A-z]" n'est pas le même que "[A-Za-z]": cette forme est équivalente à "[A-Z\[\\\]^_`a-z]".
Pour inclure un crochet fermant dans l'ensemble, placez-le en première position de l'ensemble ou faites-en un caractère d'échappement: "[][]" et "[\[\]]" chercheront tous les deux "[" 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 backspace (Chr(8)).

[^ ... ]

Cherche tout caractère qui n'est pas dans l'ensemble: "[^0-9]" cherche tout caractère qui n'est pas un chiffre. Pour inclure un caret (^) dans un ensemble, placez-le en première position de l'ensemble ou faites-en un caractère d'échappement (\^).

Les classes POSIX

Elles sont nommées spécifications d'ensembles pour ê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 nier une classe de caractère POSIX, placez un caret (^) après la première position: "[[:^digit:]]".
Quand UCP est activé, plusieurs classes POSIX s'étendent à des sous-ensembles de caractère Unicode, sinon elles sont par défaut restreintes à des ASCII 7-bit.

[:alnum:]	Lettres et chiffres ASCII (pareil que [^\W_] ou [A-Za-z0-9]). Quand UCP est activé: Lettres et chiffres Unicode (pareil que [^\W_] ou \p{Xan}).
[:alpha:]	Lettres ASCII (pareil que [^\W\d_] ou [A-Za-z]). Quand UCP est activé: lettres Unicode (pareil que [^\W\d_] ou \p{L}).
[:ascii:]	Caractères ASCII (pareil que [\x00-\x7F]).
[:blank:]	Espace ou Tab (@TAB) (pareil que \h ou [\x09\x20]). Quand UCP est activé: 'blanc horizontal' Unicode (pareil que \h).
[:cntrl:]	Caractères de contrôle ASCII (pareil que Chr(0) ... Chr(31) et Chr(127)).
[:digit:]	Chiffres décimaux ASCII (pareil que \d ou [0-9]). Quand UCP est activé: Chiffres décimaux Unicode (pareil que \d or \p{Nd}).
[:graph:]	Caractères ASCII qui s'affichent, sauf Espace (pareil que Chr(33) ... Chr(126)).
[:lower:]	Lettres minuscules ASCII (pareil que [a-z]). Quand UCP est activé: Lettres minuscules Unicode (pareil que \p{Ll}).
[:print:]	Caractères ASCII qui s'affichent, y compris Espace (pareil que Chr(32) ... Chr(126)).
[:punct:]	Caractères de ponctuation ASCII, [:print:] sauf [:alnum:] et Espace, (33-47, 58-64, 91-96, 123-126).
[:space:]	Espaces blancs ASCII (pareil que [\h\x0A-\x0D]). [:space:] n'est pas tout à fait pareil que \s: il inclut VT, Chr(11)).
[:upper:]	Lettres majuscules ASCII (pareil que [A-Z]). Quand UCP est activé: Lettres majuscules Unicode (pareil que \p{Lu}).
[:word:]	Caractères ASCII "Word" (pareil que \w or [[:alnum:]_]). Quand UCP est activé: Caractères Unicode "word" (pareil que \w ou [[:alnum:]_] ou \p{Xwd}).
[:xdigit:]	Chiffres Hexadécimaux (pareil que [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 facilement insérés entre le "?" et le ":" des groupes non - capture: "(?-i:[aeiou]{5})" cherche 5 voyelles minuscules. Dans ce cas, les options sont locales au groupe.

( ... )	Capture de groupe. 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". En capturant des groupes, rappelez-vous le texte qu'ils cherchent pour une utilisation dans les références arrières et qu'ils remplissent le tableau éventuellement retourné. Ils sont numérotés à partir de 1 dans l'ordre d'apparition de leur parenthèse ouvrante. Les groupes de capture peuvent également être considérés comme des subroutines ailleurs dans le modèle, peut-être de manière récursive.
(?<name> ... )	Groupe de capture nommé. Peut être appelé plus tard par son nom aussi bien que par son numéro. Evitez d'utiliser le nom "DEFINE" (voir "Modèles conditionnels").
(?: ... )	Groupe sans capture. N'enregistre pas les caractères trouvés dans un tableau qui ne peuvent donc pas être re-utilisés dans une référencence arrière.
(?\| ... )	Groupe sans capture avec initialisation. Re-initialise les numéros de groupes cappturés dans chaque alternative de haut niveau qu'il contient : "(?\|(Mon)\|(Tue)s\|(Wed)nes\|(Thu)rs\|(Fri)\|(Sat)ur\|(Sun))day" cherche un jour de la semaine et capture son abréviation dans un groupe numéro 1.
(?> ... )	Groupe atomique non capturant: locks and never backtracks into (gives back from) what has been matched (see also Quantifiers and greediness below). Atomic groups, like possessive quantifiers, are always greedy.
(?# ... )	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écifie combien de ce qui précède, caractère, classe, référence ou groupe devraient correspondre. Les qualificatifs optionnel de gourmandise indiquent avec quelle agressivité la répétition se comportera. Par exemple "\d{3,5}" cherchera 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 * + ? {...} chercheront 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 en donnant l'option (?U) à l'entête du modèle, ou localement en plaçant un point d'interrogation après un quantificateur.
Les répétitions non-gourmandes (paresseuses) chercheront 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 est assez bonne pour satisfaire le paresseux "(a*)" et la capture de "a" correspond au sous-motif paresseux "([ab]+)".
Les quantificateurs possessifs sont atomiques et gourmands. En fait, ils ont une notation abrégée pour les groupes atomiques simples. "\d++" est une notation abrégée pour "(?>\d+)" et son comportement est "match a complete sequence of one or more digits, but never give back any". As a consequence "\d++(\d)" can never match since the last digit (in bold) is already matched and locked by "\d++". This is in contrast with simple greediness, where "\d+(\d)" will first match a complete sequence of digits with "\d+", but then backtrack the last one to allow "(\d)" to capture it.
There are two reasons for using an atomic group or a possessive quantifier: either for matching a sequence of characters that may also appear individually (e.g. "\r\n" in the definition of \R), or for forcing a quick failure in certain situations involving unbounded repetitions, where the engine would normally spend a very long time trying a huge number of grouping combinations before failing.

?	0 ou 1, gourmand.
?+	0 ou 1, possessif.
??	0 ou 1, paresseux.
*	0 ou plus, gourmand.
*+	0 ou plus, possessif.
*?	0 ou plus, paresseux.
+	1 ou plus, gourmand.
++	1 ou plus, possessif.
+?	1 ou plus, paresseux.
{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, lazy.
{x,}	x ou plus, gourmand.
{x,}+	x ou plus, possessif.
{x,}?	x ou plus, paresseux.

Alternative

X\|Y	Cherche chaque partie du modèle X ou Y: "ac\|dc\|ground" cherche "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ée.

\n	Fait référence un groupe précédemment capturé par son numéro absolu. ATTENTION: si aucun groupe numéro n n'existe, il évalue comme un caractère de valeur n si n est une valeur octale valide, ou d'autres erreurs apparaissent. En raison de cette ambiguïté, cette formulation ne est pas recommandée. Favorisez les formes suivantes pour une sécurité sémantique.
\gn	Fait référence à un groupe précédemment capturé par son numéro absolu.
\g{n}	Fait référence à un groupe précédemment capturé par son numéro absolu. Similaire à ce qui précède mais délimite clairement où n se termine: utile lorsque les caractères qui suivent sont des chiffres.
\g-n	Fait référence à un groupe précédemment capturé par son numéro relatif.
\k<name>	Fait référence à un groupe précédemment capturé par son nom.

Référence à un sous-programme

Les groupes capturant sont des parties de modèle qui peuvent être invoquées (é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écuter au point courant de correspondance. Voir la documentation de référence pour des détails et des exemples.

(?R) ou (?0)	Récursivité dans 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 relatif.
(?&name)	Appelle un sous-modèle par son nom.

Ancres et assertions

Les ancres et les assertions sont des tests qui ne changent pas la position de la correspondance et donc ni ne consomme ni ne capture quelque chose.

Les ancres teste la position du point courant de correspondance.

^	En dehors d'une classe de caractère, le caret correspond au début du texte d'origine, et également juste après une séquence 'newline' non-finale si l'option (?m) est active. Par défaut, la séquence 'newline' est @CRLF. Dans une classe de caractères, le leading ^ complèmente la classe (exclut les caractères qui y sont énumérés).
$	En dehors d'une classe de caractères, le dollar teste la correspondance à la fin du texte sujet, et aussi juste avant une séquence 'newline' si l'option (?m) est active. Dans une classe de caractères, $ signifie lui-même, le signe dollar.
\A	Teste la correspondance seulement au début absolu de la chaîne sujet, quel que soit le l'option multiligne (?m). Ne validera pas jamais une correspondance si l'offset n'est pas 1.
\G	Valide la correspondance quand la position courante est la première position trouvée dans le sujet.
\z	Cherche une correspondance seulement à la fin de la chaîne sujet, quel que soit l'option multiligne (?m).
\Z	Cherche une correspondance seulement à la fin de la chaîne sujet, ou avant une séquence 'newline', quel que soit l'option multiligne (?m).

Les Assertions testent les caractères qui précédent (look-behind), à la limite de mot ou qui suivent (look-ahead) le point de correspondance en cours.

\b	Cherche une correspondance à la limite d'un "word", par exemple entre les caractères \w ou \W. Voir \w pour la signification de "word". Dans une classe de caractères, \b signifie "backspace" (Chr(8)).
\B	Cherche une correspondance qui n'est pas à la limite d'un "word".
(?=X)	Look-ahead positif: succès quand le sous-modèle X trouve une correspondance au début de la position courante.
(?!X)	Look-ahead négatif: succès quand le sous-modèle X ne trouve pas une correspondance au début de la position courante.
(?<=X)	Look-behind positif: succès quand le sous-modèle X trouve une correspondance avec les caractères qui précèdent la position courante. Le modèle X doit chercher une chaîne de longueur fixée, c'est-à-dire ne pas utiliser des quantificateurs indéfinis * + ou ?.
(?<!X)	Look-behind négatif: succès quand le sous-modèle X ne trouve pas de correspondance avec les caractères qui précédent la position courante. Le modèle X doit chercher une chaîne de longueur fixée, c'est-à-dire ne pas utiliser des quantificateurs indéfinis * + ou ?.

Ré-initialisation de la recherche

Il y a des situations où il est nécessaire d' "oublier" que quelque chose a été trouvé jusqu'à présent, afin de chercher une correspondance avec des données plus pertinentes plus loin dans la chaîne sujet.

Ré-initialise le démarrage de la recherche au point courant de la chaîne sujet. Remarquez que les groupes déjà capturés sont abandonnés dans le tableau retourné; il est donc toujours possible de faire des références arrières vers eux plus tard. L'action de \K est similaire mais non identique à un look-behind, en ce que \K peut travailler sur des alternances de différentes longueurs.

Modèles conditionnels

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

(?(condition)yes-pattern)	Permet une exécution conditionnelle de modèle.
(?(condition)yes-pattern\|no-pattern)	Choisit entre des modèles distincts suivant le résultat de (condition).

où (condition) peut être de la forme suivante:

(n)	Teste si le groupe de capture avec le numéro absolu n réalise la correspondance.
(+n)	Teste si le groupe de capture avec le numéro relatif +n réalise la correspondance.
(-n)	Teste si le groupe de capture avec le numéro relatif -n réalise la correspondance.
(<name>)	Teste si le groupe de capture avec le nom name réalise la correspondance.
(R)	Teste si un type de récurrence s'est produite.
(Rn)	Teste si la plus récente récurrence était pour capturer un groupe avec le numéro absolu n.
(R&name)	Teste si la plus récente récurrence était pour capturer un groupe avec le nom name.
(DEFINE)	Utilisée sans modèle, permet la définition d'un sous-programme utilisable à partir d'ailleurs. "(?x) (?(DEFINE) (?<byte> 2[0-4]\d \| 25[0-5] \| 1\d\d \| [1-9]?\d) )" définit un sous-programme nommé "byte" qui cherche une correspondance avec un composant 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 sony simplement mentionnés ici; voir la documentation référence pour plus de détails sur pourquoi, quand et comment les utiliser, voire pas du tout.

Paramètres peu fréquents et options

(?J)	Permet de dupliquer les noms de groupes ou de sous-programme (n'est pas détaillé plus loin ici).
(?X)	Provoque des séquences hors-cadre pour déclencher une erreur, au lieu d'être bénigne.
*(J)**	Installe la compatibilité avec Javascript (n'est pas détaillé ici).
*(LIMIT_MATCH=**n)	Limite le nombre de correspondances trouvés à n.
*(LIMIT_RECURSION=**n)	Limite la récurrence à n levels.
*(NO_START_OPT)**	Désactive plusieurs optimisations (n'est pas détaillé ici).

Contrôle du Backtracking

*(ACCEPT)**	Force un succès immédiat de la recherche dans le sous-programme en cours ou dans le modèle de haut niveau.
*(FAIL) ou (F)*	Force un échec immédiat de la recherche.
*(MARK:**name) or *(:**name)	(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 applique la recherche en plein Unicode plane 0. 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 UCP installé.

    2. D'autres formes de plusieurs escapes existent pour la compatibilité avec Perl, Ruby, Python, JavaScript, .NET et autres moteurs. Ne pas utiliser des 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 par défaut de 'newline' est une séquence insécable @CRLF ou un caractère séparé @CR ou @LF. De façon similaire \R cherche la correspondance du même ensemble. Connaissez 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 'newline', vous pourriez avoir à modifier la convention de saut de ligne et/ou la recherche d'une correspondance de \R (voir "Paramètres").

Voir aussi le tutoriel Expression Régulè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