Pour qu'on mot de passe soit jugé fiable et sécurisé (toujours dans mon cas), il doit adhérer aux règles suivantes :

  • doit comporter un nombre de caractères minimum (au moins 6)
  • doit comporter au moins une majuscule (et une minuscule)
  • doit comporter au moins un chiffre
  • ne doit comporter aucun espace

ActionScript 3 fournit déjà quelques méta-caractères permettant de représenter une séquence de caractères (\s pour tous les espaces par exemple). Si on se borne aux fonctionnalités standardes, la première solution (archi-basique) serait quelque chose dans le genre :

var sample:String = "aBc09YzAui";
var pattern:RegExp = /^[a-zA-z0-9]+$/
trace(pattern.test(sample)); //true

Le souci de cette expression régulière est que l'on pourrais ne mettre que des minuscules, que des majuscules, ou même que des chiffres, cela passerait quand même. On peut donc essayer quelque chose du genre :

var sample:String = "aBc09YzAui";
var pattern:RegExp = /^[a-z]+[A-Z]+[0-9]+$/
trace(pattern.test(sample)); //false

Cette fois, il est obligatoire d'avoir au moins une minuscule, au moins une majuscule et au moins un chiffre. Deux problèmes avec cette RegExp : l'ordre est déterminé (au moins une minuscule suivie d'au moins une majuscule suivie d'un ou plusieurs chiffres) et que l'on n'a pas pu mettre un longueur de chaîne minimale...

Une solution du type (pour faire en sorte qu'il y ait au moins 6 caractères)

var pattern:RegExp = /^([a-z]+[A-Z]+[0-9]+){6,}$/

ne marche pas non plus, car l'ordre est toujours nécessaire (par exemple aA0bB1 marcherait, tandis que a01BbA ne passerait pas). Afin de pouvoir checker cela en une RegExp, il faut avoir une autre manière de faire.

Et c'est là ou interviennent les lookahead groups ! Ce mécanisme permet de définire une "sous-requete" RegExp de la même manière qu'une suite de conditions. Petit exemple rapide :

var pattern:RegExp = /sh(?=e)(\w*)/i;
var str:String = "Shelly sells seashells by the seashore";
trace(pattern.test(str)); //true

Dans le cas ci-dessus, on veut une chaîne commencant par 'sh' suivi de n'importe quelle suite de caractères visibles dont le premier est un 'e' (le tout avec l'option ignore case).

Cette idée appliquée à mon cas initiale nous donne :

var sample:String = "aBc09YzAui";
var pattern:RegExp = /^(?=.*[a-z]+)(?=.*[A-Z]+)(?=.*[0-9]+)([^\s]{6,})$/
trace(pattern.test(sample)); //true

Toutes les contraintes sont respectées :

  1. [^\s]{6,} indique qu'il faut une chaine d'au moins 6 caractères ne contenant pas d'espace, tabulation ou retour de ligne
  2. (?=.*[0-9]+) indique que dans la chaîne (1), il y ait au moins un ou plusieurs chiffres
  3. (?=.*[A-Z]+) indique que dans la chaîne (1), il y ait au moins une ou plusieurs majuscules
  4. (?=.*[a-z]+) indique que dans la chaîne (1), il y ait au moins une au plusieurs minuscules

A noter qu'il existe aussi l'inverse de (?=X) se notant (?!X) qui se traduit par 'dont la sous-requête n'est pas égale à' ! Cela permet vraiment de pouvoir faire beaucoup de chose, même très compliquée. Il existe même des sites comme regexlib qui permettent de trouver plein d'expressions régulières dont certaines sont particulièrement méchantes (et inutile :D).

PS. Pour ceux qui cherchent le billet 'RegExp Level 1' il n'existe pas !