Fiche Javascript : Les expressions régulières

Objet de la fiche :

État de la fiche

Plan de la fiche :

• | Avant propos |
• | Les méthodes |
• | Les règles |
• | La syntaxe |
• | Construire des expressions régulières |
• | Testeur expressions régulières |
• | Application au projet de site Web |

Avant propos

Les expressions régulières sont des modèles créés à l'aide de caractères ASCII permettant de manipuler des chaînes de caractères, afin de trouver et/ou modifier des portions de la chaîne correspondant au modèle.
Cette fiche à pour objet de vous permettre d'en connaître les principes de base, ainsi que quelques applications.

Exemples

• Séparer un nom en prénom et nom,
• Extraire les première et troisième colonnes d'un fichier utilisant une tabulation comme séparateur,
• Trouver les occurences d'une devise dans un texte et les convertir en autre divise,
• etc.. etc ..

Les méthodes

Il y a deux manières d'utiliser ce type d'expressions : soit par le biais de l'objet RegExp et ses méthodes ( test() et exec() ), soit par le biais de certaines méthodes de l'objet String ( match(), search(), split(), replace() ).

Méthodes utilisant les expressions régulières avec l'objet string

Méthodes utilisant les expressions régulières avec l'objet RegExp

Les règles

Modes d'initialisation des règles

De façon littérale : var regle = /modèle/flag;
ou
par le constructeur : regle = new RegExp("modèle", "flag")
suivant le type de méthode que l'on veut utiliser.

Paramètres

• Le paramètre modèle décrit le modèle à appliquer afin d'exécuter une action.
• Le paramètre flag décrit le type d'expression régulière :
  • Si flag vaut "g", l'expression sera analysée globalement sur l'ensemble de la chaîne (même sur plusieurs lignes).
  • Si flag vaut "i", l'expression sera analysée indifféremment sur les majuscules ou les minuscules.
  • Si flag vaut "m", (multiline) , Les caractères de début et de fin (^ et $) sont utilisés sur plusieurs lignes et correspondent au début et à la fin de chaque ligne délimitée par \n ou \r, et non plus au début ou à la fin de l'ensemble de la chaîne.
  • Si flag vaut "y", (adhésion) , ne correspond qu'à partir de l'indice fourni par la propriété lastIndex (toutes les correspondances suivantes ne sont pas utilisées)..
  • Les conditions précédentes peuvent se cumuler comme par exemple "gi".

Remarques

• pas de quotes pour les paramètres (Modèle et flags) de la notation littérale.
• Si le contenu de modèle contient des / il faudra les échapper par \/

Applications des règles

La syntaxe

Classes de caractères

Les classes de caractères sont des caractères définis entre crochets []

Les conditions

Une quelconque des lettres qui se trouve entre les crochets peut convenir.
Exemple : /br[ae]ves/ pour : braves ou breves.

Les intervalles

Si n'importe quelle lettre de l'alphabet peut convenir, il est donc inutile de les écrire toutes, il suffit de définir l'intervalle (séparation des deux valeurs par un tiret milieu) et écrire [a-z]. De même pour les caractères numériques on écrira [0-9].

Il est possible de définir plusieurs intervalles : exemple [a-z0-9] trouvera une lettre minuscule (de a à z) ou un chiffre (de 0 à 9).

Les exclusions

Pour exclure des caractères, il suffit d'insérer un accent circonflexe en début de la classe (juste après le premier crochet). Par exemple la règle [^éèê] ignorera les e accentués. L'exclusion d'un intervalle est possible; ansi [^7-9] exclura les chiffres de 7 à 9.

Jocker

Le point symbolise un caractère quelconque, à l'exception des sauts de ligne (les retours à la ligne). Ainsi la règle /gr.s/ trouvera gras,ou gres,ou gris etc...

Les quantificateurs

Les quantificateurs permettent de signaler combien de fois un caractère peut être recherché.

Les accolades

À la place des trois symboles vus précédemment, on peut utiliser des accolades pour définir explicitement combien de fois un caractère peut être répété. Trois syntaxes sont disponibles

• {n} : le caractère est répété n fois
• {n,m} : le caractère est présent de n à m fois. Par exemple, si on a {0, 5}, le caractère peut être présent de 0 à 5 fois
• {n,} : le caractère est répété de n fois à l'infini.

Les accolades peuvent aussi permettre de contrôler précisément le nombre d'occurences dans une chaine de caractères

Exemples

• E{4} : signifie 4 fois la lettre E majuscule
• u{2,4} : signifie de 2 à 4 fois la lettre u minuscule
• z{,5} : signifie de 0 à 5 fois la lettre z minuscule
• X{8,} : signifie 8 fois minimum la lettre X majuscule.

Attention : Au sein d'une classe de caractères, il n'y a pas besoin d'échapper les métacaractères, à l'exception des crochets (qui délimitent le début et la fin d'une classe), du tiret (qui est utilisé pour définir un intervalle) et de l'anti-slash (qui sert à échapper).

On peut utiliser les opérateurs d'union (non marqué), d'intersection (&&) et de négation (^) :

• [abc] ou [a-z] : La classe des trois caractères a, b et c, ou la classe de tous les caractères de a à z.
• [^abc] : La classe de tous les caractères sauf a, b et c.
• [a-zA-Z] ou [a-z[A-Z]] : L'union des classes [a-z] et [A-Z].
• [123abc&&[a-z]] : L'intersection de la classe [123abc] et de la classe [a-z]

Parenthèses capturantes

Les parenthèses ( ) permettent de représenter une séquence de caractères et de capturer le résultat.

Exemple : "a(bc)+": chaîne qui contient "a" suivie de au moins une occurence de la chaîne "bc"

Les méta caractères

Ce sont des caractères qui sont interprétés par l'analyseur. Pour qu'un méta-caractère ne soit par interprété par l'analyseur, il faut le faire précéder du caractère '\'. Les caractères '-' et ']' ont un statut spécial : dans un intervalle ce sont des méta-caractères, et en dehors d'un intervalle ils se comportent comme des caractères normaux.

Attention : à l'échappement si la chaine de caractère contient un méta caractère vu comme du texte

Les génériques

Les types génériques s'écrivent tous de la manière suivante : \x, où x représente une lettre. Voici la liste de tous les types génériques

Spécificateurs de frontière.

Les spécificateurs de frontière sont des indicateurs permettant de dire où commence ou où finit le motif.

Les assertions

Les assertions s'écrivent comme les types génériques mais ne fonctionnent pas tout à fait de la même façon. Un type générique recherche un caractère, tandis qu'une assertion recherche entre deux caractères.

Exemples généraux

Classes

• [abc] : 1 lettre au choix parmis a, b ou c
• [a-z], [b-e], [a-zA-Z]: lettre comprise entre a et z, b et e, a à z minuscules et A à Z majuscules
• [0-9], [5-8] : chiffre compris entre 0 à 9 , 5 à 8
• [abc-] [a-z-] : lettres a, b, c et le signe '-', toute lettre de a à z et le signe '-'
• [^abc] [^a-d] : toute lettre sauf a, b, c , toutes les lettres sauf les lettres de a à d

Accolades

• a{1,3} => uniquement a, aa, aaa
• abc{2,4}d => uniquement abccd, abcccd, abccccd
• a.{2,2}z => abbz, aXXz, akkz, ...

Combinaisons et utilisation de '\'

• a\.*z => az, a.z, a..z, a.......z, mais ne trouvera pas abc
• a.\*z => ab*z, a2*z, la 2eme lettre peut être n'importe quoi
• a\++z => a+z, a++z, a+++z, a+++++++z mais ne trouvera pas az
• a\+\+z => a++z et rien d'autre
• a+\+z => a+z, aa+z, aaa+z, aaaaaaaa+z
• a.?e => ae, abe, a-e, axe, ...
• a\.?e => uniquement ae, a.e
• a.\?e => a.?e, ab?e, aX?e, ...
• a\.\?e => uniquement a.?e
• ---------------------------------
• 1\.\d\d\d4 => 1.1234, 1.9994, 1.0004, ...
• a\Dz => aaZ, a%z, ... mais ne trouvera pas à a2z, a0z
• 

Avec le point '.'

• 123.5 => 123.5, 12345, 123s5, 123-5, ....
• 12..5 => 12345, 123s5, 123-5, 12564, 12.45, ...
• 3.14 => 3.14, 3114, 3f14, ...
• 3\.14 => 3.14, ne trouve pas 3114, 3f14 ou autres

Avec '?'

Le caractère qui précède ? peut apparaître 0 ou 1 fois consécutivement.

• 12?34 => 1234, 134
• mes? amis? => mes amis, me ami, mes ami, me ami

Avec '*'

Le caractère qui précède * peut apparaître 0, 1 ou plusieurs fois consécutivement.

• 12*34 => 134, 1234, 12234, 12222222234, ...

Avec '+'

Le caractère qui précède + peut apparaître 1 ou plusieurs fois consécutivement.

• 12+34 => 1234, 12234, 12222222234, ... mais ne trouvera pas 134
• /^[a-z0-9-]+$/ => en début de ligne, un ou plusieurs (signe +) caractères alphanumériques ou "_" .

Avec $

• toto$ => toute ligne finissant pas toto

Construire des expressions régulières

La règle et l'utilisation de match().

Base de départ

Code utilisé

<script>
     regle=????? // voir le tableau;
     info="";
    result = monTexte.match(regle);
    for (i=0; i < result.length; i++){
        info += result[i] + "<br />"
    }
    document.write(info);
</script>

Exemples

La fonction replace()

D'autres constructions

Testeur expressions régulières

Application au projet de site web