L'expression régulière du mot de passe doit contenir au moins huit caractères, au moins un chiffre et des lettres minuscules et majuscules et des caractères spéciaux

448

Je veux une expression régulière pour vérifier que:

Un mot de passe contient au moins huit caractères, dont au moins un chiffre et comprend les lettres majuscules et minuscules et des caractères spéciaux, par exemple #, ?, !.

Il ne peut pas s'agir de votre ancien mot de passe ou contenir votre nom d'utilisateur "password", ou"websitename"

Et voici mon expression de validation qui est pour huit caractères dont une lettre majuscule, une lettre minuscule et un chiffre ou caractère spécial.

(?=^.{8,}$)((?=.*\d)|(?=.*\W+))(?![.\n])(?=.*[A-Z])(?=.*[a-z]).*$"

Comment puis-je l'écrire pour un mot de passe doit être composé de huit caractères dont une lettre majuscule, un caractère spécial et des caractères alphanumériques ?

Swapnil Tatkondawar
la source

Réponses:

1185

Huit caractères au minimum, au moins une lettre et un chiffre:

"^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d]{8,}$"

Huit caractères au moins, au moins une lettre, un chiffre et un caractère spécial:

"^(?=.*[A-Za-z])(?=.*\d)(?=.*[@$!%*#?&])[A-Za-z\d@$!%*#?&]{8,}$"

Huit caractères au minimum, au moins une lettre majuscule, une lettre minuscule et un chiffre:

"^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[a-zA-Z\d]{8,}$"

Huit caractères au moins, au moins une lettre majuscule, une lettre minuscule, un chiffre et un caractère spécial:

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

Huit et dix caractères au minimum, au moins une lettre majuscule, une lettre minuscule, un chiffre et un caractère spécial:

"^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,10}$"
Srinivas
la source
46
"^ (? =. * [A-Za-z]) (? =. * \ D) [A-Za-z \ d] {8,} $" n'autorise pas les symboles comme l'un des 8 caractères
Wee
J'ai trouvé ce qui suit autorisé pour tous les caractères (spécial et ponctuation), sans les rendre obligatoires: "^ (? =. * [Az]) (? =. * [AZ]) (? =. * \ D) [a- zA-Z \ d \ w \ W] {8,} $ "
Gavin
le mot de passe doit toujours avoir exactement le même ordre. que dire de quelque chose de plus générique qui peut commencer par des majuscules ou des caractères spéciaux.
Ichinga Samuel
414

Vous pouvez utiliser cette expression régulière avec plusieurs assertions d'anticipation (conditions) :

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

Cette expression régulière appliquera ces règles:

  • Au moins une lettre majuscule en anglais ,(?=.*?[A-Z])
  • Au moins une lettre minuscule en anglais, (?=.*?[a-z])
  • Au moins un chiffre, (?=.*?[0-9])
  • Au moins un caractère spécial, (?=.*?[#?!@$%^&*-])
  • Longueur minimale de huit .{8,}(avec les ancres)
anubhava
la source
71

Les expressions régulières n'ont pas d'opérateur ET, il est donc assez difficile d'écrire une expression régulière qui correspond à des mots de passe valides, lorsque la validité est définie par quelque chose ET quelque chose d'autre ET quelque chose d'autre ...

Mais, les expressions régulières ont un opérateur OU, alors appliquez simplement le théorème de DeMorgan et écrivez une expression régulière qui correspond aux mots de passe invalides:

Tout ce qui contient moins de huit caractères OU tout ce qui n'a pas de chiffres OU tout ce qui n'est pas en majuscule OU ou quoi que ce soit sans minuscule OU quoi que ce soit sans caractère spécial.

Donc:

^(.{0,7}|[^0-9]*|[^A-Z]*|[^a-z]*|[a-zA-Z0-9]*)$

Si quelque chose correspond à cela, alors c'est un mot de passe invalide.

Matt Timmermans
la source
3
D'accord, j'avais peur que vous fassiez partie de ces informaticiens que nous rencontrons parfois et qui ne réalisent pas qu'il y a une différence entre les expressions régulières et les expressions rationnelles . ;) Il est vrai que de nombreuses tâches d'expression régulière sont beaucoup plus simples si vous pouvez annuler le résultat du match par la suite, mais ce n'est pas toujours possible. C'est une belle expression régulière, cependant. Ce n'est pas simple, c'est élégant!
Alan Moore
1
Pourquoi je n'y ai pas pensé avant? Grande réponse (quand il est possible d'annuler le résultat)
TeChn4K
2
celui-ci permet aux espaces comment vérifier qu'un mot de passe ne doit pas contenir d'espace avec votre expression régulière? j'ai essayé ceci /^(\s|.{0,7}|[^0-9[*|$^AZAZ**|$^az Sloven*||^^## %%**|\s)$/ .test ('aAa # a1a aa'); mais cela ne fonctionne pas
Gaurav
1
@Gaurav, ajoutez | [^ \ s] * \ s. *
Matt Timmermans
1
Aimer. Pour que cela fonctionne, cependant, j'ai dû supprimer la dernière clause |[a-zA-Z0-9]*.
i--
36

Juste une petite amélioration pour la réponse de @ anubhava: Étant donné que les caractères spéciaux sont limités à ceux du clavier, utilisez-le pour tout caractère spécial:

^(?=.*?[A-Z])(?=(.*[a-z]){1,})(?=(.*[\d]){1,})(?=(.*[\W]){1,})(?!.*\s).{8,}$

Cette expression régulière appliquera ces règles:

  • Au moins une lettre anglaise majuscule
  • Au moins une lettre minuscule en anglais
  • Au moins un chiffre
  • Au moins un caractère spécial
  • Longueur minimale de huit
Edwin Beltran
la source
1
Dans la version JavaScript, \Wcorrespond uniquement aux caractères ASCII. Vous n'avez donc pas changé cela, et maintenant vous devez filtrer les espaces. De plus, toutes les parenthèses et {1,}quantificateurs que vous avez ajoutés sont du bruit pur, et la suppression des ?opérateurs non gourmands ( ) était inutile. Il n'y a aucune amélioration ici.
Alan Moore,
Et comment éviter pour une chaîne vide. Une expression rationnelle de chaîne vide doit renvoyer true. J'ai utilisé l'expression régulière suivante (? =. * [0-9]) (? =. * [Az]) (? =. * [AZ]) (? =. * [@ # $% ^ & + =]) (? = \\ S + $). {8,15}
Codeur
2
échoue pour _ caractère spécial
Akhilesh
22

J'ai eu quelques difficultés à suivre la réponse la plus populaire pour ma situation. Par exemple, ma validation échouait avec des caractères tels que ;ou [. Je n'étais pas intéressé par la mise en liste blanche de mes caractères spéciaux, alors j'ai plutôt utilisé [^\w\s]comme test - simplement - des caractères non verbaux (y compris numériques) et des espaces non blancs. Pour résumer, voici ce qui a fonctionné pour moi ...

  • au moins des 8personnages
  • au moins 1un caractère numérique
  • au moins une 1lettre minuscule
  • au moins une 1lettre majuscule
  • au moins 1caractère spécial

/^(?=.*?[A-Z])(?=.*?[a-z])(?=.*?[0-9])(?=.*?[^\w\s]).{8,}$/

JSFiddle Link - démo simple couvrant divers cas

scniro
la source
2
Joli. mais nous avons trouvé un problème que votre expression régulière n'acceptera pas _ (soulignement) comme caractère spécial :(.
user3217843
Bon, mais peu d'erreurs.Il accepte également l'espace qui n'est pas un mot de passe valide si nous utilisons l'espace.
Dinesh.net
J'aime vraiment cette réponse, sauf qu'elle ne peut pas accepter les soulignés. Tout ce que j'ai fait a été de remplacer (?=.*?[^\w\s])par (?=.*?([^\w\s]|[_]))pour ajouter un support pour les traits de soulignement et cela fonctionne très bien maintenant. De plus, @ Dinish.net, le système que j'utilise coupe l'espace blanc de la chaîne de mot de passe lorsque nous l'obtenons, donc l'utilisation de la méthode vanilla JS String.prototype.trim () fonctionnerait bien si vous souhaitez utiliser cette réponse.
Devin Carpenter
15

Une version plus "générique" (?), N'autorisant aucune lettre anglaise comme caractère spécial .

^(?=\S*[a-z])(?=\S*[A-Z])(?=\S*\d)(?=\S*[^\w\s])\S{8,}$

var pwdList = [
    '@@V4-\3Z`zTzM{>k',
    '12qw!"QW12',
    '123qweASD!"#',
    '1qA!"#$%&',
    'Günther32',
    '123456789',
    'qweASD123',
    'qweqQWEQWEqw',
    '12qwAS!'
  ],
  re = /^(?=\S*[a-z])(?=\S*[A-Z])(?=\S*\d)(?=\S*[^\w\s])\S{8,}$/;
  
  pwdList.forEach(function (pw) {
    document.write('<span style="color:'+ (re.test(pw) ? 'green':'red') + '">' + pw + '</span><br/>');
  });

SamWhan
la source
13

Importez le fichier JavaScript jquery.validate.min.js.

Vous pouvez utiliser cette méthode:

$.validator.addMethod("pwcheck", function (value) {
    return /[\@\#\$\%\^\&\*\(\)\_\+\!]/.test(value) && /[a-z]/.test(value) && /[0-9]/.test(value) && /[A-Z]/.test(value)
});
  1. Au moins une lettre anglaise majuscule
  2. Au moins une lettre minuscule en anglais
  3. Au moins un chiffre
  4. Au moins un caractère spécial
Vikram
la source
10

Essaye celui-là:

  1. Minimum six caractères
  2. Au moins un caractère majuscule
  3. Au moins un caractère minuscule
  4. Au moins un caractère spécial

Expression:

"/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[$@$!%*?&.])[A-Za-z\d$@$!%*?&.]{6, 20}/"

Caractères spéciaux facultatifs:

  1. Au moins un caractère spécial
  2. Au moins un numéro
  3. Les caractères spéciaux sont facultatifs
  4. Minimum six caractères et maximum 16 caractères

Expression:

"/^(?=.*\d)(?=.*[a-zA-Z]).{6,20}$/"

Si la condition min et max n'est pas requise, supprimez .{6, 16}

  • 6 est la limite de caractères minimum
  • 20 est la limite maximale de caractères
  • ? = signifie expression de correspondance
ojus kulkarni
la source
2
@Madhu J'ai mis à jour ma réponse pour votre condition pour les caractères spéciaux optionnels
ojus kulkarni
7

Ne répondant pas directement à la question, mais faut-il vraiment que ce soit une expression régulière?

J'avais l'habitude de faire beaucoup de Perl et de m'habituer à résoudre des problèmes avec des expressions rationnelles. Cependant, quand ils deviennent plus compliqués avec toutes les perspectives et autres bizarreries, vous devez écrire des dizaines de tests unitaires pour tuer tous ces petits bugs.

De plus, une expression régulière est généralement quelques fois plus lente qu'une solution impérative ou fonctionnelle.

Par exemple, la fonction Scala suivante (pas très FP) résout la question d'origine environ trois fois plus rapidement que l'expression régulière de la réponse la plus populaire. Ce qu'il fait est également si clair que vous n'avez pas du tout besoin d'un test unitaire:

def validatePassword(password: String): Boolean = {
  if (password.length < 8)
    return false

  var lower = false
  var upper = false
  var numbers = false
  var special = false

  password.foreach { c =>
    if (c.isDigit)       numbers = true
    else if (c.isLower)  lower = true
    else if (c.isUpper)  upper = true
    else                 special = true
  }

  lower && upper && numbers && special
}
Heikki Salokanto
la source
7

Je répondrais à Peter Mortensen, mais je n'ai pas assez de réputation.

Ses expressions sont parfaites pour chacune des exigences minimales spécifiées. Le problème avec ses expressions qui ne nécessitent pas de caractères spéciaux est qu'elles n'autorisent pas non plus les caractères spéciaux, elles imposent donc également des exigences maximales, ce que je ne crois pas que l'OP ait demandé. Normalement, vous voulez permettre à vos utilisateurs de rendre leur mot de passe aussi fort qu'ils le souhaitent; pourquoi restreindre les mots de passe forts?

Ainsi, son expression "au moins huit caractères, au moins une lettre et un chiffre":

^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d]{8,}$

atteint l'exigence minimale, mais les caractères restants ne peuvent être que des lettres et des chiffres. Pour autoriser (mais pas exiger) des caractères spéciaux, vous devez utiliser quelque chose comme:

^(?=.*[A-Za-z])(?=.*\d).{8,}$ pour autoriser tous les caractères

ou

^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d$@$!%*#?&]{8,}$ pour autoriser des caractères spéciaux spécifiques

De même, "au moins huit caractères, au moins une lettre majuscule, une lettre minuscule et un chiffre:"

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[a-zA-Z\d]{8,}$

répond à cette exigence minimale, mais autorise uniquement les lettres et les chiffres. Utilisation:

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{8,}$ pour autoriser tous les caractères

ou

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[A-Za-z\d$@$!%*?&]{8,} pour autoriser des caractères spéciaux spécifiques.

deathwombat
la source
Merci pour l'explication.
Hải Nguyễn
Cela devrait être marqué comme la bonne réponse. La première réponse est fausse.
Jake
6
Use the following Regex to satisfy the below conditions:

Conditions: 1] Min 1 uppercase letter.
            2] Min 1 lowercase letter.
            3] Min 1 special character.
            4] Min 1 number.
            5] Min 8 characters.
            6] Max 30 characters.

Regex: /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[#$@!%&*?])[A-Za-z\d#$@!%&*?]{8,30}$/    
SHASHANK HONRAO
la source
2
En quoi votre réponse est-elle meilleure que les autres réponses écrites il y a des années?
JSantos
@ JoshYates1980 pouvez-vous s'il vous plaît mentionner le "caractère spécial" pour lequel l'expression régulière a échoué pour vous. Permettez-moi de vérifier cela et de le mettre à jour en conséquence. Mais pour autant que je sache, cela fonctionne avec tous selon la condition de mandat de 1 caractère spécial. En attente de votre réponse ....
SHASHANK HONRAO
1
@SHASHANKHONRAO J'ai mis à jour l'expression en: ^ (? =. * [Az]) (? =. * [AZ]) (? =. * \ D) (? =. * [$ @ $!% *? & + + ~ |{}:;<>/])[A-Za-z\d$@$!%*?&+~| {}:; <> /] {8,15} qui comprendra les caractères non alphanumériques suivants: (@ $!% *? & + ~ `| {}
:;
6

Qu'en est-il de la solution regex suivante:

^(?=.*[\w])(?=.*[\W])[\w\W]{8,}$

Ce qui valide les éléments suivants:

  1. Au moins un minuscule
  2. Au moins un majuscule
  3. Au moins un chiffre
  4. Au moins un caractère spécial
  5. Au moins, il doit contenir 8 caractères.

Découvrez-le en travaillant sur le lien suivant https://regex101.com/r/qPmC06/4/

Emerson Joel Rojas Soliz
la source
Votre regex suggéré et celui sous le lien regex101 varient. N'est-ce pas ^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[\W\_])[A-Za-z\d\W\_]{8,}$?
CraZ
1
@CraZ J'ai édité l'expression régulière, merci pour votre suggestion.
Emerson Joel Rojas Soliz
3

Selon votre besoin, ce modèle devrait très bien fonctionner. Essaye ça,

^(?=(.*\d){1})(.*\S)(?=.*[a-zA-Z\S])[0-9a-zA-Z\S]{8,}

Il suffit de créer une variable chaîne, d'assigner le modèle et de créer une méthode booléenne qui renvoie vrai si le modèle est correct, sinon faux.

Échantillon:

String pattern = "^(?=(.*\d){1})(.*\S)(?=.*[a-zA-Z\S])[0-9a-zA-Z\S]{8,}";
String password_string = "Type the password here"

private boolean isValidPassword(String password_string) {
    return password_string.matches(Constants.passwordPattern);
}
Arun Sivanandan
la source
3

J'ai trouvé beaucoup de problèmes ici, alors j'ai fait le mien.

La voici dans toute sa splendeur, avec des tests:

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*([^a-zA-Z\d\s])).{9,}$

https://regex101.com/r/DCRR65/4/tests

À surveiller:

  1. n'utilise pas \wparce que cela inclut _, que je teste.
  2. J'ai eu beaucoup de problèmes pour faire correspondre les symboles, sans faire correspondre la fin de la ligne.
  3. Ne spécifie pas spécifiquement les symboles, cela est également dû au fait que différents paramètres régionaux peuvent avoir différents symboles sur leurs claviers qu'ils peuvent vouloir utiliser.
Stefano
la source
Cette expression régulière passe même lorsque les espaces blancs se trouvent dans le mot de passe, n'a pas fonctionné pour moi
Arthur Melo
2

@ClasG a déjà suggéré :

^(?=\S*[a-z])(?=\S*[A-Z])(?=\S*\d)(?=\S*[^\w\s])\S{8,}$

mais il n'accepte pas _ (trait de soulignement) comme caractère spécial (par exemple, Aa12345_).

Une amélioration est:

^(?=\S*[a-z])(?=\S*[A-Z])(?=\S*\d)(?=\S*([^\w\s]|[_]))\S{8,}$
SONewbiee
la source
2

Démo:

function password_check() {
  pass = document.getElementById("password").value;
  console.log(pass);
  regex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/;
  if (regex.exec(pass) == null) {
    alert('invalid password!')
  }
  else {
    console.log("valid");
  }
}
<input type="text" id="password" value="Sample@1">
<input type="button" id="submit" onclick="password_check()" value="submit">

Mohideen bin Mohammed
la source
2

Test de celui-ci en 2020:

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

Vérifiez-vous

const regex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/;
const str = `some12*Nuts`;
let m;

if ((m = regex.exec(str)) !== null) {
    // The result can be accessed through the `m`-variable.
    m.forEach((match, groupIndex) => {
        console.log(`Found match, group ${groupIndex}: ${match}`);
    });
}

Mihir Kumar
la source
Comment est-ce mieux que la réponse acceptée?
Toto
@Toto il n'y a pas de réponse acceptée sur ce fil, au moins je n'en vois pas, il y a des réponses avec beaucoup de votes mais je ne vois pas de réponse acceptée. De plus, j'ai trouvé celui-ci et lu à ce sujet sur regex101 pour la validité, alors je l'ai partagé avec un extrait de code pour vérifier la validité aussi.
Mihir Kumar
1

Utilisez le Regex suivant pour satisfaire les conditions ci-dessous:

Conditions: 1] Min 1 special character.
            2] Min 1 number.
            3] Min 8 characters or More

Regex: ^(?=.*\d)(?=.*[#$@!%&*?])[A-Za-z\d#$@!%&*?]{8,}$

Peut tester en ligne: https://regex101.com

Samrat Saha
la source
1

Nous pouvons simplement le faire en utilisant HTML5.

Utilisez le code ci-dessous dans l'attribut de modèle,

pattern="(?=^.{8,}$)((?=.*\d)(?=.*\W+))(?![.\n])(?=.*[A-Z])(?=.*[a-z]).*$"

Cela fonctionnera parfaitement.

Vidya
la source
1

Vous pouvez utiliser le modèle d'expression régulière ci-dessous pour vérifier le mot de passe s'il correspond à vos attentes ou non.

((?=.*\\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[~!@#$%^&*()]).{8,20})
Harshal_Kalavadiya
la source
1

Utilisez ceci,

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

Il validera au moins un minuscule, un majuscule, un nombre et les caractères spéciaux de (!, @, #, $,%,?, =, *, &).

La longueur minimale est de 8 et la longueur maximale est de 20

Anand Raja
la source
En quoi est-ce différent de la réponse acceptée?
Toto
0

En Java / Android, pour tester un mot de passe avec au moins un chiffre, une lettre, un caractère spécial dans le schéma suivant:

"^(?=.*[A-Za-z])(?=.*\\d)(?=.*[$@$!%*#?&])[A-Za-z\\d$@$!%*#?&]{8,}$"
Dadaji
la source
0

Essaye ça:

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

Cette expression régulière fonctionne parfaitement pour moi.

function myFunction() {
    var str = "c1TTTTaTTT@";
    var patt = new RegExp("^.*(?=.{8,})(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])[a-zA-Z0-9@#$%^&+=]*$");
    var res = patt.test(str);
    console.log("Is regular matches:", res);
}
Kiwi Rupela
la source
0

Motif pour correspondre à au moins 1 caractère majuscule, 1 chiffre et tout caractère spécial et la longueur entre 8 à 63.

"^ (? =. [az]) (? =. [AZ]) (? =. * \ d) [a-zA-Z \ d \ W] {8,63} $"

Ce modèle a été utilisé pour la programmation JAVA.

Anup Seth
la source
0

J'espère que les travaux ci-dessous. J'ai essayé cela dans la stratégie personnalisée Azure.

^ (? =. [az]) (? =. [AZ]) (? =. \ d) (? =. [@ # $% ^ & * -_ + = [] {} | \: ',? / ~&quot;();!])([A-Za-z\d@#$%^&amp;*\-_+=[\]{}|\\:',?/~ "() ;!] |. (?! @)) {6,16} $

Venkatesh
la source
0

En fait, je viens de copier la première réponse ici et de la transformer en une expression rationnelle plus pratique qui nécessite un caractère supérieur, un caractère inférieur et au moins 8 caractères, mais accepte tout "entre les deux".

Celui-ci est un exemple-regex qui nécessite

  1. longueur d'au moins 8 caractères
  2. au moins une lettre minuscule
  3. au moins une lettre majuscule

IMPORTANT : Cette expression régulière exclura également tous les autres caractères, par exemple les chiffres, les caractères spéciaux tels que $, #,! etc. - tant que les règles 1. à 3. correspondent à la chaîne d'entrée

^(?=.*[a-z])(?=.*[A-Z]).{8,}$

Attention au "." alomst à la fin de l'expression régulière. Cela correspondra à presque tous les caractères (et afaik tout lisible)

Frithjof Schaefer
la source
0

Si vous souhaitez utiliser des expressions régulières pour vérifier au moins huit caractères, au moins une lettre majuscule, au moins une lettre minuscule, au moins un chiffre de 0 à 9 et au moins un caractère spécial de:! @ # $% ^ & * _? ET donnez également à l'utilisateur un peu plus d'informations sur ce qu'il manque dans le mot de passe, vous pouvez utiliser le code suivant:

let password = "@Aa3a4d$";

//  Check every single condition separately
let lowercase = password.match((/[a-z]+/g));
let uppercase = password.match((/[A-Z]+/g));
let digits = password.match((/[\d]+/g));
let special = password.match((/[!@#$%^&*_]+/g));
let lenght = password.match((/[A-Za-z\d!@#$%^&*_]{8,}/g));

//  Array to store information about any mismatches in the string
let errors = [];

if (password === '' ) {
    errors.push('Password is required');
}
if (lowercase === null) {
    errors.push('Password must include at least one lowercase letter');
}
if (uppercase === null) {
    errors.push('Password must include at least one uppercase letter');
}
if (digits === null) {
    errors.push('Password must include at least one digit from 0 to 9');
}
if (special  === null) {
    errors.push('Password must include at least one special character');
}
if (lenght === null) {
    errors.push('Password must include at least 8 characters');
}
if (errors.length > 0) {
    console.log(errors);
    return;
} else {
    // Process your password
}
Tours
la source
-1

Une solution que j'ai trouvée dans l'une des réponses précédentes:

* Minimum 8 caractères au moins 1 alphabet majuscule, 1 alphabet minuscule, 1 chiffre et 1 caractère spécial:

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

... n'a pas fonctionné pour moi, mais ce qui suit est une version simplifiée et fonctionne très bien (ajoutez n'importe quel caractère spécial que vous aimez, j'ai ajouté # ici), et ajoutez la règle numérique comme vous le faites avec les lettres comme:

"^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[$@$!%*?&]){8,}"
Carette
la source
1
Il s'agit de quantifier une anticipation positive.
ctwheels