Regexp Java pour la validation du mot de passe

Essayez ceci:

^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])(?=\S+$).{8,}$

Explication:

^                 # start-of-string
(?=.*[0-9])       # a digit must occur at least once
(?=.*[a-z])       # a lower case letter must occur at least once
(?=.*[A-Z])       # an upper case letter must occur at least once
(?=.*[@#$%^&+=])  # a special character must occur at least once
(?=\S+$)          # no whitespace allowed in the entire string
.{8,}             # anything, at least eight places though
$                 # end-of-string

Il est facile d'ajouter, de modifier ou de supprimer des règles, étant donné que chaque règle est indépendante "module".

La (?=.*[xyz]) construire mange la totalité de la chaîne (.*) et revient à la première occurrence où [xyz] peut égaler. Il réussit si [xyz] est trouvé, il ne parvient pas autrement.

L'alternative consisterait à l'aide d'un réticents qualifier: (?=.*?[xyz]). Pour un mot, ce ne sera guère faire toute la différence, pour beaucoup plus de chaînes qu'il pourrait être le plus efficace variante.

La plupart variante plus efficace (mais plus difficile à lire et à maintenir, donc les plus sujettes à l'erreur) serait (?=[^xyz]*[xyz]), bien sûr. Pour une regex de cette longueur et de cette fin, je voudrais, dis-recommandons de le faire de cette façon, comme il n'a pas de réels avantages.

Toutes les déjà donné les réponses d'utiliser le même (bon) technique d'utiliser une anticipation pour chaque exigence. Mais ils contiennent un couple d'inefficacités et un gigantesque bug, selon le back-end qui va effectivement utiliser le mot de passe.

Je vais commencer avec la regex de la accepté de répondre:

^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])(?=\S+$).{8,}$

Tout d'abord, depuis Java prend en charge \A et \z je préfère utiliser ceux assurez-vous que l'ensemble de la chaîne est validé, indépendamment de Pattern.MULTILINE. Cela n'affecte pas les performances, mais évite les erreurs lors de la regexes sont recyclés.

\A(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])(?=\S+$).{8,}\z

De vérifier que les mots de passe ne doivent pas contenir d'espaces et de vérifier sa longueur minimale qui peut être fait en une seule passe par l'aide de tout cela à la fois en mettant la variable quantificateur {8,} sur le raccourci \S qui limite les caractères autorisés:

\A(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])\S{8,}\z

Si le mot de passe fourni contient un espace, de tous les contrôles seront effectués, uniquement pour avoir le contrôle final échouer sur l'espace. Ceci peut être évité par le remplacement de tous les points avec \S:

\A(?=\S*[0-9])(?=\S*[a-z])(?=\S*[A-Z])(?=\S*[@#$%^&+=])\S{8,}\z

La dot doit être utilisée que si vous désirez vraiment pour permettre à n'importe quel caractère. Sinon, utilisez un (annulés) classe de personnage à la limite de votre regex pour seulement ces personnages qui sont vraiment autorisé. S'il fait peu de différence dans ce cas, ne pas utiliser le point quand quelque chose d'autre est plus approprié est une très bonne habitude. Je vois beaucoup trop de cas de catastrophique mandature parce que le développeur était trop paresseux pour utiliser quelque chose de plus approprié que de la dot.

Car il ya une bonne chance les premiers tests permettra de trouver un personnage dans la première moitié du mot de passe, un paresseux quantificateur peut être plus efficace:

\A(?=\S*?[0-9])(?=\S*?[a-z])(?=\S*?[A-Z])(?=\S*?[@#$%^&+=])\S{8,}\z

Mais maintenant, pour la très importante question: aucune réponse ne mentionne le fait que la question d'origine semble être écrit par quelqu'un qui pense en ASCII. Mais en Java, les chaînes Unicode. Sont non-ASCII des caractères autorisés dans les mots de passe? Si elles le sont, ne sont ASCII des espaces non autorisés, ou devrait tous les espaces Unicode être exclus.

Par défaut \s correspond uniquement ASCII de l'espace, de sorte que son inverse \S correspond à tous les caractères Unicode (espaces ou pas) et tous les non-blanc caractères ASCII. Si des caractères Unicode sont permis, mais Unicode espaces ne sont pas, les UNICODE_CHARACTER_CLASS drapeau peut être spécifié pour faire \S exclure des espaces Unicode. Si des caractères Unicode ne sont pas autorisés, puis [\x21-\x7E] peut être utilisé à la place de \S pour correspondre à tous les caractères ASCII qui ne sont pas un espace ou un caractère de contrôle.

Qui nous amène à la prochaine question potentielle: voulons-nous laisser les caractères de contrôle? La première étape de l'écriture d'une bonne regex est de spécifier exactement ce que vous voulez et ce que vous n'avez pas. Le seul 100% techniquement réponse correcte est que le mot de passe de la spécification de la question est ambigu, car il ne prend pas en état de savoir si certaines des plages de caractères, comme le contrôle des caractères ou des caractères non-ASCII sont autorisés ou non.

Exigence De Mot De Passe :

• Mot de passe doit être d'au moins huit (8) caractères où le système peut supporter.

• Mots de passe doit contenir des caractères d'au moins deux (2) de ces groupements: lettres, des chiffres et des caractères spéciaux.

  ^.*(?=.{8,})(?=.*\d)(?=.*[a-zA-Z])|(?=.{8,})(?=.*\d)(?=.*[!@#$%^&])|(?=.{8,})(?=.*[a-zA-Z])(?=.*[!@#$%^&]).*$

Je l'ai testé et il fonctionne

Celui-ci vérifie pour chaque caractère spécial :

^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=\S+$).*[A-Za-z0-9].{8,}$

Je pense que cela peut le faire aussi (comme un simple mode):

^(?=.*\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])[^\s]{8,}$

[Regex Demo]

String s=pwd;
int n=0;
for(int i=0;i<s.length();i++)
{
    if((Character.isDigit(s.charAt(i))))
    {
        n=5;
        break;
    }
    else
    {

    }
}
for(int i=0;i<s.length();i++)
{
    if((Character.isLetter(s.charAt(i))))
    {
        n+=5;
        break;
    }
    else
    {

    }

}

if(n==10)
{
    out.print("Password format correct <b>Accepted</b><br>");

}
else
{
    out.print("Password must be alphanumeric <b>Declined</b><br>");
}

Explication:

1. D'abord définir le mot de passe comme une chaîne de caractères et de créer ensemble d'entiers o.
2. Puis vérifier le chaque et chaque char en boucle.
3. Si il trouve le numéro de la chaîne, puis la n de l'ajouter 5. Passez ensuite à l'
   à côté de la boucle. Caractère.appel isdigit(s).charAt(i))
4. Cette boucle de vérifier toute alphabets placé dans la chaîne. Si son trouver alors
   ajouter un plus de 5 à n. Caractère.isLetter(s).charAt(i))
5. Maintenant vérifier l'entier n par la voie de la condition if. Si n=10 est vrai
   chaîne alphanumérique, ailleurs son ne pas.