Les expressions régulières (appelées aussi “expressions rationnelles”) sont issues des théories mathématiques dans le domaine des automates. Une expression régulière n'est en fait qu'une suite de caractères qui décrit un ensemble de chaînes de caractères possibles selon une syntaxe précise.
Comme en mathématique, une expression régulière comprend des opérateurs, des valeurs et des variables. Les expressions régulières permettent donc de réaliser des recherches de caractères ou de séquences de caractères qui répondent à des combinaisons d'opérateurs et de valeurs.
Les expressions régulières sont largement utilisées en programmation pour l'édition et le contrôle de texte. L'interpréteur Abstrasy dispose donc aussi d'opérateurs permettant l'utilisation des expressions régulières.
La syntaxe des expressions régulières est très riche et comprend pas moins de six groupes de marqueurs:
Il s'agit simplement de séquences ou de suites de caractères que l'on tente de rechercher dans une chaîne de caractères.
On notera toutefois, qu'il peut s'agir de n'importe quel caractère non repris dans un des autres groupes de marqueurs.
Il s'agit de symbole particuliers qui remplacent d'autres caractères. Les métacaractères peuvent être combinés entre eux pour décrire des formules de recherche très complexes.
| Caratère | Description |
| Remplace n'importe quel caractère | |
| Remplace une séquence de zéro, un ou plusieurs caractères | |
| ? | Remplace un caractère (ce caractère doit être obligatoirement présent) |
| ( ) | Groupe capturant |
| [ ] | Intervalle de caractères |
| { } | Quantificateur |
| \\ | Déspécialise le caractère qu'il précède. De cette manière, il est par exemple possible d'introduire un méta caractère pour l'utiliser comme un caractère littéral. |
| ^ | Négation ou début de ligne |
| $ | Fin de ligne |
| | | Ou logique entre deux sous expressions |
| + | Numérateur |
Contrairement à la norme des expressions régulières, le caractère “\” (barre oblique inverse) doit être doublé en Abstrasy.
En effet, l'interpréteur utilise aussi “\” pour insérer des caratères spéciaux dans les chaînes de caractères. Aussi, pour insérer un caractère “\” dans une chaîne de caractères qui servira d'expression régulière, il faut écrire “\\”.
De même pour introduire le caractère “\” en le déspacialisant complètement pour l'utiliser comme un caractère littéral, il faut écrire “\\\\” (4 “\” pour que l'interpréteur place dans la chaîne de caractères “\\” ( 2 “\” successifs).
Une classe de caractères est un ensemble de caractères. Abstrasy reconnait les classes prédéfinies suivantes:
| Classe | Description |
| Un chiffre (correspond à [0-9]) | |
| Un caractère qui n'est pas un chiffre (soit [^0-9]) | |
| \\s | Un caractère d'espacement (correspond à [\\t\\n\\x0b\\f\\r]) |
| \\S | Un caractère qui n'est pas un caractère d'espacement (équivalent de [^\\s]) |
| \\w | Un caractère de mot (soit [a-zA-Z_0-9]) |
| \\W | Un caractère qui n'est pas un caractère de mot (ou, si vous voulez [^\\w]) |
Il existe aussi des groupes de classes nommées directement utilisable:
| Classe | Description |
| Une lettre ASCII en minuscule : [a-z] | |
| Une lettre ASCII en majuscule : [A-Z] | |
| \\p{ASCII} | Tout caractère ASCII : [\\x00-\\x7f] |
| \\p{Alpha} | Un lettre ASCII : [a-zA-Z] |
| \\p{Digit} | Un chiffre ASCII : [0-9] |
| \\p{Xdigit} | Un chiffre hexadécimal : [0-9a-fA-F] |
| \\p{Alnum} | Un lettre ou un chiffre ASCII : [\\p{Alpha}\\p{Digit}] |
| \\p{Punct} | Un caractère de ponctuation ASCII : [!\"#\$%&\'\(\)\*\+,-./:;<=>\?@\[\\\]\^_\{\|\}~] |
| \\p{Graph} | Un caractère ASCII visible : [\\p{Alnum}\\p{Punct}] |
| \\p{Print} | Identique à \\p{Graph} |
| \\p{Blank} | Un espace ou une tabulation ASCII : [ \\t] |
| \\p{Space} | Un caractère d'espace blanc ASCII : [ \\t\\n\\f\\r\\x0b] |
| \\p{Cntrl} | Un caractère de contrôle ASCII : [\\x00-\\x1f\\7f] |
Il est bien entendu possible de construire soi-même une nouvelle classe de caractères personnalisée en la décrivant directement à l'aide des exemples suivants:
| Exemple | Description |
| Défini un ensemble simple qui comprend les caractères indiqués (dans notre exemple, il s'agit des caractères "a", "b" et "c") | |
| Correspond à la négation de l'ensemble précédent. Donc, tous les caractères pourront être sélectionnés sauf "a", "b" et "c". | |
| [a-z] | Défini un interval de caractères. Dans cet exemple, il s'agit de tous les caractères compris de "a" à "z". On dit qu'il s'agit d'un ensemble complexe. |
| [a-z0-9] | Défini une union d'ensembles. Dans le cas de notre exemple, il s'agit des ensembles de caractères allant de "a" à "z" et de "0" à "9". Notez que notre exemple pouvait aussi s'exprimer comme ceci : [a-z[0-9]]. |
| [abc&&[a-z]] | Nous définissons ici une intersection d'ensembles. Dans notre exemple, nous indiquons que seul les caractères faisant à la fois partie de [abc] et de [a-z] peuvent être sélectionnés. Autrement-dit, seul "a", "b" et "c"... |
| [a-z&&[^abc]] | On introduit ici une soustraction d'ensembles. En fait, on indique dans cet exemple que l'on peut sélectionner tous les caractères minuscules de l'alphabet sauf "a", "b" et "c"... |
Les quantificateurs permettent de définir le nombre d'occurences d'une sous expression.
| Quantificateur | Description |
| Indique que la condition de la sous expression <X> peut se présenter une seule fois ou pas du tout.. | |
| Cela indique que la condition de la sous expression <X> peut se présenter une fois, plusieurs fois ou pas du tout. | |
| X+ | Indique que la condition de la sous expression <X> doit se vérifier au moins une fois et plus. |
| X{n} | Indique que la condition de <X> doit se présenter exactement <n> fois. |
| X{n,} | Indique que la condition de <X> doit se présenter au moins <n> fois et plus. |
| X{n,m} | Indique que la condition de <X> doit être vérifiée entre <n> et <m> fois. |
Il est possible de combiner les quantificateurs de façon à modifier leur manière de gérer les conditions récurrentes:
Pour créer des groupes de capture, il suffit d'utiliser les parenthèses. On crée ansi des sous expressions qui peuvent être vérifiées dans l'ordre de leur imbrication respective.
Par exemple, (match—regex “aax” ”(a{2}(x|y))”) retourne TRUE, ainsi que pour la chaîne d'entrée “aay”, mais FALSE pour la chaîne d'entrée “aaz”… (L'expression régulière de cet exemple définisant 2 fois “a” suivit de “x” ou “y”).
Il est également possible d'ajouter au sein de l'expression une référence à un groupe de capture qui précéde dans le traitement.
Par exemple, (split—regex “x1515y1234z” “\\d\\d”) donne la liste [“x” “y” “z”]. Mais, (split—regex “x1515y1234z” “(\\d\\d)\\1”) donne la liste [“x” “y1234z”].
Cela s'explique par le fait que l'expression “\\1” fait référence au groupe de capture (\\d\\d).
Autrement dit, pour que la formule soit vérifiée, le contenu de la sélection du premier groupe qui précède doit se retrouver une deuxième fois directement après le premier.
Ainsi, “1515” vérifie la condition “15” identique à “15”. Alors que “1234” ne vérifie pas la condition puisque “12” n'est pas identique à “34”.
Il est possible aussi de définir l'emplacement à partir duquel l'expression régulière doit être vérifiée dans la chaîne d'entrée.
On peut donc définir cette position à l'aide d'un spécificateur de frontière.
| Spécificateur | Description |
| Commencer à partir du début de ligne | |
| Commencer à partir de la fin de ligne | |
| \\b | Les recherches commencent à partir de l'extrémité d'un mot |
| \\B | Les recherches commencent à partir de l'extrémité d'un "non mot" |
| \\A | Commencer à partir du début de la chaîne d'entrée soumise |
| \\G | Commencer à la fin de l'occurence précédente |
| \\Z | Commencer à la fin de la chaîne soumise, à l'exclusion du caractère final |
| \\z | Commencer à la fin de la chaîne soumise (le dernier caractère étant inclu dans la recherche) |
Ainsi, pour illustrer cela, (match—regex? “Abstrasy, c'est SUPER!” “^Abstrasy.*”) retourne TRUE puisque la chaîne d'entrée commence bien par “Abstrasy” suivi de n'importe quel caractère en n'importe quel nombre.
De même, (match—regex? “SUPER Abstrasy” “.*Abstrasy$”) retourne aussi TRUE puisque la chaîne d'entrée se termine bien par “Abstrasy”.
Par contre (match—regex? “SUPER Abstrasy!” “.*Abstrasy$”) retourne FALSE puisque la chaîne d'entrée se termine par un point d'exclamation “!” avant la séquence “Abstrasy”.
 |
 |
 |
 |
|
|
|
||||||||
