Besoin d'aide sur regexp javascript

Version imprimable

Voir 40 message(s) de cette discussion en une page

Bonjour à tous,

Voilà, je développe un site internet avec un peu de javascript et je bloque sur la vérification de la complexité du mot depasse lors de l'inscription.

Voici le code que j'ai écrit :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 function motdepasse() { if (!document.register.motdepasse.value.match('[a-z]+[A-Z]+[0-9]+[^a-zA-Z0-9]+')) { document.getElementById('motdepasse').innerHTML = 'Votre mot de passe doit être compris entre 8 et 32 caractères, contenir une majuscule, une minuscule, un chiffre et un caractère non-alphanumérique.'; } else { document.getElementById('motdepasse').innerHTML = ''; } }
Ce code fonctionne il exige bien une minuscule, une majuscule, un chiffre et un caractère non alphanumérique, cependant je n'arrive pas à exiger une longueur minimum et maximum.

Si je met :

Code:

[a-z]+[A-Z]+[0-9]+[^a-zA-Z0-9]+{8,16}

Ca ne fonctionne pas.

Auriez-vous une idée ?

Merci à tous.
Cordialement,

30/05/2010, 17h28
SpaceFrog

Citation:

Ce code fonctionne il exige bien une minuscule, une majuscule, un chiffre et un caractère non alphanumérique, cependant je n'arrive pas à exiger une longueur minimum et maximum.

heu non il exige au moins une minuscule suivi d'au moins une majuscule suivi d'au mois un numérique suivi d'au moins un caractère non alphanumérique
donc
acfFGHYTR12356548%@ est validé ...

que souhaites tu autoriser exactement ?
30/05/2010, 17h51
SpLiFFman

En fait je souhaite :

Autoriser une ou plusieurs minuscules, une ou plusieurs majuscules, un ou plusieurs chiffres et un ou plusieurs caractères non alphanumériques.

Effectivement, je ne m'en était pas rendu compte mais il n'aurtorise qu'une majuscule suivie d'une minuscule suivie d'un chiffre suivi d'un caractère non alphanumérique.

Cela vient du mot de passe avec le lequel je test, qui utilise exactement cet ordre la :S

^^
30/05/2010, 18h04
SpaceFrog

Code:

il n'aurtorise qu'une majuscule suivie d'une minuscule suivie d'un chiffre suivi d'un caractère non alphanumérique.

Cel m'etonnerais fort !
+ => au moins un

donc en gros pas de limitation sur les caractères mais plutot sur le nombre entre 8 et 16 ?

Code:

^\w{8,16}$
30/05/2010, 18h09
SpLiFFman

Bonjour SpaceFrog,

En fait ce que je souhaite c'est exiger au moins une ou plusieurs minuscules, au moins une ou plusieurs majuscules, au moins un ou plusieurs chiffres et au moins un ou plusieurs caractères non alphanumériques et la chaine doit etre comprise entre 8 et 16 caractères.

Voilà, je n'avais pas bien expliqué.

Tu penses que ^\w{8,16}$ peux suffir ?

Cordialement,
30/05/2010, 19h40
SpaceFrog

un peu plus de precisions sur non alphanumérique ??
30/05/2010, 20h15
SpLiFFman

Caractères du genre :

&é~"#'{([-|è`_\ç^à@)]°=}+¨$£¤ù%*µ!§:/;.,?<>²

Je crois que je te les ai tous faits ^^ mdrr :P
30/05/2010, 21h45
eyquem

Code:

'#(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^a-zA-Z0-9])(?=\A.{8}\z)#'

Je m'ai trompé, au lieu de (?=\A.{8}\z) il faut (?=\A.{8,16}\z)#
30/05/2010, 21h58
SpaceFrog

Code:

/^[a-z0-9&é~"#'{(\[-|è`_\ç^à@)\]°=}+¨$£¤ù%*µ!§:/;.,?<>²]{8,16}$/i

sinon vu qu'a priori tu n'interdit que l'espace ...

Code:

/^[^ ]{8,16}$/

:mouarf:
30/05/2010, 22h31
eyquem

Bien vu, SpaceFrog, pour le [^ ]

Mais pour le reste je suis perplexe:

hormis le fait que les majuscules sont oubliées et que, définissant les non-alphanumériques explicitement, il risque d’en être oubliés,

il y a surtout que si par exemple on définit ’\A[a-z0-9+=@]{8,16}\z’, cela n’assure absolument pas qu’il y ait au moins un ’+’ par exemple:

’ahgt=et@@923’ passera le test puisque chacun de ses caractères appartient à la classe [a-z0-9+=@]

Donc j'en reste à ma proposition, en la corrigeant avec ton idée de [^ ]:

'#(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^a-zA-Z0-9])(?=\A[^ ]{8,16}\z)#'
30/05/2010, 23h04
SpaceFrog

Citation:

au moins un ’+’

HAaaaaa
Au moins un de chaque ... cela m'avais echappé
A mon avis pas possible avec une seul regExp ...
Ou alors vu qu'il faudra prendre en compte les différentes combinaisons
min maj non-alphanum
maj min non alphanum
min non-alphanum maj
...

elle ferait 3km de long ^^

donc une pour verifier les maj, une autre les min et une pour le non alpha et un test length

Citation:

A mon avis pas possible avec une seul regExp ...

Ou alors vu qu'il faudra prendre en compte les différentes combinaisons
elle ferait 3km de long ^^

Ben, la regex construite avec la RE que j’ai proposée le fait.
Je veux dire qu’elle réagit comme voulu, pas qu’elle fait 3 km....

Je viens de la tester. Vous m'excuserez, mais par fainéantise j’ai fait ça en Python:

Code:

1
2
3
4
5
6
7
8
9
10
11
import re
 
RE = '(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^a-zA-Z0-9])(?=\A[^ ]{8,16}\Z)'
pat = re.compile(RE)
 
while 1:
    ch = raw_input('Entrer une chaine de caracteres : ')
    if pat.search(ch):
        print len(ch),ch,'   OK'
    else:
        print len(ch),ch,'   PAS BON'

Code:

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
Entrer une chaine de caracteres : gfre9087AGTEr$$>
16 gfre9087AGTEr$$>    OK
Entrer une chaine de caracteres : gfreXXXXAGTEr$$>
16 gfreXXXXAGTEr$$>    PAS BON
Entrer une chaine de caracteres : gfre9087****r$$>
16 gfre9087****r$$>    PAS BON
Entrer une chaine de caracteres : 8#8#9087AGTEr$$>
16 8#8#9087AGTEr$$>    OK
Entrer une chaine de caracteres : 8#8#9087AGTE~$$>
16 8#8#9087AGTE~$$>    PAS BON
Entrer une chaine de caracteres : aB9&&&+
7 aB9&&&+    PAS BON
Entrer une chaine de caracteres : aB9&&&+s
8 aB9&&&+s    OK
Entrer une chaine de caracteres : aB9&&&+s9
9 aB9&&&+s9    OK
Entrer une chaine de caracteres : aB9&&&+s9fertw
14 aB9&&&+s9fertw    OK
Entrer une chaine de caracteres : aB9&&&+s9fertw4@+
17 aB9&&&+s9fertw4@+    PAS BON
Entrer une chaine de caracteres : aB9&&&+s9fertw4@
16 aB9&&&+s9fertw4@    OK
Entrer une chaine de caracteres : aB9& &+s9fertw4@
16 aB9& &+s9fertw4@    PAS BON
Entrer une chaine de caracteres : $%#^&***()~<>
13 $%#^&***()~<>    PAS BON
Entrer une chaine de caracteres : $%#^&***()~<>w
14 $%#^&***()~<>w    PAS BON
Entrer une chaine de caracteres : $%#^&***()~<>w0
15 $%#^&***()~<>w0    PAS BON
Entrer une chaine de caracteres : $%#^&***()~<>w0Q
16 $%#^&***()~<>w0Q    OK
Entrer une chaine de caracteres : $%#^&***()~<>w0Q-
17 $%#^&***()~<>w0Q-    PAS BON
Entrer une chaine de caracteres :

Tester les codes, ça aide.....

Bonjour eyquem,

Je vois que vous avez été actifs tous les deux et je vous en remercie ^^

Ma problématique s'inscrit dans l'écriture d'un code javascript dans une page php.

Voici mon code dans lequel j'ai rajouté l'expression régulière à laquelle vous êtes tous les deux arrivés :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 function motdepasse() { if (!document.register.motdepasse.value.match('(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^a-zA-Z0-9])(?=\A[^ ]{8,16}\Z)')) { document.getElementById('motdepasse').innerHTML = 'Votre mot de passe doit être compris entre 8 et 16 caractères, doit contenir au moins une majuscule, une minuscule, un chiffre et un caractère non-alphanumérique.'; } else { document.getElementById('motdepasse').innerHTML = ''; } }
Cependant, le message "Votre mot de passe doit être compris entre 8 et 16 caractères, doit contenir au moins une majuscule, une minuscule, un chiffre et un caractère non-alphanumérique." s'affiche toujours, ce qui signifie qu'il y'a une erreur.

Manifestement pas dans l'expression régulière mais peut être dans mon code.

Question subsidiaire :

Est-ce que les expressions régulières en javascript ont des particularitées de syntaxe qui pourrait faire que ton expression régulière ne marcherais pas dans mon code ?

Cordialement,

31/05/2010, 00h24
eyquem

Je ne connais pas JavaScript. Je ne pourrai donc pas vous aider au delà de ma RE.

Juste une remarque:

je ne vois pas comment est passée à la fonction la valeur de la chaîne à tester.

Est-ce « motdepasse.value » ?

Ne devrait il pas y avoir passage d’argument ?
31/05/2010, 03h55
SpLiFFman

En fait, pour le motdepasse.value :
- motdepasse correspond à un champ input text
- et input à sa valeur

Je test en fait la valeur du champ input par la fonction motdepasse() qui est appelée à l'appui sur un bouton.

J'ai l'impression qu'en javascript il doit y avoir des particularitée concernant les regexp.

La regexp que tu m'a donnée correspond à quel language ?
31/05/2010, 05h37
SpLiFFman

Voilà ce que j'ai trouvé, ca va m'aider un peu ^^

http://www.regular-expressions.info/...ptexample.html
31/05/2010, 05h56
SpLiFFman

(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^a-zA-Z0-9])

celle-ci marche

donc l'erreur est ici (?=\A[^ ]{8,16}\Z)
31/05/2010, 06h04
SpLiFFman

((?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^a-zA-Z0-9])){8,}

Celle-ci marche bien, donc l'erreur est sur la fin pour l'espace.
31/05/2010, 08h40
SpaceFrog

eyq, je ne vois pas comment ta reg peut prendre en considération les differentes combinaisons, am mois que le but recherché soit de respecter l'ordre minusucule maj non-alpha ...
31/05/2010, 11h46
eyquem
SpLiFFman, je dis ça sans méchanceté mais si tu utilises des expressions régulières en JavaScript, il serait bon que tu saches comment JavaScript utilise les expressions régulières.

Ton lien est intéressant. Je connaissais ce site sur les regex mais pas spécialement quelle partie des possibilités des regex le JavaScript utilise. Donc j’ai cliqué sur
Learn how to use the JavaScript RegExp object.
et je suis tombé sur une page bien intéressante dans laquelle je lis entre autres choses:

- « Since forward slashes delimit the regular expression, ... »
c’est comme en PHP, il y a des délimiteurs, mais ici ils sont obligatoirement des / si je comprends bien.
Il faut donc les ajouter à ma RE

- « No \A or \Z anchors to match the start or end of the string. Use a caret or dollar instead. »
Et paf, c’est exactement ce que j’ai utilisé. Les portions
(?=.*[a-z])
(?=.*[A-Z])
(?=.*[0-9])
(?=.*[^a-zA-Z0-9])
fonctionnant indépendamment les unes des autres et indépendamment de (?=\A[^ ]{8,16}\Z) , je comprends pourquoi il n’y a que cette dernière partie qui fait foirer et que ça marche si on l’enlève.

Je suis désolé de n’avoir pas été plus attentif à ces points, d’autant que tu as avais bien senti le danger: «Est-ce que les expressions régulières en javascript ont des particularitées de syntaxe ...»

Je m’aperçois que les regex en JavaScript ont des possibilités très limitées:

Citation:

No \A or \Z anchors to match the start or end of the string. Use a caret or dollar instead.
Lookbehind is not supported at all. Lookahead is fully supported.
No atomic grouping or possessive quantifiers
No Unicode support, except for matching single characters with \uFFFF
No named capturing groups. Use numbered capturing groups instead.
No mode modifiers to set matching options within the regular expression.
No conditionals.
No regular expression comments. Describe your regular expression with JavaScript // comments instead, outside the regular expression string.

Lookbehind is not supported at all.
Mais on a de la chance:
Lookahead is fully supported.
car les
(?=.*[a-z])
(?=.*[A-Z])
(?=.*[0-9])
(?=.*[^a-zA-Z0-9])
sont justement des lookahead assertions.

Enfin bref, je pense que ce devrait mieux marcher avec
Code:

1 2 if (!document.register.motdepasse.value.match('/(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^a-zA-Z0-9])^[^ ]{8,16}$/')
Nota: j’ai enlevé la dernière lookahaed assertion (?=...) autour de ^[^ ]{8,16}\$. C’est inutile, et même contradictoire, bien que ça marcherait quand même.

Pour ce qui est du fonctionnement:

il y a 5 portions
(?=.*[a-z])
(?=.*[A-Z])
(?=.*[0-9])
(?=.*[^a-zA-Z0-9])
^[^ ]{8,16}\$
qui spécifient 5 impératifs qui doivent être vérifiées par la chaîne testée:

(?=.*[a-z]) dit :

il faut explorer la chaîne vers l’avant à partir de ce point et il faut trouver dans l’avancée d’abord n’importe quelle succession de caractères avant de tomber ensuite sur un caractère de la classe [a-z], la succession de caractères quelconques (représentés par le métacaractère point) pouvant être éventuellement inexistante (dans le cas où le premier caractère est de la classe [a-z] )

Mais une fois cette exigence vérifiée, le moteur de regex REVIENT à la position initiale d’où il est parti: les assertions vers l’avant (aussi bien que celles vers l’arrière dans d’autres langages) ne sont pas consommatrices, elles sont seulement exploratrices de la chaîne à partir d’un point de départ. Si vous voulez, c’est comme un toutou qui n’est autorisé à explorer qu’une certaine longueur au bout de sa laisse et qui est obligé de revenir vers son maître.
Ouais bon... on trouve ce qu’on peut comme image....

L’important étant que lorsque la seconde assertion en avant est vérifiée, l’exploration se fait à partir du même point de départ.

Et rebelote, (?=.*[A-Z]) spécifie:

il faut explorer la chaîne vers l’avant à partir de ce point ...blablabli... avant de tomber ensuite sur un caractère de la classe [A-Z], la succession ...bliblibla... pouvant être éventuellement inexistante ...blabloublou...[A-Z] )

Puis idem avec (?=.*[0-9]) ,

la chaîne est explorée (avec retour) à partir du même point de départ, pour trouver un chiffre quelque part vers l’avant.

Et encore ensuite à partir du même point de départ,
avec (?=.*[^a-zA-Z0-9]) le moteur de regex cherche un caractère non-alphanumérique quelque part vers l’avant... et revient au point de départ.

Quel est ce point de départ ?

Étant donné que toutes les assertions vers l’avant sont écrites devant ^[^ ]{8,16}\$ ,
le point de départ est situé devant le premier caractère spécifié par ^[^ ]{8,16}\$

Bon en l’occurence ^[^ ]{8,16}\$ commence au début de la chaîne, donc les assertions vers l’avant ont leur point de départ au début de la chaîne.

Et voilà.

Voir 40 message(s) de cette discussion en une page