Aller au menu - Aller au contenu

Icône L'objet "RegExp"

Par Avatar JoSé2
Mise à jour : 22/07/2009
5 116 visites depuis 7 jours, dont 370 sur ce chapitre classé 38/786
Nous allons maintenant aborder un objet qui nous offre plus de contrôles sur les chaînes de caractères.
On le surnomme regex ; son nom est RegExp, pour Regular Expression, ce qui se traduit par "expression rationnelle" (une autre traduction, moins parlante, est "expression régulière").

C'est un sujet qui peut très vite devenir compliqué et "prise de tête" >_< ...
Tâchons donc de l'aborder de manière simple, mais suffisamment complète.


Note : dans ce chapitre, les regex seront écrites de cette façon.
Retour en haut
Sommaire du chapitre :
Icône du chapitre
Chapitre précédent Sommaire Chapitre suivant
Retour en haut

Sommaire

Créer une regex



Tout ce qu'il faut savoir pour créer une regex.
Il faut bien une sous-partie pour ça ;) .


Quelques exemples



On va créer des regex pour vérifier :
  • une adresse e-mail
  • un numéro de téléphone français.



Utiliser une regex



Ici, reg désigne une regex et str une chaîne de caractères.
  • reg.test(str) : renvoie true si str vérifie la regex, false sinon.
  • reg.exec(str) : applique la regex à la chaîne, renvoie le résultat.
  • str.match(reg) : applique la regex à la chaîne, renvoie le(s) résultat(s).
  • str.replace(reg, str2) : remplace le(s) sous-chaîne(s) vérifiant la regex par str2 et renvoie le résultat.
  • str.search(reg) : renvoie la position de la première sous-chaîne vérifiant la regex.
  • str.split(reg) : pour "découper" une chaîne.
Retour en haut

Créer une regex

Créer une regex




Avant de se lancer...



Pour tester une regex, nous allons utiliser la méthode nommée test de cet objet, qui s'utilise ainsi :
Code : JavaScript
1
var verifie = maRegex.test(str);

Si la chaîne de caractères str vérifie la regex maRegex, alors verifie vaut true, sinon il vaut false.


Une regex... pourquoi ?!



C'est bien beau, mais comment ça fonctionne ? o_O
Ça veut dire quoi "vérifier une regex" ?


Si on devait formuler une phrase pour décrire les regex, ce serait celle-ci :
Citation : les regex
L'utilisation des regex consiste à chercher un motif dans la chaîne de caractères.


Avec test, on récupère simplement true si le motif est trouvé dans la chaîne de caractères, false sinon.
Mais on peut également récupérer les morceaux de chaînes qui satisfont le motif, ou encore les remplacer par autre chose.

Pour l'instant, sachez qu'une chaîne de caractères est un motif.
Nous verrons des motifs plus évolués un peu plus loin dans ce chapitre, c'est justement son but.




Première regex



Il est maintenant temps de créer une première regex...
Sachez qu'il y a pour cela deux façons, qui reviennent au même.

La première, grâce à laquelle on voit bien que RegExp est une classe d'objet :
Code : JavaScript
1
var maRegex = new RegExp("motif", "flags");

La seconde, dont la syntaxe est moins lourde :
Code : JavaScript
1
var maRegex = /motif/flags;


Il y a des guillemets dans le premier cas, mais pas dans le second !

Le paramètre flags est facultatif (dans les deux cas).



On essaie !



Essayons donc sans plus tarder :
Code : JavaScript
1
2
3
var reg = new RegExp("toto");
var resultat = reg.test("toto");
alert(resultat);

Ce qui affiche true, normal ^^ .

Deuxième essai, avec la même regex :
Code : JavaScript
1
2
3
var reg = /toto/;
var resultat = reg.test("Bonjour toto !");
alert(resultat);

Ce qui affiche également true, car la chaîne de caractères qui forme le motif (c'est "toto") a été trouvée dans notre phrase (qui est "Bonjour toto !").


Une regex un peu plus évoluée




Les flags



Comme nous l'avons dit, une regex est constitué de deux choses :
  • un motif, qui sera recherché dans les chaînes de caractères auxquelles on appliquera notre regex,
  • des flags, qui sont des options supplémentaires.


Revenons sur ces derniers, qui ne devraient pas vous poser de difficultés.
Ils sont au nombre de trois :
  • i, pour rechercher le motif sans tenir compte de la casse (des majuscules / minuscules),
  • g, signifiant "global", dont on précisera l'utilisation en temps voulu (quand on parlera des fonctions utilisant les regex),
  • gi = g + i :D (pour combiner les deux options).



Des symboles bizarres



Maintenant que vous savez tout des flags, concentrons-nous sur les motifs, car c'est une autre paire de manches :-° .

Des symboles particuliers vont nous aider à rendre nos motifs beaucoup plus évolués. Vous verrez, avec tous ces symboles, un motif complet ressemble à du martien. :D

Le premier symbole est | (la barre verticale) et signifie OU.
Par exemple, pour vérifier si la chaîne contient sdz ou SdZ (avec ces majuscules) : /sdz|SdZ/
Cette regex vérifie "Vive le SdZ !" et "Je suis sur le sdz", mais pas "Le SDZ ?".
On peut utiliser des parenthèses pour délimiter : /(st|h|p)op/ est vérifié par "stop !", "Le shopping", "pop-up", mais pas par "flop".

Le symbole suivant est . (le point), qui signifie "n'importe quel caractère".
Ainsi, /o.o/i (notez le flag i pour ignorer la casse) sera satisfaite par : "o,O", "Toto" et "automobile".


Début et fin de chaîne



Deux symboles nous permettent de délimiter le début et la fin de la chaîne de caractères : ce sont respectivement ^ et $.

Par exemple, /^Bonjour/ sera satisfaite uniquement avec une phrase commençant par "Bonjour", comme "Bonjour monsieur", mais pas par "Hey ! Bonjour toi !".
Autre exemple, /!$/ va vérifier si une phrase se termine par un point d'exclamation, comme "Hey ! Bonjour toi !", mais pas comme "Toto ?!?"


Encore plus de symboles




Les classes



Il est également possible de définir, au lieu d'un seul caractère, une liste de caractères (appelée classe de caractères), en les indiquant entre crochets [].

Avec /t[iaot]c/, on peut ainsi filtrer "Et toc !", "Tic, tac...", "25? ttc", mais pas "tuc".

À l'intérieur d'une classe, il est possible d'utiliser le tiret pour définir une plage de valeur : [i-n] équivaut à [ijklmn], et [0-9A-F] à [0123456789ABCDEF].
On peut ainsi chercher si une phrase se termine par une lettre ou un chiffre avec /[a-zA-Z0-9]$/, vérifiée par "Bonjour", "BOB" et "Agent 007", mais pas par "Non." ni "(-_-)".

Inversement, on peut définir une classe en indiquant les caractères qui ne doivent pas y figurer, grâce à ^ placé au début de cette classe.
Exemple : pour détecter les phrases qui ne se terminent pas par une lettre, on peut utiliser /[^a-zA-Z]$/, que vérifie "Agent 007" mais pas "Toto".

Attention à ne pas confondre les deux utilisations de ^ !
  • Au début d'une classe (entre crochets), il indique quels caractères ne font pas partie de cette classe.
  • En dehors des crochets, il indique le début de la chaîne de caractères.



Classes existantes



Certaines classes très utilisées sont déjà définies : en voici les principales.

NomÉquivalentDescription
\d [0-9] Un chiffre
\D [^0-9] Caractère qui n'est pas un chiffre
\w [a-zA-Z0-9_] Caractère alpha-numérique, ou underscore
\W [^a-zA-Z0-9_] Caractère non alpha-numérique (autre que underscore)
\s Caractère "blanc" (espace, saut de ligne, tabulation, etc.)
\S Caractère "non-blanc"
\b Début / fin de mot (début de chaîne, espace, etc.)
\B Ni début ni fin de mot


Dans une chaîne de caractères, l'antislash est déjà utilisé pour les caractères spéciaux. Ainsi, si vous utiliser la notation
new RegExp("motif"),
il faut faire précéder chaque antislash d'un... antislash. o_O
Voyez plutôt : les deux regex suivantes sont identiques :
Code : JavaScript
1
2
var regex1 = /\d/;
var regex2 = new RegExp("\\d");



Les quantificateurs



Il est possible de préciser le nombre de fois que doit se répéter un "bout de motif".


Quantifier "manuellement"



On peut préciser, entre accolades {}, le nombre de fois qu'un caractère / groupe de caractères doit se répéter.
Dans cet exemple, on veut filtrer "foot" avec deux "o" : /fo{2}t/

Il est possible d'indiquer une plage de valeur : on demande au groupe de caractères de se répéter au minimum i fois, et au maximum j fois, avec {i,j}.
Par exemple, /bo{2,5}m/ cherchera "boom" avec 2, 3, 4 ou 5 "o".

Notez que la valeur supérieure est facultative.
Ainsi, /bo{2,}m/ sera validé par "boom" et par "boooooom" : avec 2 "o" ou plus.


D'autres symboles pour quantifier



Il existe les symboles ? * et + en guise de "raccourcis".

NomÉquivalentEn français
? {0,1} 0 ou 1 fois
* {0,} N'importe quel nombre de fois
+ {1,} Au moins une fois



Symbole utilisé = symbole à échapper !



Et si on veut utiliser le point dans nos regex, comment faire ?
Si on l'écrit comme ça, il veut dire "n'importe quelle caractère" !


Pour utiliser en dehors d'une classe l'un des symboles, mais en tant que caractère, il faut l'échapper en le faisant précéder d'un antislash.
Exemple : pour savoir si une chaîne se termine par ".com", on utilisera /\.com/

Voici une liste de symboles à échapper : | . ^ $ ( ) [ ] - { } ? * + \ /


À l'intérieur d'une classe, inutile d'échapper les caractères autres que ^ [ ] - \.


De même que pour les classes prédéfinies, si vous utilisez la notation new RegExp("motif"), il faut penser à échapper les antislashes, ainsi que les guillemets !
Voici à nouveau deux regex identiques :
Code : JavaScript
1
2
var regex1 = /\.com/;
var regex2 = new RegExp("/\\.com/");



Parenthèses : avec ou sans capture ?




Ce qu'on n'a pas encore dit...



Pour l'instant, nous utilisons simplement les regex pour savoir si une chaîne vérifiait un certain motif. Mais les regex permettent bien plus que ça !


Il est également possible de savoir quelles sous-chaînes satisfont le motif, et on va même pouvoir utiliser les regex pour en extraire certains morceaux.
Ainsi, dans une phrase telle que "les horaires sont 16h45, 17h, 17h20 et 17h40", il est possible d'extraire toutes les heures à l'aide d'une simple regex.

Puissant ! :soleil:


Les parenthèses capturantes



Pour extraire certains morceaux d'une chaîne de caractères, il faut les délimiter dans notre motif. Pour ce faire, on utilise les parenthèses, qui sont dites capturantes.

Un exemple : on veut extraire l'âge du visiteur, qui se trouve dans une chaîne du type "J'ai 99 ans".
Construisons notre motif lentement... on va d'abord se baser sur "j'ai" et "ans", sans tenir compte de la casse : /j\'ai - ans/i
Ces mots sont séparés de l'âge par un blanc (éventuellement, l'utilisateur peut écrire "99ans" sans espace) : /j\'ai\s - \s?ans/i
Maintenant, on ajoute les chiffres (1, 2 ou 3 chiffres), en les capturant grâce aux parenthèses : /j\'ai\s(\d{1,3})\s?ans/i

On a donc notre regex /j\'ai\s(\d{1,3})\s?ans/i o_O
Elle va nous permettre d'extraire l'âge (dans notre exemple, 99).
Pour l'instant, on ne sait pas comment récupérer le contenu ; en fait, ça va dépendre de la fonction utilisée, on en reparlera donc quand on présentera les fonctions.



Et si on veut des parenthèses qui ne capturent pas ?



Cependant, on peut avoir besoin de parenthèses, mais sans pour autant vouloir en capturer le contenu (par exemple, avec le symbole | vu plus haut).

Il est possible de les rendre non-capturantes, en les faisant commencer par ?:.
Reprenons un exemple vu plus haut, en rendant les parenthèses non capturantes : /(?:st|h|p)op/


Les assertions



Terminons la théorie par un point un peu plus délicat. :-°
Supposons que nous voulions rechercher "bon", mais uniquement dans le mot "bonjour"...

On pourrait utiliser des parenthèses capturantes, de cette manière : /(bon)jour/.
Ainsi, "Bien le bonjour, mon bon monsieur" vérifiera ce motif.
On récupère donc deux choses : le "bonjour", qui satisfait le motif, et le "bon", capturé par les parenthèses.

Mais il est possible d'utiliser ce qu'on appelle une assertion : le symbole (?= (à placer entre parenthèses) à la fin du motif, signifie "si le motif est suivi de".
Dans l'exemple précédent, ceci nous donne /bon(?=jour)/. Comprenez-le ainsi : "bon, s'il est suivi de jour".
Ainsi, dans la phrase "Bien le bonjour, mon bon monsieur", seul le "bon", s'il est suivi de "jour", est sélectionné. :)


Il existe de même le symbole ?!, en fin de motif lui aussi, signifiant "si le motif n'est pas suivi de".
Ainsi, /bon(?!jour)/ (comprenez : "bon, s'il n'est pas suivi de jour") appliqué à la même phrase nous donnera ce résultat : "Bien le bonjour, mon bon monsieur".

Remarquez qu'on retrouve le symbole = pour "est suivi de", et ! pour "n'est pas suivi de".
Comme pour les signes == et !=, le = exprime l'égalité, et le ! la négation.
Retour en haut

Quelques exemples

Quand est-ce qu'on utilise des expressions régulières ?
Parce que c'est bien joli de rechercher "toto" dans une phrase, mais en pratique...


En JavaScript, il est courant d'avoir à vérifier des formulaires avant de les valider. Et pour cela, les regex constituent un outil excellent, car elles permettent de contrôler très précisément toutes les informations données par le visiteur.

Comme nous avons pu le dire, vérifier un formulaire en JavaScript est très agréable pour le visiteur, mais n'est pas très fiable (car ce dernier peut désactiver le JS pour contourner la vérification).
Ainsi, il est courant d'effectuer une seconde vérification, en PHP cette fois, pour une vérification réellement fiable.
Et en PHP, les regex existent, et sont pratiquement identiques, ce qui nous simplifie donc la tâche si on doit faire les deux vérifications.
Si ça, ce n'est pas une bonne nouvelle... ;)



Revenons à nos moutons : nous voulions créer des regex pour vérifier si le pseudonyme donné par le visiteur n'est pas trop long, si l'âge qu'il a saisi est valide, s'il n'a pas donné une adresse e-mail qui n'en est pas une, si son numéro de téléphone est vraisemblable, etc.


Le pseudonyme



Tout d'abord, on demande un pseudonyme à l'utilisateur.
Seulement voilà : pour éviter les trucs complètement tordus qui risquent de nous embêter par la suite, on va demander à ce qu'il comporte entre 3 et 16 lettres, avec éventuellement des chiffres et des tirets (hauts et bas).

Voici donc une regex, toute simple, pour vérifier ceci :
/^[a-zA-Z0-9_-]{3,16}$/

Libre à vous d'adapter à vos besoins, ceci n'est qu'un exemple...


L'âge



Pour vérifier l'âge, deux solutions s'offrent à nous...


La première consiste à convertir la valeur en nombre (entier), pour la comparer à un âge minimum et à un âge maximum.
Prenons par exemple 5 et 100 ans comme âges limites, et créons une fonction qui renvoie true si l'âge passé en paramètre est valide :
Code : JavaScript
1
2
3
4
5
6
function ageValide(valeur)
{
     var age = parseInt(valeur);   // on convertit la valeur en nombre entier
     var estValide = !isNaN(age) && (age >= 5) && (age <= 100);
     return estValide;
}

Les deux dernières lignes de la fonction sont équivalentes à ceci :
Code : JavaScript
1
2
3
4
if(!isNaN(age) && (age >= 5) && (age <= 100))
     return true;
else
     return false;



La seconde solution : en utilisant une regex !
On veut que l'âge soit composé d'un ou deux chiffres (on pourrait en prendre 3, ça ne change pas grand-chose au final).
Pour rappel, la classe [0-9] peut s'écrire \d.
Ce qui nous donne :
/^\d{1,2}$/


Quelle solution privilégier ?
  • La première solution a l'avantage de bien s'adapter, pour deux raisons. Tout d'abord, on choisit précisément les limites d'âge. Ensuite, la fonction de conversion est capable de "comprendre" correctement une expression telle "99 ans", qui sera ici considérée comme valide.
  • Concernant la seconde solution, certain diront que "c'est comme tuer une mouche avec un bazooka". :D
    En bon français : est-ce vraiment utile d'utiliser des moyens si "élaborés" pour tester un nombre ?
    En effet, les regex sont utilisés pour analyser des chaînes de caractères. Les utiliser pour savoir si on se trouve en présence d'un nombre peut donc sembler un peu "démesuré".



Le numéro de téléphone



Passons maintenant au numéro de téléphone, dans le cas où c'est un numéro français (le principe reste bien sûr le même pour tous les pays).

Pour rappel, un numéro français est constitué de 5 groupes de 2 chiffres.
Le premier chiffre est toujours un 0 ; le second chiffre peut être soit 1, 2, 3, 4, 5 (selon la région), soit 6 (pour les portables), soit 8 (numéros spéciaux).
Pour séparer les groupes de chiffres, on va considérer que l'utilisateur utilisera soit un espace, soit un tiret, soit un point (soit il ne les sépare pas).

Au passage, nous allons choisir de capturer chacun des groupes de chiffres (ce qui permettra, si besoin est, de ne retenir que les chiffres, sans les séparateurs).

Décomposons donc notre regex...
  • /[ _.-]?/ pour un séparateur (je vous rappelle que le ? est équivalent à {0,1}, car le séparateur est facultatif).
  • /[ _.-]?(\d{2})/ : on ajoute deux chiffres après le séparateur, et on les capture grâce aux parenthèses.
  • /(?:[ _.-]?(\d{2})){4}/ : on répète 4 fois ce groupe "séparateur + 2 chiffre". Pour le délimiter, on utilise des parenthèses non capturantes.
    Pour l'instant, on capture donc les numéros tels que "-12-34-56-78".
  • /(0[1-68])(?:[ _.-]?(\d{2})){4}/ : on ajoute (et on capture avec les parenthèses) le premier groupe de 2 chiffres, dont le premier est forcément un 0, et le second est 1, 2, 3, 4, 5, 6 ou 8.
  • /^(0[1-68])(?:[ _.-]?(\d{2})){4}$/ : on ancre la regex : le numéro commence au début de la chaîne et se termine à la fin.


Ce qui nous donne la magnifique regex suivante, prête à l'emploi :
Code : JavaScript
1
var regexTel = /^(0[1-68])(?:[ _.-]?(\d{2})){4}$/;

Ou bien, pour utiliser l'autre façon de créer une regex :
Code : JavaScript
1
var regexTel = new RegExp("^(0[1-68])(?:[ _.-]?(\\d{2})){4}$");



Et comme vous mourez d'envie de la tester, voici un petit script pour demander un numéro et le tester. :p
Code : JavaScript
1
2
3
4
5
6
var regexTel = /^(0[1-68])(?:[ _.-]?(\d{2})){4}$/;
var numeroTel = prompt("Quel est votre numéro de téléphone ?");
if(regexTel.test(numeroTel))
     alert("Votre numéro semble correct");
else
     alert("Ce n'est pas un numéro de téléphone (français) valide");



L'adresse e-mail



Après l'exemple du numéro de téléphone, vérifier une adresse e-mail ne devrait pas vous poser trop de problèmes...

Si on récapitule, une adresse e-mail, c'est
  • des caractères : lettres, chiffres, points et tirets (hauts ou bas),
  • un symbole "arobase" @,
  • des caractères : comme au début, mais en minuscules ; au moins deux,
  • un point,
  • des caractères : de 2 à 4 lettres minuscules.


On a donc notre regex sans trop de difficultés :
/^[a-zA-Z0-9._-]+@[a-z0-9._-]{2,}\.[a-z]{2,4}$/
Retour en haut

Utiliser une regex

reg.test(str)



Renvoie true si la chaine vérifie le motif, false sinon.


reg.exec(str)



Cherche la première expression vérifiant le motif, et renvoie un tableau contenant :
  • dans la première case (d'indice 0), l'expression qui vérifie le motif,
  • dans les cases suivantes (à partir de l'indice 1), les sous-chaînes capturées via les parenthèses.



str.match(reg)



Renvoie un tableau :
  • s'il n'y a pas le flag "g" : le tableau contient la première expression qui satisfait le motif, et les captures (même résultat que reg.exec(str)) ;
  • s'il y a le flag "g" : le tableau contient toutes les expressions satisfaisant le motif (mais sans les captures).



str.search(reg)



Renvoie la position de la première expression qui vérifie le motif.


str.replace(reg, str2)



Remplace les expressions vérifiant le motif par la chaine str2 (uniquement la première s'il n'y a pas le flag "g", toutes s'il y est) ; le résultat est renvoyé.

La valeur capturée par la n-ième parenthèse (n étant un numéro, plus grand ou égal à 1) est accessible via $n.

Exemple : affichera "Le grooos chat griiis est très graaas !"
Code : JavaScript
1
2
3
4
var regex = /gr([aio])s/g;
var chaine = "Le gros chat gris est très gras !";
var resultat = chaine.replace(regex, "gr$1$1$1s");
alert(resultat);



str.split(reg)



Découpe la chaine aux endroits où le motif est vérifié. Les éléments capturés via les parenthèses sont rajoutés au découpage.

Exemple pour scinder une chaîne là où il y a des signes de ponctuation, en conservant ces signes (pour rappel, \s = caractère blanc) :
Code : JavaScript
1
2
3
var regex = /\s?([.,:;])\s?/;
var chaine = "Ceci est un test : il est destiné à tester des regex ; à rien d'autre, rien.";
var resultat = chaine.split(regex);


Voici le résultat obtenu :
Citation : Contenu du tableau

resultat[0] : "Ceci est un test"
resultat[1] : ":"
resultat[2] : "il est destiné à tester des regex"
resultat[3] : ";"
resultat[4] : "à rien d'autre"
resultat[5] : ","
resultat[6] : "rien"
resultat[7] : "."
resultat[8] : "" (car il n'y a rien après le point)
Retour en haut
J'espère que vous avez tenu le coup ;) .
Si tout est un peu flou pour vous, revenez-y un peu plus tard, lorsque vous serez plus familiarisés avec les objets JS.

Ce sujet est certes difficile, mais les regex sont des outils vraiment puissants : ça vaut le coup de s'y intéresser.

Bien que nous ayons beaucoup utilisé les regex dans ce chapitre (il fallait bien des exemples), il ne faut pas non plus en abuser, car ça peut demander beaucoup de travail à l'ordinateur.
Apprenez à les utiliser uniquement lorsqu'elles s'avèrent vraiment utiles.
Chapitre précédent Sommaire Chapitre suivant
Retour en haut

Partager

Retour en haut
4 commentaires pour "L'objet "RegExp""
Note moyenne : 3.51 / 4 (260 votes)
Pseudo Commentaire
Hors ligne Anonyme # Posté le 22/04/2009 à 16:04:06

Je pense qu'il faudrait prendre en compte les numéros de téléphones en 09 :

var regexTel = /^(0[1-68-9])(?:[ _.-]?(\d{2})){4}$/;

Et peut-être qu'il y aura bientôt des numéros en 07 ? cf news assez lointaine sur les numéros de portables
Hors ligne lenainjaune # Posté le 20/08/2009 à 11:25:45
Avatar

 Bonjour à tous,

Tout d'abord un grand merci à JoSé2, pour ce tutoriel sur les expressions régulières. Je commence à mieux les comprendre ...

Je voulais juste vous donner ma petite contribution pour tester les expressions régulières. C'est une simple fonction qui permet de tester simplement...

NB: je ne garantis pas que cette fonction est exempte de bugs, ni qu'elle est optimisée, ni qu'elle respecte la syntaxe recommandée pour le JS (je suis débutant après tout) ...

Code : JavaScript
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
function testRegExp(titre, regex, demander /*,... chaines_test*/) { 
  /*
          testRegExp permet de tester des expressions régulieres

                          Les arguments
                               ---
    titre:          Indique clairement ce a quoi sert l'expression (chaine)  
    regex:          L'expression a proprement parler (regex et pas une chaine)
    demander :      [optionel] Indique si la chaine de test va etre demandee; 
                    par defaut true (booleen)
    chaines_test :  [optionel] 0, 1, plusieurs chaines de test; 
                    par defaut une chaine de test vide (chaine)
                    
    Retour:         Le rapport d'evaluation (chaine)

    Utilisation:
    On fournit un titre, une regex, on indique si on veut saisir la chaine de
    test et on fournit les eventuelles chaines de test. Si demander est a true, 
    on pourra saisir sa chaine de test ou modifier l'une des chaines de test 
    fournies en arguments. Si demander est a false, l'evaluation des chaines
    sera automatique.
    
    Remarque: 
    Si demander est a false et que l'on ne fournit pas de chaine de test,
    l'evaluation sera faite sur une chaine vide
    
                              LNJ 20/08/2009 V1.0
                            
  */ 
  if(demander == undefined) demander = true;
     
  var args = testRegExp.arguments;  // on recupere les arguments de la fonctionn 
  var rapport = "";
  var chaine_test;
                  
  // si aucun test fourni, il faut quand meme rentrer dans la boucle
  if(args.length < 4) 
    args = new Array(args[0], args[1], args[2], "");

  // Pour chaque chaine de test       
  for(var i = 3; i < args.length; i++) {        
    if(demander)
      chaine_test = prompt(titre + "> " + regex + "\n\nChaine à tester:", args[i]);
    else
      chaine_test = args[i];
      
    rapport += titre + "> " + regex + " :";        
    rapport += " \"" + chaine_test + "\"";
    rapport += regex.test(chaine_test) ? " satisfait" : " ne satisfait pas";
    rapport += "\n";                            
  }   
  return rapport;        
}

un exemple d'utilisation en mode automatique:
Code : JavaScript
1
2
3
4
5
6
7
8
var msg = "";
    msg += testRegExp("pseudo",              // pseudo
    /^[a-zA-Z0-9_\-]{3,16}$/
    , false, "g-9", " aaa", "gg", "12345678901234567");   
    msg += testRegExp("age",                   // age
    /^\d{1,3}$/
    , false, "123", " 123", "1.2"); 
    alert(msg);


Remarquez que les expressions régulières ne sont pas données sous forme de chaine !

Qui affiche dans une belle popup:
Code : Console
pseudo> /^[a-zA-Z0-9_\-]{3,16}$/ : "g-9" satisfait
pseudo> /^[a-zA-Z0-9_\-]{3,16}$/ : " aaa" ne satisfait pas
pseudo> /^[a-zA-Z0-9_\-]{3,16}$/ : "gg" ne satisfait pas
pseudo> /^[a-zA-Z0-9_\-]{3,16}$/ : "12345678901234567" ne satisfait pas
age> /^\d{1,3}$/ : "123" satisfait
age> /^\d{1,3}$/ : " 123" ne satisfait pas
age> /^\d{1,3}$/ : "1.2" ne satisfait pas


un exemple d'utilisation en mode saisie:

Code : JavaScript
1
2
3
4
5
var msg = "";
    msg += testRegExp("n° telephone",           // phone
    /^(0[1-68])(?:[ _.-]?(\d{2})){4}$/
    , true, "06-76-31-13-30", "0676311330", "06+76+31+13+30", " 0676311330" );                   
    alert(msg);





... qui demandera pour chacune des 4 chaines de test, de valider la chaine ou de la modifier. 

Avantage: on ne perd pas de temps a taper une chaine à chaque fois, on part sur un modèle existant ...



Voili, voilou !

Si vous avez des suggestions, des modifications à apporter ... elles seront les bienvenues...



Cordialement
                    
                        
J'aime ce qui est parfaitement clair !

                        
 

                    
                		
                

              
                

                  
                    
                      Hors ligne 
                    
                      Acarnan
                    
                  
                  
                    #
                    
                         Posté le 14/07/2010 à 10:53:38
                    
                    
                


                
                    

                
                
                    

Avatar

    

    Avis : Très bon
        
    



     Études : BTS IG Clermont-Ferrand






                		
                
                    
                    Pas mal du tout ce cours ! 

Celà dit j'aurai préféré qu'on aborde le sujet des parenthèses capturantes en même temps que les méthodes de RegExp parce qu'utiliser des parenthèses capturantes pendant tout le long du cours sans savoir à quoi elle servent en pratique c'est un peu déroutant !
                    
                		
                

              
                

                  
                    
                      Hors ligne 
                    
                      007Julien
                    
                  
                  
                    #
                    
                         Posté le 30/09/2010 à 17:10:09
                    
                    
                


                
                    

                
                
                    




    





                		
                
                    
                    Les expressions régulières permettent aussi de mises en forme rapides. Par exemple, en remplaçant la dernière virgule par un et, la ligne suivante :



emn=chn.substr(1).replace(/, ([^,]+)$/," et $1");



transforme une chaîne (telle que ", un, deux, trois, quatre") obtenue par itération dans une boucle en une énumération (", un, deux, trois et quatre.") quel que soit le nombre d'items.
                    
                		
                

              
            
        

        
            
Voir tous les commentaires