Problèmes de regex

Bien le bonsoir,

J'ai décidé de me pencher sérieusement sur les regex, mais même après lecture de quelques docs, je ne comprends pas leur utilisation. (Enfin, j'ai pigé, mais vaguement, surtout quand on cherche plusieurs occurrences différentes des unes des autres)

Je souhaite retrouver au moins 5 chiffres, 5 lettres minuscules et 5 lettres majuscules dans n'importe quel ordre.

J'ai donc trouvé logique d'écrire ceci:

Code:

---

[a-zA-Z]{5}[0-9]{5}

---

Mais visiblement, ma logique laisse un peu à désirer, donc j'ai choisi de tester petit à petit en ne cherchant que les lettres (minuscules et majuscules) avec cette expression:

Code:

---

[a-zA-Z]{5}

---

Mais ça m'affiche une erreur dès que le matcher a trouvé une occurrence dans mon message, voici le message:

Code:

---

Matcher match = patt.matcher("12345AZERTYUIOPazertyuiop"); //10 lettres minus et 10 lettres majuscules pour être sûr

---

Je suis obligé de mettre une quantité astronomique de caractères pour qu'il trouve au moins une occurrence pour que ça casse ensuite...

Vous auriez une idée d'où pourrait venir mon erreur ?

En attente de votre réponse,

Cordialement,

Songbird.

Quelle erreur ça t'affiche?

Citation:

---

Envoyé par tchize_

Quelle erreur ça t'affiche?

---

Bonsoir,

Tout à l'heure, ça m'affichait "match not found", un truc du genre.

Maintenant, vu que j'ai mis une condition, ça me dit que le mot de passe ne correspond pas aux attentes demandées, alors que c'est le cas.... au moins 5 chiffes, 5 minus, 5 majuscules.

Voici le code complet:

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

import java.util.regex.Pattern; import java.util.regex.Matcher;     public class RegTest { Pattern patt = Pattern.compile("[a-zA-Z]{5}[0-9]{5}"); Matcher match = patt.matcher("12345azertAZERT");   public RegTest(){   } public void searchMatch(){ if(match.find()){ for(int i =0; match.find(); i++){ System.out.println("Ok ?"+match.find()); System.out.println("Trouvé: "+match.group()); } }   else if(!match.find()){ System.out.println("Ok ?"+match.find()); System.out.println("Le mot de passe n'est pas assez robuste."); } }   public static void main(String[] args){ new RegTest().searchMatch(); } }

---

Merci à toi.

Code:

---

[a-zA-Z]{5}[0-9]{5}

---

Les patterns ça se lit de gauche à droite. Ca dit 5 lettres suivies de 5 chiffre. Il faut faire les choses dans l'ordre. Tu cherche à faire une expression qui validera la totalité sur trois règles distinctes: au moins 5 chiffres, au moins 5 minuscules, au moins 5 majuscule. Pour ça il faut utiliser des groupes non capturant:

(?=au moins 5 chiffres)(?=au moins 5 minuscules)(?=au moins 5 majuscule)


maintenant, c'est quoi "au moins 5 chiffres"? Ce n'est pas [0-9]{5} Car ça, ça veux dire exactement 5 chiffres successifs. Non, c'est 5 fois un chiffre avec peut être autre chose autour:
(.*[0-9].*){5,}
Pareil avec les minuscules et majuscules

(.*[a-z].*){5,}
(.*[A-Z].*){5,}
et mettant ensemble, on aurait un truc dans ce gout là:

(?=(.*[0-9].*){5,})(?=(.*[a-z].*){5,})(?=(.*[A-Z].*){5,})

Citation:

---

Envoyé par tchize_

[a-zA-Z]{5}[0-9]{5}

(?=(.*[0-9].*){5,})(?=(.*[a-z].*){5,})(?=(.*[A-Z].*){5,})

---

Je te remercie pour la clarté de ton explication, j'essaierai ça demain ! :)

Une dernière question: A quoi correspond le symbole "?=" que tu as utilisé ?


Bonne soirée.

Je l'ai dit, c'est un groupe non capturant

Personnellement, ma réponse aurait plutôt été que les regex ne sont pas très utiles pour faire ça, et qu'il vaut mieux programmer la vérification soi-même, ou alors avec plusieurs étapes utilisant les regex.
Mais bon -_-°.

Tout à fait d'accord. Quand une regexp devient difficile à écrire ou à comprendre, c'est signe que ce n'est pas adapté au problème.

La méthode find n'est pas trop adaptée pour une validation de mot de passe, mieux vaut se tourner vers la méthode matches ou éventuellement lookingAt car ces méthodes ancres la pattern au début de la chaîne alors que la méthode find cherche une correspondance pour chaque position dans la chaîne, ce qui est inutile (si ça ne marche pas au début de la chaîne, pas la peine de tester les positions suivantes).

Pour ce qui est de la pattern proposée par tchize_, je la transformerai comme ça pour lookingAt: (?=(?:.*[0-9]){5})(?=(?:.*[a-z]){5})(?=(?:.*[A-Z]){5})

• (?=...) est un lookahead (test avant) et peut se traduire par suivi de .... Comme c'est juste un test, il ne consomme pas de caractères, i.e. une fois la parenthèse fermante atteinte, on est toujours à la même position dans la chaîne. C'est pour ça que tu peux les faire se succéder à gogo, chacune pouvant tester une règle particulière toujours de la même position.
• (?:...) est une groupe non-capturant, il sert juste à regrouper des éléments pour par exemple pouvoir les répéter. Contrairement au groupe capturant (...), le texte correspondant à l'intérieur des parenthèses n'est pas stocké pour une utilisation ultérieur, d'où une économie de mémoire.
• {5} suffit comme quantificateur, on se fiche de savoir s'il y en a plus.

Toujours avec lookingAt tu peux aussi tenter de l'écrire comme ça (?=(?:[^0-9]*[0-9]){5})(?=(?:[^a-z]*[a-z]){5})(?=(?:[^A-Z]*[A-Z]){5}) pour éviter que .* aille jusqu'à la fin de la chaîne puis rende les caractères un par un jusqu'à ce que la pattern réussisse (et ce 3 fois).

Avec la méthode matches la pattern n'est pas différente, à la nuance que cette méthode exige que la pattern décrive la chaîne jusqu'à la fin. Donc pour faire fonctionner les deux patterns précédentes, il suffit de rajouter .* à la fin.

Code:

---

(?=(?:[^0-9]*[0-9]){5})(?=(?:[^a-z]*[a-z]){5})(?=(?:[^A-Z]*[A-Z]){5}).*

---

Maintenant au lieu d'utiliser .*, tu peux remplacer par ce que bon te semble pour tester d'autres choses (dimensions de la chaîne, caractères autorisés...)

Bonsoir,

D'accord, merci pour les explications, je prends note.

Je pense essayer avec la regexp et créer une procédure de vérification en parallèle, et j'aviserai au moment d'intégrer mon morceau de code au reste. :)

Bonne soirée à vous.