CyBWarrior

1. L’objet RegExp
   1. Propriétés de l’objet RegExp
      1. global
      2. ignoreCase
      3. lastIndex
   2. Méthodes de l’objet RegExp
      1. compile(expression, options)
      2. exec(chaine)
      3. test(chaine)
2. Syntaxe des expressions régulières

Les expressions régulières permettent de manipuler les chaînes de caractères de façon très poussée. Dans
JavaScript, elles sont souvent utilisées pour la vérification des données transmises dans les formulaires
(présence du @ et pas d’espace dans l’email par exemple).
Les expressions réguliéres utilisées par JavaScript sont compatibles Perl (Perl est un langage utilisé
pour l’écriture de CGI).
La syntaxe des expressions régulières est extremement complete (et complexe) et nous nous contenterons ici
d’introduire le sujet. En effet, il existe des livres de plus de 400 pages sur ce sujet…

L’objet RegExp

Nous aurions pu faire un pari la dessus : et oui, dans JavaScript, les expressions régulières sont aussi des
objets. Ici, il s’agit de l’objet RegExp.
La syntaxe du constructeur est la suivante :

var MonExpression = new RegExp(expression, options);

MonExpression symbolise un identificateur correct, expression represente l’expression
régulière et options, les options de cette expression. Pour l’instant, ça ne nous dit pas grand
chose. Mais ce n’est qu’un début.

À noter qu’une expression régulière peut également être créée de manière littérale, comme par exemple ci-dessous :

var At = /@/;

Non! Vous ne revez pas! La ligne précedente est tout à fait correct. Il ne s’agit pas d’une chaîne de caractères,
vu qu’il n’y a ni guillemets, ni apostrophes, et ce n’est pas non plus un nombre : c’est une expression régulière.
Mais tout ceci deviendra plus clair dans un instant.

Propriétés de l’objet RegExp

global

Renvoi true si l’expression permet d’effectuer une recherche globale (attribut g présent).

ignoreCase

Renvoi true si l’expression est sensible à la casse des caractères ou non.

lastIndex

Renvoi la position du caractère où l’expression a été trouvée dans une chaîne lors de l’utilisation
de la méthode exec.

Méthodes de l’objet RegExp

compile(expression, options)

Modifie l’expression régulière en utilisant expression comme nouveau modéle et options
comme nouveaux attributs.

exec(chaine)

Teste si l’expression régulière peut s’appliquer à la chaîne de caractères chaine
passée en argument.
Si l’expression est trouvée, la méthode livre en retour un tableau (la valeur null est
renvoyée en cas d’echec).
Le première index de ce tableau (par exemple : Tableau[0]) represente la chaîne de caractères
correspondante au modéle, lorsque celui-ci utilise des parenthèses capturantes.
Ce tableau possede aussi 2 propriétés :

• index qui correspond à l’index du caractère de la chaîne où l’expression a été trouvée.
• input qui est en fait un lien sur la chaîne de caractère.

test(chaine)

Renvoi true si l’expression régulière est contenue dans chaine.

Syntaxe des expressions régulières

Tout d’abord, les options. Il y en a deux :

• g qui permet de réaliser une recherche globale, c’est à dire sur l’ensemble de la chaîne
  de caractères. Par exemple, si l’expression peut s’appliquer à deux endroits dans la chaîne, les deux
  occurances seront prise en compte, ce qui n’est pas le cas si g est abscent, où seule la
  première occurence est prise en compte.
  Exemple, avec la méthode replace de l’objet String (voir pages précedentes
  pour une explication détaillée) :

  var MonReg=/a/g;// ou bien var MonReg = new RegExp("a", "g");
  var Chaine="abracadabra";
  
  Chaine = Chaine.replace(MonReg, "A");// on remplace tout les 'a' par des 'A'
  document.write(Chaine);// Sortie -> AbrAcAdAbrA
  

• i permet de rendre insensible à la casse l’expression. Ces options sont cumulables. On peut
  donc écrire :

  var MonReg=/abr/gi;
  var Chaine="aBracadAbRa";
  
  Chaine = Chaine.replace(MonReg, "ABR");
  document.write(Chaine);// Sortie -> ABRacadABRA
  

Maintenant, voyons d’un peu plus près la syntaxe de ces expressions.

Les crochets permettent de spécifier des alternatives entre plusieurs caractères. Par exemple, on peut vouloir
effectuer une recherche qui retiendrai les mots moi ou toi, et pas le mot roi.
On se rend compte que seul la première lettre differe. On ecrira alors les caractères m et t
entre crochets :

var MonReg = /[tm]oi/i;

with(document){
writeln(MonReg.test("moi"));// true
writeln(MonReg.test("toi"));// true
writeln(MonReg.test("roi"));// false
}

Au lieu d’enumérer les lettres, on peut dans cerains cas préferer de spécifier un intervale, par exemple, de
a à l. On place alors la première lettre de l’intervale, suivie du signe moins (-)
et de la seconde lettre de l’intervale :

var MonReg = /[a-l]ou/i;

with(document){
writeln(MonReg.test("cou"));// true
writeln(MonReg.test("pou"));// false
}

On peut aussi spécifier des alternatives, séparées par le caractères pipe (|), pour rechercher
aol ou wanadoo :

var MonReg = /aol|wanadoo/;

with(document){
writeln(MonReg.test("robert@aol.com"));// true
writeln(MonReg.test("webmaster@cybwarrior.com"));// false
writeln(MonReg.test("marcel@wanadoo.fr"));// true
}

Si on sait qu’un caractère intervient, mais que l’on ne sait pas combien de fois, on peut utiliser le caractère
étoile (*). L’étoile indique que le caractère qui la précede peut intervenir 0 ou plusieurs fois dans
la chaîne :

var MonReg = /a*tchoum/;
var Chaine1 = "aaaaaaaaaaaaatchoum!";
var Chaine2 = "tchoum";

Chaine1 = Chaine1.replace(MonReg, "atchoum");
Chaine2 = Chaine2.replace(MonReg, "atchoum");

document.write(Chaine1);// Sortie -> atchoum!
document.write(Chaine2);// Sortie -> atchoum

Par contre, si on veut que le caractère a intervienne au moins une fois, il nous faut substituer
l’étoile par un plus (+) :

var MonReg = /a+tchoum/;
var Chaine1 = "aaaaaaaaaaaaatchoum!";
var Chaine2 = "tchoum";

Chaine1 = Chaine1.replace(MonReg, "atchoum");
Chaine2 = Chaine2.replace(MonReg, "atchoum");

document.write(Chaine1);// Sortie -> atchoum!
document.write(Chaine2);// Sortie -> tchoum (rien n'est modifié)

On peut aussi utiliser le point d’interogation (?) pour présicer que le caractère précedent est optionel :

var MonReg = /bienvenue?/;// Avec ou sans e ?

with(document){
writeln(MonReg.test("bienvenue"));// true
writeln(MonReg.test("bienvenu"));// true
}

Si on veut qu’un caractère intervienne un nombre précis de fois, on peut le préciser grace aux accolades ({
et }).
Voici comment detecter des codes de la forme XXX-XXX-XX.XX,ou X est un nombre :

var MonReg = /[0-9]{3}-[0-9]{3}-[0-9]{2}.[0-9]{2}/;

with(document){
writeln(MonReg.test("123-456-78.90"));// true
writeln(MonReg.test("4567-76-322.1"));// false
}

On peut aussi spécifier un nombre minimal et un nombre maximal de fois en utilisant les accolades sous la forme
{min, max}, ou min represente le nombre minimal et max le nombre maximal.
Au lieu de specifier un unique caractère, on peut specifier un mot en le placant entre parenthèses :

var MonReg = /Raph(ael)?/;

document.write(MonReg.test("Raphael")); // true
document.write(MonReg.test("Raph")); // true