Expressions rationnelles

Crer une expression rationnelle

Il est possible de construire une expression rationnelle de deux faons :

• Utiliser un littral d'expression rgulire, qui correspond un motif contenu entre deux barres obliques, par exemple :

  js

  var re = /ab+c/;
  

  Lorsque les littraux d'expression rgulire sont utiliss, l'expression est compile lors du chargement du script. Il est prfrable d'utiliser cette mthode lorsque l'expression rgulire reste constante, afin d'avoir de meilleurs performances.

• Appeler le constructeur de l'objet RegExp, par exemple :

  js

  var re = new RegExp("ab+c");
  

  Avec cette mthode, l'expression rationnelle est compile lors de l'excution. On utilisera cette mthode lorsque le motif utilis est variable ou provient d'une autre source (par exemple une interaction utilisateur).

crire une expression rationnelle

Le motif d'une expression rationnelle est compos de caractres simples (comme /abc/), ou de caractres simples et spciaux, comme /ab*c/ ou /Chapitre (\d+)\.\d*/. Le dernier exemple utilise des parenthses qui permettent d'avoir une mmoire . La correspondance avec le motif contenu entre parenthses pourra tre utilise par la suite. Ceci est dcrit avec ce paragraphe.

Utiliser des motifs simples

Les motifs simples sont construits partir de caractres pour lesquels on souhaite avoir une correspondance directe. Le motif /des/ correspond lorsqu'on observe exactement les caractres 'des' ensemble et dans cet ordre prcis. On pourrait utiliser ce motif et dtecter une correspondance dans les chanes suivantes : "J'ai vu des licornes ?" et "Sa description de licorne tait superbe" car la chane de caractres 'des' y est prsente (dans le mot description pour le second exemple). Il n'y aura pas de correspondance avec la chane de caractres "Toc toc" car 'des' n'est pas prsente.

Utiliser des caractres spciaux

Lorsque le motif trouver est plus complexe qu'une simple galit (trouver tous les B, les blancs...), le motif devra contenir des caractres spciaux. Ainsi, le motif /ab*c/ correspond toutes les combinaisons de caractres qui possdent un seul 'a' suivi de zro ou plusieurs 'b' (l'astrisque utilise ici signifie que l'lment qui la prcde doit tre prsent zro ou plusieurs fois) qui sont immdiatement suivis d'un 'c'. Par exemple, la chane de caractre "cbbabbbbcdebc" correspond au motif avec la chane de caractres 'abbbbc'.

Les pages suivantes dcrivent en dtail les caractres spciaux qui peuvent tre utiliss afin de composer une expression rationnelle.

Assertions

Une assertion caractrisant la faon dont la correspondance peut se produire (en recherchant un motif avant, aprs ou avec une expression conditionnelle).

Limites

Permet d'indiquer le dbut ou la fin d'une ligne ou d'un mot.

Classes de caractre

Les classes permettent de distinguer diffrents caractres selon diffrents groupes (par exemple les lettres et les chiffres).

Groupes et intervalles

Permet d'indiquer un groupe ou un intervalle de caractres.

Quantificateurs

Permet d'indiquer un nombre de caractres ou d'expressions qui doivent correspondre.

Proprits Unicode

Permet de distinguer les caractres en fonction de leurs caractristiques Unicode (majuscule/minuscule, symbole mathmatique, ponctuation).

chapper des caractres

SI on souhaite rechercher certains caractres dans une chane de caractres et que ceux-ci ont une signification spciale lorsqu'ils font partie d'une expression rationnelle (ex. "*"), il faudra chapper ces caractres spciaux en plaant une barre oblique inverse (backslash "\") devant. Ainsi, si on souhaite trouver un "a" suivi d'un astrisque ("*") suivi d'un "b", on pourra composer l'expression rationnelle : /a\*b/ o la barre oblique inverse chappe l'astrisque afin de lui enlever sa signification particulire.

De mme si on crit un littral d'expression rationnelle et qu'on souhaite rechercher une barre oblique ("/") dans la chane cible, on pourra chapper ce caractre (sinon, il aura sa signification particulire aux expressions rationnelles et indiquera la fin du motif). Si on cherche la prsence de "/exemple/" dans une chane de caractres, on pourra utiliser le littral /\/exemple\//.

Il en va de mme avec la barre oblique inverse (dont la signification spcifique est justement l'chappement) : si on veut rechercher la chane "C:\", on pourra utiliser le motif /C:\\/ (la premire barre oblique inverse sert chapper la seconde).

Lorsqu'on utilise le constructeur RegExp avec une chane de caractres en paramtre (plutt qu'un littral), il faudra chapper la barre oblique inverse qui a un sens particulier dans les chanes de caractres. Ainsi, le littral /a\*b/ et new RegExp("a\\*b") creront la mme expression (qui permet de chercher la lettre "a", suivie d'un astrisque, suivi de la lettre "b").

La tableau qui suit fournit une liste complte des caractres spciaux pouvant tre utiliss dans les expressions rgulires ainsi que leur signification.

Afin d'chapper les informations saisies par l'utilisateur et de trater les chanes de caractres pour les utiliser au sein d'un expression rgulire correspondante, il est possible d'utiliser le remplacement suivant :

function escapeRegExp(string) {
  // $& correspond  la chane correspondante
  // dans son intgralit
  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
}

Le marqueur g situ en fin d'expression permet d'effectuer une recherche globale, qui parcoure toute la chane et renvoie l'ensemble des correspondances trouves (voir Utiliser les marqueurs ci-aprs).

Utiliser les parenthses

Les parenthses encadrant une partie du motif de l'expression rgulire peuvent tre utilises pour garder en mmoire les correspondances. Cela pourra tre utile pour rutiliser la correspondance trouve.

Ainsi, le motif /Chapitre (\d+)\.\d*/ utilise des caractres chapps et spciaux et indique une partie du motif garder en mmoire. Ce motif correspond aux caractres 'Chapitre ' suivi par un ou plusieurs caractres numriques (\d correspond un chiffre et + indiquant que une srie de 1 ou plusieurs chiffres), suivis par un point (qu'il est ncessaire d'chapper car c'est un caractre spcial, on utilise donc '\' pour indiquer qu'on souhaite reconnatre le caractre '.'), suivi par 0 ou plusieurs chiffres (\d correspondant un chiffre et l'astrisque indiquant que le caractre est prsent 0 ou plusieurs fois). Les parenthses sont utilises pour garder en mmoire les premiers chiffres correspondant.

Ce motif est trouv dans "Ouvrir le Chapitre 4.3 au paragraphe 6" et le chiffre '4' est gard en mmoire. Le motif n'est pas trouv dans "Chapitre 3 et 4", car la chane de caractres ne comporte pas de point aprs le '3'.

Pour qu'une partie de la chane de caractre corresponde mais que la correspondance ne soit pas garde en mmoire, on pourra utiliser ?:. Ainsi, (?:\d+) correspondra pour une squence de chiffres (1 ou plusieurs chiffres) mais on ne gardera pas en mmoire les caractres correspondants.

Utiliser les expressions rationnelles

Les expresssions rgulires sont utilises avec les mthodes test() et exec() de l'objet RegExp et avec les mthodes match(), matchAll(), replace(), replaceAll(), search(), et split(). de l'objet String. Ces mthodes sont expliques en dtail dans la Rfrence JavaScript.

Pour savoir si un motif est prsent au sein d'une chane de caractres, utiliser les mthodes test ou search. Pour obtenir plus d'informations (moins rapidement) on utilisera les mthodes exec ou match. Si on utilise exec ou match et qu'une correspondance est trouve, ces mthodes renverront un tableau et mettront jour des proprits de l'objet global RegExp et aussi de l'instance de RegExp associe l'expression rationnelle. Si aucune correspondance n'est trouve, la mthode exec renverra null (qui est automatiquement converti false lors d'un test conditionnel).

Dans l'exemple qui suit, le script utilise la mthode exec pour trouver une correspondance dans une chane de caractres.

var monExpressionReguliere = /d(b+)d/g;
var monTableau = monExpressionReguliere.exec("cdbbdbsbz");

S'il n'est pas ncessaire d'accder aux proprits de l'expression rgulire, une autre faon de rcuprer monTableau peut tre :

var monTableau = /d(b+)d/g.exec("cdbbdbsbz");
// quivalent  "cdbbdbsbz".match(/d(b+)d/g);

Si on souhaite construire une expression rgulire partir d'une chane de caractres, on peut utiliser le script suivant :

var monExpressionReguliere = new RegExp("d(b+)d", "g");
var monTableau = monExpressionReguliere.exec("cdbbdbsbz");

Avec ces scripts, on obtient bien une correspondance, la mthode renvoie un tableau et met jour les proprits listes dans le tableau qui suit.

Comme le montre la seconde formulation de cet exemple, il est possible d'utiliser une expression rationnelle, cre avec un objet initialis sans l'affecter une variable. Cela implique qu' chaque utilisation, on aura une nouvelle expression rgulire distincte et qu'on ne pourra pas, pour cette raison, accder aux proprits de l'expression rgulire. Avec le script suivant :

var monExpressionReguliere = /d(b+)d/g;
var monTableau = monExpressionReguliere.exec("cdbbdbsbz");
console.log("La valeur de lastIndex est " + monExpressionReguliere.lastIndex);

// "La valeur de lastIndex est 5"

Si le script utilis est :

var monTableau = /d(b+)d/g.exec("cdbbdbsbz");
console.log("La valeur de lastIndex est " + /d(b+)d/g.lastIndex);

// "La valeur de lastIndex est 0"

Les occurences de /d(b+)d/g dans les deux instructions sont des objets diffrents. Leurs proprits lastIndex respectives ont donc des valeurs diffrentes. Quand il est ncessaire d'accder aux proprits d'un objet dcrivant une expression rationnelle, il faudra d'abord l'affecter une variable.

Utiliser les correspondances de groupes avec les parenthses

Les parenthses, utilises dans un motif d'expression rgulire, permettent de garder en mmoire un groupe (ou fragment) d'une correspondance. Ainsi, /a(b)c/ correspond aux caractres 'abc' et garde 'b' en mmoire. Pour rcuprer ces fragments mmoriss, on peut utiliser les lments du tableau array [1], ..., [n].

Le nombre de fragments qu'il est possible de garder entre parenthses n'est pas limit. Le tableau renvoy contiendra tout ce qui aura t trouv. Les exemples qui suivent montrent comment utiliser cette syntaxe.

Le script qui suit utilise la mthode replace() pour changer les mots d'une chane de caractres. Pour remplacer le texte, le script utilise $1 et $2 qui correspondent au premier et deuxime groupe correspondant.

var re = /(\w+)\s(\w+)/;
var str = "Titi toto";
var newstr = str.replace(re, "$2, $1");
console.log(newstr);

Cela affichera "toto, Titi".

Effectuer des recherches avances en utilisant les marqueurs (flags)

Les expressions rationnelles peuvent tre utilises avec des marqueurs optionnels permettant des recherches globales et/ou ne respectant pas la casse. Ces marqueurs peuvent tre utiliss sparement ou ensemble, quel que soit l'ordre. Ils font partie de l'expression rgulire.

Pour utiliser un marqueur avec une expression rgulire, on utilisera la syntaxe suivante :

var re = /motif/marqueurs;

ou

var re = new RegExp("motif", "marqueurs");

Les marqueurs font partie intgrante d'une expression rgulire, ils ne peuvent pas tre ajouts ou supprims ensuite.

Ainsi, re = /\w+\s/g permet de crer une expression rgulire pour trouver un ou plusieurs caractres suivis d'un espace, la recherche est effectue globalement, sur toute la chane de caractres.

var re = /\w+\s/g;
var str = "un deux trois quatre";
var monTableau = str.match(re);
console.log(monTableau);

Cela affichera ["un ", "deux ", "trois "]. On pourrait remplacer la ligne :

var re = /\w+\s/g;

avec la ligne :

var re = new RegExp("\\w+\\s", "g");

pour obtenir le mme rsultat.

Le comportement du marqueur 'g' est diffrent selon qu'il est utilis avec exec() ou avec match(). Pour match(), c'est la chane de caractres qui invoque la mthode et l'expression rationnelle est alors un argument. Pour exec(), c'est l'expression rationnelle qui invoque la mthode et c'est la chane de caractres qui est passe en argument. Dans l'appel exec(), le marqueur 'g' permet d'avoir une progression itrative.

Le marqueur m pourra tre utilis pour traiter une chane de caractres de plusieurs lignes comme plusieurs lignes distinctes. Si ce marqueur est utilis, les caractres spciaux ^ et $ correspondront au dbut ou la fin de n'importe quelle ligne appartenant la chane de caractres au lieu de correspondre simplement au dbut ou la fin de la chane.

Exemples

Les exemples qui suivent utilisent les expressions rgulires dans diffrents cas.

Changer l'ordre d'une saisie

L'exemple qui suit utilise les expressions rgulires et string.split() et string.replace(). Le script nettoie la chane de caractres saisie qui contient des noms (prnom puis nom) spars par des blancs, tabulations et points-virgules. Enfin il inverse les noms et prnoms puis trie la liste.

// La chane des noms contient plusieurs blancs et tabulations,
// il peut y avoir plusieurs espaces entre le nom et le prnom.
var noms = "Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ; Chris Hand ";

var output = ["---------- Chane originale\n", noms + "\n"];

// Prparer deux expressions rgulires pour stocker un tableau.
// et dcouper les chanes dans ce tableau.

// motif: on peut avoir des blancs, un point virgule puis d'autres blancs
var motif = /\s*;\s*/;

// Dcouper la chane de caractres en morceaux spars par le prcdent motif
// Stocker ces morceaux dans un tableau listeNoms
var listeNoms = noms.split(motif);

// nouveau motif : un ou plusieurs caractres, des blancs puis des caractres.
// On utilise des parenthses pour garder en mmoire les groupes du motif.
// On utilisera ces groupes par la suite.
motif = /(\w+)\s+(\w+)/;

// Nouveau tableau pour enregistrer les noms traits.
var listeParNomFamille = [];

// Afficher le tableau des noms et remplir le nouveau tableau
// avec les noms et prnoms spars par des virgules, le nom
// de famille tant crit en premier
//
// La mthode replace supprime tout ce qui correspond au motif
// et le remplace par le nom (mmoris), une virgule, un espace
// et le prnom (mmoris).
//
// Les variables $1 et $2 font rfrences aux fragments gards
// en mmoire lors de l'utilisation du motif.

output.push("---------- Aprs dcoupage avec l'expression rgulire");

var i, len;
for (i = 0, len = listeNoms.length; i < len; i++) {
  output.push(listeNoms[i]);
  listeParNomFamille[i] = listeNoms[i].replace(motif, "$2, $1");
}

// Afficher le nouveau tableau
output.push("---------- Noms et prnoms inverss");
for (i = 0, len = listeParNomFamille.length; i < len; i++) {
  output.push(listeParNomFamille[i]);
}

// Trier par le nom de famille puis afficher le tableau tri
listeParNomFamille.sort();
output.push("---------- Trie");
for (i = 0, len = listeParNomFamille.length; i < len; i++) {
  output.push(listeParNomFamille[i]);
}

output.push("---------- Fin");

console.log(output.join("\n"));

Utiliser les caractres spciaux pour vrifier la saisie

Dans l'exemple suivant, on s'attend ce que l'utilisateur saisissent un numro de tlphone. Quand l'utilisateur appuie sur le bouton "Vrifier", le script vrifie la validit du numro. Si le numro est valide (il correspond la squence de caractres fournie par l'expression rgulire), le script affiche un message remerciant l'utilisateur et confirmant le numro. S'il est invalide, le script informe l'utilisateur et lui signifie que les informations saisies ne sont pas valides.

Dans les parenthses sans mmoire (?: , l'expression rgulire cherche les deux premiers chiffres ou l'indicatif du pays suivi d'un blanc et du premier chiffre, ce qui correspond

\d{2}|\+\d{2}[ ]\d

Cette partie signifie : deux chiffres OU un signe '+' suivi de deux chiffres, un blanc et un autre chiffre.

Ensuite, on a un groupe qui est mmoris (entre parenthses) :

([- ])

Ce groupe correspond ce qui va tre utilis pour sparer les diffrentes composantes du numro de tlphone.

Ensuite,

\d{2}\1

signifie qu'on a deux chiffres suivi du premier groupe qui est celui qui dfinit le sparateur. Le reste est compos de la mme faon. Ainsi les numros de tlphone +33 1 23 45 67 89 et 01 23 45 67 89 seront tous les deux valides.

L'vnement Change, provoqu quand l'utilisateur appuie sur Entre, renseigne la valeur RegExp.input.

<!doctype html>
<html>
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
    <meta http-equiv="Content-Script-Type" content="text/javascript" />
    <script type="text/javascript">
      var re = /(?:\d{2}|\+\d{2}[ ]\d)([- ])\d{2}\1\d{2}\1\d{2}\1\d{2}/;
      function testInfo(phoneInput) {
        var OK = re.exec(phoneInput.value);
        if (!OK)
          window.alert(
            phone.input + " n'est pas un numro de tlphone valide!",
          );
        else window.alert("Merci, votre numro est : " + OK[0]);
      }
    </script>
  </head>
  <body>
    <p>
      Saisissez votre numro de tlphone (avec indicatif) puis cliquez sur
      "Vrifier". <br />Le format attendu est ## ## ## ## ## ou +## # ## ## ##
      ##.
    </p>
    <form action="#">
      <input id="phone" /><button
        >
        Vrifier
      </button>
    </form>
  </body>
</html>

• Prcdent
• Suivant