Syntaxe des expressions régulières

Les expressions régulières ont une syntaxe particulière qu'il est important de connaître afin de pouvoir utiliser toute les ressources de cet outil.

On distingue deux types de caractères: les caractères ordinaires comme les lettres et les chiffres, et les caractères spéciaux $\$,$ ^, . , $*, +, ?, [,] \backslash$ qui servent à construire des expressions.
Le caractère ``a'' est un caractère ordinaire mais il est également une expression régulière élémentaire réduite au singleton ``a'' qui permettra de retrouver le caractère ``a'' et rien d'autre.
Deux expressions régulières peuvent être concaténées. Ainsi les deux expressions ``a'' et ``b'' constituées des deux singletons ``a'' et ``b'' peuvent être concaténées pour former l'expression ``ab'' qui pourra être appariée avec la chaîne ``ab''.

Pour former des expressions moins triviales on utilise les caractères spéciaux qui assurent chacun une fonction particulière et qui peuvent être combinés entre eux.

. (point)

remplace un caractère. Il ne peut pas remplacer le caractère <newline>. Si on forme l'expression b.s vous pourrez retrouver par exemples les chaînes ``bas'', ``bis''.

*

il n'a pas de signification par lui-même, c'est un suffixe qui doit être associé à une expression régulière. Il signifie dans ce cas que l'expression régulière qui précède peut apparaître un nombre de fois quelconque dans la chaîne. Ainsi si vous entrée l'expression ba*s vous pourrez trouver toutes les chaînes commençant par le caractère ``b'' suivit d'un nombre quelconque de ``a'' et se terminant par ``s'' : bs, bas, baas, baaas etc...

+

il s'agit également d'un suffixe. Il opère comme * mais l'expression régulière qui le précède doit exister au moins une fois. Ainsi avec l'expression ba+s vous ne pourrez pas trouver la chaîne ``bs'' comme précédemment, car le caractère ``a'' doit ici apparaître au moins une fois.

?

ce suffixe permet de trouver les chaînes pour lesquelles l'expression régulière qui précède ? apparaît 0 ou 1 fois. Ainsi l'expression ba?s permet de retrouver que les chaînes ``bas'' et ``bs''.

[...]

définit un ensemble de caractères qui peuvent se substituer à un emplacement donné d'une chaîne. Ainsi l'expression b[ai]s permet de retrouver les chaînes ``bas'' et ``bis'' et aucune autre. Maintenant si on forme l'expression b[ai]*s on pourra trouver par exemple les chaînes ``bs'', ``bas'', baias'', ``bais'' etc...Il est possible de définir un intervalle de caractères substituables, ainsi [a-z] permettra de substituer une lettre minuscule, [A-Z] une lettre majuscule, [0-9] un chiffre de 0 à 9. On peut ainsi écrire l'expression ba[a-z]s qui permettrait de retrouver toutes les chaînes commençant par ``ba'' suivies d'une lettre minuscule et se terminant par ``s'' comme ``bais'', ``bals'', ``bars'' etc...Si on écrit l'expression ba[b-z]*s on trouvera l'ensemble des chaînes commençant par ``ba'', comportant un nombre quelconque de lettres minuscules et se terminant par ``s'' mais ne pouvant pas présenter un autre ``a'' car l'intervalle l'exclut. Vous pourriez ainsi obtenir ``bas'', ``ballons'', ``bars'', ``barres'' etc...Il est possible d'inclure les caractères spéciaux à l'intérieur des crochets car ils n'ont pas alors de significations particulières. Ainsi l'expression ba[b-z]s[?!]+ ne donnera de l'ensemble précédent que les chaînes qui présenteront un ``?'' ou un ``!'' à la fin. Pour éviter des confusions le caractère ``]'' doit être placé en début d'intervalle, le caractère ``^'' en fin d'intervalle, enfin pour inclure le caractère ``-'' il faut écrire ``--'' .

[^...]

cette construction permet d'exclure un ensemble de caractères.^1.4 Si on forme l'expression ba[^A-Z0-9]s on pourra retrouver toutes les chaînes comportant ``ba'' suivie d'un caractère qui ne sera pas une majuscule ou un chiffre de 0 à 9. Ainsi vous pouvez trouver ``bais'' mais aussi ``ba?s'' ou ``ba!s'' car les caractères non alphabétiques ne sont pas exclus.

^

est un caractère spécial qui permet de limiter la recherche aux chaînes qui se trouvent en début de ligne. Ainsi l'expression ^b[ai]s permettra de retrouver les chaînes ``bas'' et ``bis'' que si elles se trouvent en début de ligne.

$\$$

permet de limiter la recherche aux chaînes qui se trouvent en fin de ligne.

$\backslash$

suivit d'un caractère, permet d'inclure des caractères spéciaux dans les expressions régulières. Ainsi l'expression b[ai] $\backslash\$ permettra de retrouver des chaînes bas$\$$ et bis$\$$.

$\backslash$|

précise une alternative. Ainsi l'expression bas $\backslash$|bis permettra de retrouver les chaînes ``bas'' ou ``bis'' et seulement celles-ci.

$\backslash(\ldots\backslash)$

permet de grouper des constructions et de limiter également certaines actions. Ainsi, si on lance une recherche avec l'expression régulière
ba $\backslash$(na $\backslash$)*n[ea] on pourra retrouver les chaînes ``banane'', ``banana'' ``bananane'' etc...

$\backslash$ <n>

permet d'appliquer l'expression régulière n fois dans les chaînes, n étant compris entre 1 et 9.

$\backslash$`

espace en début de Buffer.

$\backslash$'

espace en fin de Buffer.

$\backslash$b

espace avant ou après la chaîne. Par exemple l'expression $\backslash$bb[ai]s $\backslash$b permettra de retrouver les chaînes ``bas'' et ``bis'' uniquement si elles sont séparées des autres mots par un espace, avant et après .

$\backslash$B

inverse du précédent.

$\backslash$<

espace en début de chaîne.

$\backslash$>

espace en fin de chaîne.

$\backslash$w

n'importe quel caractère pouvant entrer dans la composition d'un mot, par exemple a,b,c ...mais pas ? ou !

$\backslash$W

inverse du précédent.

Normalement XEmacs ignore la casse des caractères, il ne fera donc pas de différence entre ``Bas'', ``bas'', BAS''. Si on désire rendre la recherche sensible à la casse il faut le lui préciser en allant dans le menu Options, entrée Options d'édition et valider le bouton Respecter la casse dans les recherches.

Notes

...ères.^1.4

On notera que le caractère ``^'' apparaît en première position après le crochet ouvrant. C'est la raison pour laquelle il ne faut pas le placer en début d'intervalle si on veut pouvoir le retrouver en tant que caractère dans une chaîne.